code
stringlengths
81
54k
code_codestyle
int64
0
721
style_context
stringlengths
91
41.9k
style_context_codestyle
int64
0
699
label
int64
0
1
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging a_ : str = logging.get_logger(__name__) a_ : Any = { '''facebook/encodec_24khz''': '''https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json''', '''facebook/encodec_48khz''': '''https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json''', } class UpperCamelCase ( __a ): __UpperCamelCase ='''encodec''' def __init__( self : List[Any] , snake_case__ : str=[1.5, 3.0, 6.0, 12.0, 24.0] , snake_case__ : int=2_4_0_0_0 , snake_case__ : Any=1 , snake_case__ : Optional[int]=False , snake_case__ : Tuple=None , snake_case__ : Optional[int]=None , snake_case__ : str=1_2_8 , snake_case__ : Tuple=3_2 , snake_case__ : Optional[int]=1 , snake_case__ : Dict=[8, 5, 4, 2] , snake_case__ : List[Any]="weight_norm" , snake_case__ : Union[str, Any]=7 , snake_case__ : Optional[int]=7 , snake_case__ : List[Any]=3 , snake_case__ : Optional[int]=2 , snake_case__ : List[str]=True , snake_case__ : str="reflect" , snake_case__ : int=2 , snake_case__ : Union[str, Any]=2 , snake_case__ : str=1.0 , snake_case__ : str=1_0_2_4 , snake_case__ : str=None , snake_case__ : List[Any]=True , **snake_case__ : Any , ): """simple docstring""" SCREAMING_SNAKE_CASE = target_bandwidths SCREAMING_SNAKE_CASE = sampling_rate SCREAMING_SNAKE_CASE = audio_channels SCREAMING_SNAKE_CASE = normalize SCREAMING_SNAKE_CASE = chunk_length_s SCREAMING_SNAKE_CASE = overlap SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_filters SCREAMING_SNAKE_CASE = num_residual_layers SCREAMING_SNAKE_CASE = upsampling_ratios SCREAMING_SNAKE_CASE = norm_type SCREAMING_SNAKE_CASE = kernel_size SCREAMING_SNAKE_CASE = last_kernel_size SCREAMING_SNAKE_CASE = residual_kernel_size SCREAMING_SNAKE_CASE = dilation_growth_rate SCREAMING_SNAKE_CASE = use_causal_conv SCREAMING_SNAKE_CASE = pad_mode SCREAMING_SNAKE_CASE = compress SCREAMING_SNAKE_CASE = num_lstm_layers SCREAMING_SNAKE_CASE = trim_right_ratio SCREAMING_SNAKE_CASE = codebook_size SCREAMING_SNAKE_CASE = codebook_dim if codebook_dim is not None else hidden_size SCREAMING_SNAKE_CASE = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( F"""self.norm_type must be one of `\"weight_norm\"`, `\"time_group_norm\"`), got {self.norm_type}""" ) super().__init__(**snake_case__ ) @property def UpperCamelCase ( self : Any ): """simple docstring""" if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def UpperCamelCase ( self : str ): """simple docstring""" if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def UpperCamelCase ( self : str ): """simple docstring""" return int(1_0_0_0 * self.target_bandwidths[-1] // (self.frame_rate * 1_0) )
706
import unittest from parameterized import parameterized from transformers import OpenLlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel class UpperCamelCase : def __init__( self : Dict , snake_case__ : str , snake_case__ : str=1_3 , snake_case__ : Tuple=7 , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : List[str]=False , snake_case__ : Any=True , snake_case__ : Union[str, Any]=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Optional[Any]=5 , snake_case__ : Optional[Any]=4 , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Tuple="gelu" , snake_case__ : Dict=0.1 , snake_case__ : Any=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Dict=1_6 , snake_case__ : str=2 , snake_case__ : Any=0.02 , snake_case__ : List[str]=3 , snake_case__ : int=4 , snake_case__ : List[str]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Dict ): """simple docstring""" return OpenLlamaConfig( 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=snake_case__ , initializer_range=self.initializer_range , use_stable_embedding=snake_case__ , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : int , snake_case__ : List[str] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : Tuple , ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : int , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() # first forward pass SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , use_cache=snake_case__ , ) SCREAMING_SNAKE_CASE = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([input_mask, next_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , past_key_values=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else () ) __UpperCamelCase =(OpenLlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": OpenLlamaModel, "text-classification": OpenLlamaForSequenceClassification, "text-generation": OpenLlamaForCausalLM, "zero-shot": OpenLlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'single_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test' ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" pass @parameterized.expand([('linear',), ('dynamic',)] ) def UpperCamelCase ( self : str , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = ids_tensor([1, 1_0] , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) original_model.to(snake_case__ ) original_model.eval() SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = {'type': scaling_type, 'factor': 10.0} SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) scaled_model.to(snake_case__ ) scaled_model.eval() SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) else: self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
673
0
import warnings from diffusers import StableDiffusionImgaImgPipeline # noqa F401 warnings.warn( "The `image_to_image.py` script is outdated. Please use directly `from diffusers import" " StableDiffusionImg2ImgPipeline` instead." )
707
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="openai/whisper-base" __UpperCamelCase =( "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the " "transcribed text." ) __UpperCamelCase ="transcriber" __UpperCamelCase =WhisperProcessor __UpperCamelCase =WhisperForConditionalGeneration __UpperCamelCase =["audio"] __UpperCamelCase =["text"] def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.pre_processor(snake_case__ , return_tensors='pt' ).input_features def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" return self.model.generate(inputs=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : Union[str, Any] ): """simple docstring""" return self.pre_processor.batch_decode(snake_case__ , skip_special_tokens=snake_case__ )[0]
673
0
import os import sys import unittest a_ : List[Any] = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, "utils")) import check_dummies # noqa: E402 from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402 # Align TRANSFORMERS_PATH in check_dummies with the current path a_ : Tuple = os.path.join(git_repo_path, "src", "diffusers") class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = find_backend(' if not is_torch_available():' ) self.assertEqual(snake_case__ , 'torch' ) # backend_with_underscore = find_backend(" if not is_tensorflow_text_available():") # self.assertEqual(backend_with_underscore, "tensorflow_text") SCREAMING_SNAKE_CASE = find_backend(' if not (is_torch_available() and is_transformers_available()):' ) self.assertEqual(snake_case__ , 'torch_and_transformers' ) # double_backend_with_underscore = find_backend( # " if not (is_sentencepiece_available() and is_tensorflow_text_available()):" # ) # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text") SCREAMING_SNAKE_CASE = find_backend( ' if not (is_torch_available() and is_transformers_available() and is_onnx_available()):' ) self.assertEqual(snake_case__ , 'torch_and_transformers_and_onnx' ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = read_init() # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects self.assertIn('torch' , snake_case__ ) self.assertIn('torch_and_transformers' , snake_case__ ) self.assertIn('flax_and_transformers' , snake_case__ ) self.assertIn('torch_and_transformers_and_onnx' , snake_case__ ) # Likewise, we can't assert on the exact content of a key self.assertIn('UNet2DModel' , objects['torch'] ) self.assertIn('FlaxUNet2DConditionModel' , objects['flax'] ) self.assertIn('StableDiffusionPipeline' , objects['torch_and_transformers'] ) self.assertIn('FlaxStableDiffusionPipeline' , objects['flax_and_transformers'] ) self.assertIn('LMSDiscreteScheduler' , objects['torch_and_scipy'] ) self.assertIn('OnnxStableDiffusionPipeline' , objects['torch_and_transformers_and_onnx'] ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = create_dummy_object('CONSTANT' , '\'torch\'' ) self.assertEqual(snake_case__ , '\nCONSTANT = None\n' ) SCREAMING_SNAKE_CASE = create_dummy_object('function' , '\'torch\'' ) self.assertEqual( snake_case__ , '\ndef function(*args, **kwargs):\n requires_backends(function, \'torch\')\n' ) SCREAMING_SNAKE_CASE = '\nclass FakeClass(metaclass=DummyObject):\n _backends = \'torch\'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, \'torch\')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, \'torch\')\n' SCREAMING_SNAKE_CASE = create_dummy_object('FakeClass' , '\'torch\'' ) self.assertEqual(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = '# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, [\"torch\"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = [\"torch\"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, [\"torch\"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, [\"torch\"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, [\"torch\"])\n' SCREAMING_SNAKE_CASE = create_dummy_files({'torch': ['CONSTANT', 'function', 'FakeClass']} ) self.assertEqual(dummy_files['torch'] , snake_case__ )
708
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
673
0
# Algorithm for the pigeonhole sorting def __lowerCAmelCase ( _UpperCamelCase : str ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = min(_A ) # min() finds the minimum value SCREAMING_SNAKE_CASE = max(_A ) # max() finds the maximum value SCREAMING_SNAKE_CASE = max_val - min_val + 1 # size is difference of max and min values plus one # list of pigeonholes of size equal to the variable size SCREAMING_SNAKE_CASE = [0] * size # Populate the pigeonholes. for x in a: assert isinstance(_A , _A ), "integers only please" holes[x - min_val] += 1 # Putting the elements back into the array in an order. SCREAMING_SNAKE_CASE = 0 for count in range(_A ): while holes[count] > 0: holes[count] -= 1 SCREAMING_SNAKE_CASE = count + min_val i += 1 def __lowerCAmelCase ( ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = [8, 3, 2, 7, 4, 6, 8] pigeonhole_sort(_A ) print('Sorted order is:' , ' '.join(_A ) ) if __name__ == "__main__": main()
709
import numpy as np def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return 1 / (1 + np.exp(-vector )) def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return vector * sigmoid(_UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
673
0
def __lowerCAmelCase ( _UpperCamelCase : Tuple = 10**12 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = 0 SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = 1 while numerator <= 2 * min_total - 1: prev_numerator += 2 * numerator numerator += 2 * prev_numerator prev_denominator += 2 * denominator denominator += 2 * prev_denominator return (denominator + 1) // 2 if __name__ == "__main__": print(F"""{solution() = }""")
710
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
673
0
from __future__ import annotations from random import choice def __lowerCAmelCase ( _UpperCamelCase : Optional[int] ) -> int: '''simple docstring''' return choice(_UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : List[str] ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = random_pivot(_UpperCamelCase ) # partition based on pivot # linear time SCREAMING_SNAKE_CASE = [e for e in lst if e < pivot] SCREAMING_SNAKE_CASE = [e for e in lst if e > pivot] # if we get lucky, pivot might be the element we want. # we can easily see this: # small (elements smaller than k) # + pivot (kth element) # + big (elements larger than k) if len(_UpperCamelCase ) == k - 1: return pivot # pivot is in elements bigger than k elif len(_UpperCamelCase ) < k - 1: return kth_number(_UpperCamelCase , k - len(_UpperCamelCase ) - 1 ) # pivot is in elements smaller than k else: return kth_number(_UpperCamelCase , _UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
711
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
673
0
from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging a_ : List[Any] = logging.get_logger(__name__) # pylint: disable=invalid-name class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : int , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : Any , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : Tuple , snake_case__ : str , snake_case__ : int , snake_case__ : int , ): """simple docstring""" super().__init__() if hasattr(scheduler.config , 'steps_offset' ) and scheduler.config.steps_offset != 1: SCREAMING_SNAKE_CASE = ( F"""The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`""" F""" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure """ 'to update the config accordingly as leaving `steps_offset` might led to incorrect results' ' in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,' ' it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`' ' file' ) deprecate('steps_offset!=1' , '1.0.0' , __a , standard_warn=__a ) SCREAMING_SNAKE_CASE = dict(scheduler.config ) SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = FrozenDict(__a ) if hasattr(scheduler.config , 'skip_prk_steps' ) and scheduler.config.skip_prk_steps is False: SCREAMING_SNAKE_CASE = ( F"""The configuration file of this scheduler: {scheduler} has not set the configuration""" ' `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make' ' sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to' ' incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face' ' Hub, it would be very nice if you could open a Pull request for the' ' `scheduler/scheduler_config.json` file' ) deprecate('skip_prk_steps not set' , '1.0.0' , __a , standard_warn=__a ) SCREAMING_SNAKE_CASE = dict(scheduler.config ) SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = FrozenDict(__a ) if safety_checker is None: logger.warning( F"""You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure""" ' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered' ' results in services or applications open to the public. Both the diffusers team and Hugging Face' ' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling' ' it only for use-cases that involve analyzing network behavior or auditing its results. For more' ' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .' ) self.register_modules( segmentation_model=__a , segmentation_processor=__a , vae=__a , text_encoder=__a , tokenizer=__a , unet=__a , scheduler=__a , safety_checker=__a , feature_extractor=__a , ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] = "auto" ): """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory SCREAMING_SNAKE_CASE = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(__a ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" self.enable_attention_slicing(__a ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) SCREAMING_SNAKE_CASE = torch.device('cuda' ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(__a , __a ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self : Dict ): """simple docstring""" if self.device != torch.device('meta' ) or not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(__a , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self : Any , snake_case__ : List[Any] , snake_case__ : Tuple , snake_case__ : Tuple , snake_case__ : str = 5_1_2 , snake_case__ : Union[str, Any] = 5_1_2 , snake_case__ : List[str] = 5_0 , snake_case__ : List[str] = 7.5 , snake_case__ : List[str] = None , snake_case__ : int = 1 , snake_case__ : Optional[int] = 0.0 , snake_case__ : Union[str, Any] = None , snake_case__ : int = None , snake_case__ : Any = "pil" , snake_case__ : Dict = True , snake_case__ : Union[str, Any] = None , snake_case__ : Optional[Any] = 1 , **snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = self.segmentation_processor( text=[text] , images=[image] , padding='max_length' , return_tensors='pt' ).to(self.device ) SCREAMING_SNAKE_CASE = self.segmentation_model(**__a ) SCREAMING_SNAKE_CASE = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() SCREAMING_SNAKE_CASE = self.numpy_to_pil(__a )[0].resize(image.size ) # Run inpainting pipeline with the generated mask SCREAMING_SNAKE_CASE = StableDiffusionInpaintPipeline( vae=self.vae , text_encoder=self.text_encoder , tokenizer=self.tokenizer , unet=self.unet , scheduler=self.scheduler , safety_checker=self.safety_checker , feature_extractor=self.feature_extractor , ) return inpainting_pipeline( prompt=__a , image=__a , mask_image=__a , height=__a , width=__a , num_inference_steps=__a , guidance_scale=__a , negative_prompt=__a , num_images_per_prompt=__a , eta=__a , generator=__a , latents=__a , output_type=__a , return_dict=__a , callback=__a , callback_steps=__a , )
712
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : Dict = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Any , **snake_case__ : Optional[int] ): """simple docstring""" super().__init__(**snake_case__ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(snake_case__ ) def __call__( self : List[Any] , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(snake_case__ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {'image': image, 'candidate_labels': candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(snake_case__ , **snake_case__ ) return results def UpperCamelCase ( self : Union[str, Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs['threshold'] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs['top_k'] return {}, {}, postprocess_params def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs['candidate_labels'] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = self.tokenizer(snake_case__ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(snake_case__ , return_tensors=self.framework ) yield { "is_last": i == len(snake_case__ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**snake_case__ ) SCREAMING_SNAKE_CASE = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output['candidate_label'] SCREAMING_SNAKE_CASE = BaseModelOutput(snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=snake_case__ , threshold=snake_case__ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs['scores'][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {'score': score, 'label': label, 'box': box} results.append(snake_case__ ) SCREAMING_SNAKE_CASE = sorted(snake_case__ , key=lambda snake_case__ : x["score"] , reverse=snake_case__ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : List[Any] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
673
0
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : List[Any] = logging.get_logger(__name__) @add_end_docstrings(lowercase_ ) class UpperCamelCase ( lowercase_ ): def __init__( self : Tuple , **snake_case__ : Union[str, Any] ): """simple docstring""" super().__init__(**lowerCamelCase_ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(lowerCamelCase_ ) def __call__( self : int , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Tuple , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(lowerCamelCase_ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {"""image""": image, """candidate_labels""": candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(lowerCamelCase_ , **lowerCamelCase_ ) return results def UpperCamelCase ( self : str , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs["""threshold"""] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs["""top_k"""] return {}, {}, postprocess_params def UpperCamelCase ( self : int , snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs["""candidate_labels"""] if isinstance(lowerCamelCase_ , lowerCamelCase_ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(lowerCamelCase_ ): SCREAMING_SNAKE_CASE = self.tokenizer(lowerCamelCase_ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(lowerCamelCase_ , return_tensors=self.framework ) yield { "is_last": i == len(lowerCamelCase_ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**lowerCamelCase_ ) SCREAMING_SNAKE_CASE = {"""target_size""": target_size, """candidate_label""": candidate_label, """is_last""": is_last, **outputs} return model_outputs def UpperCamelCase ( self : int , snake_case__ : str , snake_case__ : List[str]=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output["""candidate_label"""] SCREAMING_SNAKE_CASE = BaseModelOutput(lowerCamelCase_ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=lowerCamelCase_ , threshold=lowerCamelCase_ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs["""scores"""][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {"""score""": score, """label""": label, """box""": box} results.append(lowerCamelCase_ ) SCREAMING_SNAKE_CASE = sorted(lowerCamelCase_ , key=lambda snake_case__ : x["score"] , reverse=lowerCamelCase_ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : Optional[int] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { """xmin""": xmin, """ymin""": ymin, """xmax""": xmax, """ymax""": ymax, } return bbox
713
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
673
0
def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : list[int] , _UpperCamelCase : int ) -> int: '''simple docstring''' def count_of_possible_combinations(_UpperCamelCase : int ) -> int: if target < 0: return 0 if target == 0: return 1 return sum(count_of_possible_combinations(target - item ) for item in array ) return count_of_possible_combinations(A__ ) def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : list[int] , _UpperCamelCase : int ) -> Optional[Any]: '''simple docstring''' def count_of_possible_combinations_with_dp_array( _UpperCamelCase : int , _UpperCamelCase : list[int] ) -> int: if target < 0: return 0 if target == 0: return 1 if dp_array[target] != -1: return dp_array[target] SCREAMING_SNAKE_CASE = sum( count_of_possible_combinations_with_dp_array(target - item , A__ ) for item in array ) SCREAMING_SNAKE_CASE = answer return answer SCREAMING_SNAKE_CASE = [-1] * (target + 1) return count_of_possible_combinations_with_dp_array(A__ , A__ ) def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : list[int] , _UpperCamelCase : int ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = [0] * (target + 1) SCREAMING_SNAKE_CASE = 1 for i in range(1 , target + 1 ): for j in range(A__ ): if i - array[j] >= 0: dp_array[i] += dp_array[i - array[j]] return dp_array[target] if __name__ == "__main__": import doctest doctest.testmod() a_ : List[str] = 3 a_ : str = 5 a_ : List[str] = [1, 2, 5] print(combination_sum_iv(n, array, target))
714
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
673
0
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging a_ : Tuple = logging.get_logger(__name__) a_ : Optional[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 ( _UpperCamelCase ): __UpperCamelCase ="xmod" def __init__( self : List[str] , snake_case__ : List[str]=3_0_5_2_2 , snake_case__ : Union[str, Any]=7_6_8 , snake_case__ : Tuple=1_2 , snake_case__ : List[Any]=1_2 , snake_case__ : Optional[int]=3_0_7_2 , snake_case__ : Dict="gelu" , snake_case__ : str=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : Dict=2 , snake_case__ : List[str]=0.02 , snake_case__ : Optional[Any]=1E-12 , snake_case__ : Dict=1 , snake_case__ : Optional[Any]=0 , snake_case__ : List[Any]=2 , snake_case__ : Any="absolute" , snake_case__ : Union[str, Any]=True , snake_case__ : List[str]=None , snake_case__ : Optional[Any]=False , snake_case__ : Optional[Any]=2 , snake_case__ : Any=False , snake_case__ : Union[str, Any]=True , snake_case__ : Optional[int]=True , snake_case__ : List[str]=("en_XX",) , snake_case__ : Any=None , **snake_case__ : Any , ): """simple docstring""" super().__init__(pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , **snake_case__ ) SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = position_embedding_type SCREAMING_SNAKE_CASE = use_cache SCREAMING_SNAKE_CASE = classifier_dropout SCREAMING_SNAKE_CASE = pre_norm SCREAMING_SNAKE_CASE = adapter_reduction_factor SCREAMING_SNAKE_CASE = adapter_layer_norm SCREAMING_SNAKE_CASE = adapter_reuse_layer_norm SCREAMING_SNAKE_CASE = ln_before_adapter SCREAMING_SNAKE_CASE = list(snake_case__ ) SCREAMING_SNAKE_CASE = default_language class UpperCamelCase ( _UpperCamelCase ): @property def UpperCamelCase ( self : Optional[int] ): """simple docstring""" if self.task == "multiple-choice": SCREAMING_SNAKE_CASE = {0: "batch", 1: "choice", 2: "sequence"} else: SCREAMING_SNAKE_CASE = {0: "batch", 1: "sequence"} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
715
# Note: if you intend to run this script make sure you look under scripts/fsmt/ # to locate the appropriate script to do the work correctly. There is a set of scripts to: # - download and prepare data and run the conversion script # - perform eval to get the best hparam into the config # - generate model_cards - useful if you have multiple models from the same paper import argparse import json import os import re from collections import OrderedDict from os.path import basename, dirname import fairseq import torch from fairseq import hub_utils from fairseq.data.dictionary import Dictionary from transformers import FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() a_ : str = 2 # based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping` # values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults: # # * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users) # * `early_stopping`: `False` consistently scored better # * `length_penalty` varied, so will assign the best one depending on the model a_ : int = { # fairseq: "wmt19-ru-en": {"length_penalty": 1.1}, "wmt19-en-ru": {"length_penalty": 1.1_5}, "wmt19-en-de": {"length_penalty": 1.0}, "wmt19-de-en": {"length_penalty": 1.1}, # allenai: "wmt16-en-de-dist-12-1": {"length_penalty": 0.6}, "wmt16-en-de-dist-6-1": {"length_penalty": 0.6}, "wmt16-en-de-12-1": {"length_penalty": 0.8}, "wmt19-de-en-6-6-base": {"length_penalty": 0.6}, "wmt19-de-en-6-6-big": {"length_penalty": 0.6}, } # this remaps the different models to their organization names a_ : str = {} for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: a_ : List[Any] = "facebook" for m in [ "wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1", "wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big", ]: a_ : Any = "allenai" def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = dict((re.sub(R'@@$' , '' , _UpperCamelCase ), v) if k.endswith('@@' ) else (re.sub(R'$' , '</w>' , _UpperCamelCase ), v) for k, v in d.items() ) SCREAMING_SNAKE_CASE = '<s> <pad> </s> <unk>'.split() # restore the special tokens for k in keep_keys: del da[f"""{k}</w>"""] SCREAMING_SNAKE_CASE = d[k] # restore return da def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[str] ) -> Dict: '''simple docstring''' assert os.path.exists(_UpperCamelCase ) os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) print(f"""Writing results to {pytorch_dump_folder_path}""" ) # handle various types of models SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel SCREAMING_SNAKE_CASE = cls.hub_models() SCREAMING_SNAKE_CASE = {'bpe': 'fastbpe', 'tokenizer': 'moses'} SCREAMING_SNAKE_CASE = '.' # note: since the model dump is old, fairseq has upgraded its model some # time later, and it does a whole lot of rewrites and splits on the saved # weights, therefore we can't use torch.load() directly on the model file. # see: upgrade_state_dict(state_dict) in fairseq_model.py print(f"""using checkpoint {checkpoint_file}""" ) SCREAMING_SNAKE_CASE = hub_utils.from_pretrained( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , archive_map=_UpperCamelCase , **_UpperCamelCase ) SCREAMING_SNAKE_CASE = vars(chkpt['args']['model'] ) SCREAMING_SNAKE_CASE = args['source_lang'] SCREAMING_SNAKE_CASE = args['target_lang'] SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) # dicts SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{src_lang}.txt""" ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{tgt_lang}.txt""" ) SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(src_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-src.json' ) print(f"""Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # detect whether this is a do_lower_case situation, which can be derived by checking whether we # have at least one uppercase letter in the source vocab SCREAMING_SNAKE_CASE = True for k in src_vocab.keys(): if not k.islower(): SCREAMING_SNAKE_CASE = False break SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(tgt_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-tgt.json' ) print(f"""Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # merges_file (bpecodes) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , VOCAB_FILES_NAMES['merges_file'] ) for fn in ["bpecodes", "code"]: # older fairseq called the merges file "code" SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) if os.path.exists(_UpperCamelCase ): break with open(_UpperCamelCase , encoding='utf-8' ) as fin: SCREAMING_SNAKE_CASE = fin.read() SCREAMING_SNAKE_CASE = re.sub(R' \d+$' , '' , _UpperCamelCase , 0 , re.M ) # remove frequency number print(f"""Generating {merges_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as fout: fout.write(_UpperCamelCase ) # model config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'config.json' ) # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe - # may have to modify the tokenizer if a different type is used by a future model assert args["bpe"] == "fastbpe", f"""need to extend tokenizer to support bpe={args['bpe']}""" assert args["tokenizer"] == "moses", f"""need to extend tokenizer to support bpe={args['tokenizer']}""" SCREAMING_SNAKE_CASE = { 'architectures': ['FSMTForConditionalGeneration'], 'model_type': 'fsmt', 'activation_dropout': args['activation_dropout'], 'activation_function': 'relu', 'attention_dropout': args['attention_dropout'], 'd_model': args['decoder_embed_dim'], 'dropout': args['dropout'], 'init_std': 0.02, 'max_position_embeddings': args['max_source_positions'], 'num_hidden_layers': args['encoder_layers'], 'src_vocab_size': src_vocab_size, 'tgt_vocab_size': tgt_vocab_size, 'langs': [src_lang, tgt_lang], 'encoder_attention_heads': args['encoder_attention_heads'], 'encoder_ffn_dim': args['encoder_ffn_embed_dim'], 'encoder_layerdrop': args['encoder_layerdrop'], 'encoder_layers': args['encoder_layers'], 'decoder_attention_heads': args['decoder_attention_heads'], 'decoder_ffn_dim': args['decoder_ffn_embed_dim'], 'decoder_layerdrop': args['decoder_layerdrop'], 'decoder_layers': args['decoder_layers'], 'bos_token_id': 0, 'pad_token_id': 1, 'eos_token_id': 2, 'is_encoder_decoder': True, 'scale_embedding': not args['no_scale_embedding'], 'tie_word_embeddings': args['share_all_embeddings'], } # good hparam defaults to start with SCREAMING_SNAKE_CASE = 5 SCREAMING_SNAKE_CASE = False if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]: SCREAMING_SNAKE_CASE = best_score_hparams[model_dir]['length_penalty'] else: SCREAMING_SNAKE_CASE = 1.0 print(f"""Generating {fsmt_model_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # tokenizer config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = { 'langs': [src_lang, tgt_lang], 'model_max_length': 10_24, 'do_lower_case': do_lower_case, } print(f"""Generating {fsmt_tokenizer_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # model SCREAMING_SNAKE_CASE = chkpt['models'][0] SCREAMING_SNAKE_CASE = model.state_dict() # rename keys to start with 'model.' SCREAMING_SNAKE_CASE = OrderedDict(('model.' + k, v) for k, v in model_state_dict.items() ) # remove unneeded keys SCREAMING_SNAKE_CASE = [ 'model.model', 'model.encoder.version', 'model.decoder.version', 'model.encoder_embed_tokens.weight', 'model.decoder_embed_tokens.weight', 'model.encoder.embed_positions._float_tensor', 'model.decoder.embed_positions._float_tensor', ] for k in ignore_keys: model_state_dict.pop(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTForConditionalGeneration(_UpperCamelCase ) # check that it loads ok model_new.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) # save SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) print(f"""Generating {pytorch_weights_dump_path}""" ) torch.save(_UpperCamelCase , _UpperCamelCase ) print('Conversion is done!' ) print('\nLast step is to upload the files to s3' ) print(f"""cd {data_root}""" ) print(f"""transformers-cli upload {model_dir}""" ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--fsmt_checkpoint_path", default=None, type=str, required=True, help=( "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts," " bpecodes, etc." ), ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) a_ : int = parser.parse_args() convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
673
0
def __lowerCAmelCase ( _UpperCamelCase : List[str] ) -> list: '''simple docstring''' if len(a__ ) <= 1: return lst SCREAMING_SNAKE_CASE = 1 while i < len(a__ ): if lst[i - 1] <= lst[i]: i += 1 else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = lst[i], lst[i - 1] i -= 1 if i == 0: SCREAMING_SNAKE_CASE = 1 return lst if __name__ == "__main__": a_ : Dict = input("Enter numbers separated by a comma:\n").strip() a_ : Tuple = [int(item) for item in user_input.split(",")] print(gnome_sort(unsorted))
716
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
673
0
# using dfs for finding eulerian path traversal def __lowerCAmelCase ( _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple=None ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = (path or []) + [u] for v in graph[u]: if visited_edge[u][v] is False: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = True, True SCREAMING_SNAKE_CASE = dfs(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) return path def __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : str ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = 0 SCREAMING_SNAKE_CASE = -1 for i in range(snake_case__ ): if i not in graph.keys(): continue if len(graph[i] ) % 2 == 1: odd_degree_nodes += 1 SCREAMING_SNAKE_CASE = i if odd_degree_nodes == 0: return 1, odd_node if odd_degree_nodes == 2: return 2, odd_node return 3, odd_node def __lowerCAmelCase ( _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Any ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = [[False for _ in range(max_node + 1 )] for _ in range(max_node + 1 )] SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = check_circuit_or_path(snake_case__ , snake_case__ ) if check == 3: print('graph is not Eulerian' ) print('no path' ) return SCREAMING_SNAKE_CASE = 1 if check == 2: SCREAMING_SNAKE_CASE = odd_node print('graph has a Euler path' ) if check == 1: print('graph has a Euler cycle' ) SCREAMING_SNAKE_CASE = dfs(snake_case__ , snake_case__ , snake_case__ ) print(snake_case__ ) def __lowerCAmelCase ( ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = {1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]} SCREAMING_SNAKE_CASE = {1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]} SCREAMING_SNAKE_CASE = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]} SCREAMING_SNAKE_CASE = {1: [2, 3], 2: [1, 3], 3: [1, 2]} SCREAMING_SNAKE_CASE = { 1: [], 2: [] # all degree is zero } SCREAMING_SNAKE_CASE = 10 check_euler(snake_case__ , snake_case__ ) check_euler(snake_case__ , snake_case__ ) check_euler(snake_case__ , snake_case__ ) check_euler(snake_case__ , snake_case__ ) check_euler(snake_case__ , snake_case__ ) if __name__ == "__main__": main()
717
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
673
0
from __future__ import annotations import os from typing import Any import requests a_ = 'https://api.github.com' # https://docs.github.com/en/free-pro-team@latest/rest/reference/users#get-the-authenticated-user a_ = BASE_URL + '/user' # https://github.com/settings/tokens a_ = os.environ.get("USER_TOKEN", "") def __lowerCAmelCase ( _UpperCamelCase : Tuple ) -> dict[Any, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = { '''Authorization''': f"""token {auth_token}""", '''Accept''': '''application/vnd.github.v3+json''', } return requests.get(_UpperCamelCase , headers=_UpperCamelCase ).json() if __name__ == "__main__": # pragma: no cover if USER_TOKEN: for key, value in fetch_github_info(USER_TOKEN).items(): print(F"""{key}: {value}""") else: raise ValueError("\'USER_TOKEN\' field cannot be empty.")
718
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
673
0
from sympy import diff, lambdify, symbols from sympy.functions import * # noqa: F403 def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] , _UpperCamelCase : Optional[int] , _UpperCamelCase : int = "x" , _UpperCamelCase : Dict = 10**-10 , _UpperCamelCase : Dict = 1 , ) -> complex: '''simple docstring''' SCREAMING_SNAKE_CASE = symbols(_UpperCamelCase ) SCREAMING_SNAKE_CASE = lambdify(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = lambdify(_UpperCamelCase , diff(_UpperCamelCase , _UpperCamelCase ) ) SCREAMING_SNAKE_CASE = starting_point while True: if diff_function(_UpperCamelCase ) != 0: SCREAMING_SNAKE_CASE = prev_guess - multiplicity * func(_UpperCamelCase ) / diff_function( _UpperCamelCase ) else: raise ZeroDivisionError('Could not find root' ) from None # Precision is checked by comparing the difference of consecutive guesses if abs(next_guess - prev_guess ) < precision: return next_guess SCREAMING_SNAKE_CASE = next_guess # Let's Execute if __name__ == "__main__": # Find root of trigonometric function # Find value of pi print(F"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""") # Find root of polynomial # Find fourth Root of 5 print(F"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5J)}""") # Find value of e print( "The root of log(y) - 1 = 0 is ", F"""{newton_raphson("log(y) - 1", 2, variable="y")}""", ) # Exponential Roots print( "The root of exp(x) - 1 = 0 is", F"""{newton_raphson("exp(x) - 1", 10, precision=0.0_0_5)}""", ) # Find root of cos(x) print(F"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")
719
import heapq import sys import numpy as np a_ : Optional[int] = tuple[int, int] class UpperCamelCase : def __init__( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() def UpperCamelCase ( self : List[Any] ): """simple docstring""" if not self.empty(): return self.elements[0][0] else: return float('inf' ) def UpperCamelCase ( self : List[str] ): """simple docstring""" return len(self.elements ) == 0 def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] ): """simple docstring""" if item not in self.set: heapq.heappush(self.elements , (priority, item) ) self.set.add(snake_case__ ) else: # update # print("update", item) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pri, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) temp.append((priority, item) ) for pro, xxx in temp: heapq.heappush(self.elements , (pro, xxx) ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" if item in self.set: self.set.remove(snake_case__ ) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pro, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) for prito, yyy in temp: heapq.heappush(self.elements , (prito, yyy) ) def UpperCamelCase ( self : str ): """simple docstring""" return self.elements[0][1] def UpperCamelCase ( self : Tuple ): """simple docstring""" ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) self.set.remove(snake_case__ ) return (priority, item) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) return np.linalg.norm(a - b ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Dict: '''simple docstring''' return consistent_heuristic(_UpperCamelCase , _UpperCamelCase ) // t def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[int]: '''simple docstring''' return abs(p[0] - goal[0] ) + abs(p[1] - goal[1] ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : int , _UpperCamelCase : TPos , _UpperCamelCase : dict[TPos, float] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = g_function[start] + Wa * heuristics[i](_UpperCamelCase , _UpperCamelCase ) return ans def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : int , _UpperCamelCase : Tuple ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = np.chararray((n, n) ) for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = '*' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): if (j, (n - 1) - i) in blocks: SCREAMING_SNAKE_CASE = '#' SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = x # print(x) SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[x] SCREAMING_SNAKE_CASE = '-' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): 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:-' ) SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: print(_UpperCamelCase , end=' ' ) SCREAMING_SNAKE_CASE = back_pointer[x] print(_UpperCamelCase ) sys.exit() def __lowerCAmelCase ( _UpperCamelCase : TPos ) -> Any: '''simple docstring''' 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 __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : Tuple , _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Optional[Any] , ) -> List[Any]: '''simple docstring''' for itera in range(_UpperCamelCase ): open_list[itera].remove_element(_UpperCamelCase ) # print("s", s) # print("j", j) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = s SCREAMING_SNAKE_CASE = (x - 1, y) SCREAMING_SNAKE_CASE = (x + 1, y) SCREAMING_SNAKE_CASE = (x, y + 1) SCREAMING_SNAKE_CASE = (x, y - 1) for neighbours in [left, right, up, down]: if neighbours not in blocks: if valid(_UpperCamelCase ) and neighbours not in visited: # print("neighbour", neighbours) visited.add(_UpperCamelCase ) SCREAMING_SNAKE_CASE = -1 SCREAMING_SNAKE_CASE = float('inf' ) if valid(_UpperCamelCase ) and g_function[neighbours] > g_function[s] + 1: SCREAMING_SNAKE_CASE = g_function[s] + 1 SCREAMING_SNAKE_CASE = s if neighbours not in close_list_anchor: open_list[0].put(_UpperCamelCase , key(_UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ) ) if neighbours not in close_list_inad: for var in range(1 , _UpperCamelCase ): if key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) <= Wa * key( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ): open_list[j].put( _UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = [] 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 a_ : str = {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a} a_ : List[str] = [ (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), ] a_ : Union[str, Any] = make_common_ground() a_ : Tuple = blocks_blk # hyper parameters a_ : Any = 1 a_ : List[str] = 1 a_ : Union[str, Any] = 20 a_ : Optional[Any] = 3 # one consistent and two other inconsistent # start and end destination a_ : int = (0, 0) a_ : Optional[int] = (n - 1, n - 1) a_ : Union[str, Any] = 1 def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos , _UpperCamelCase : int ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = {start: 0, goal: float('inf' )} SCREAMING_SNAKE_CASE = {start: -1, goal: -1} SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() for i in range(_UpperCamelCase ): open_list.append(PriorityQueue() ) open_list[i].put(_UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] while open_list[0].minkey() < float('inf' ): for i in range(1 , _UpperCamelCase ): # 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(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = open_list[i].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_inad.append(_UpperCamelCase ) else: if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float('inf' ): do_something(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE = open_list[0].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_anchor.append(_UpperCamelCase ) print('No path found to goal' ) print() for i in range(n - 1 , -1 , -1 ): for j in range(_UpperCamelCase ): 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)
673
0
def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : int ) -> Optional[Any]: '''simple docstring''' return int((input_a, input_a).count(0 ) != 0 ) def __lowerCAmelCase ( ) -> List[str]: '''simple docstring''' assert nand_gate(0 , 0 ) == 1 assert nand_gate(0 , 1 ) == 1 assert nand_gate(1 , 0 ) == 1 assert nand_gate(1 , 1 ) == 0 if __name__ == "__main__": print(nand_gate(0, 0)) print(nand_gate(0, 1)) print(nand_gate(1, 0)) print(nand_gate(1, 1))
720
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) a_ : Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name a_ : str = "\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to(\"cuda\")\n\n >>> prompt = \"A red cartoon frog, 4k\"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-decoder\", torch_dtype=torch.float16\n ... )\n >>> pipe.to(\"cuda\")\n\n >>> init_image = load_image(\n ... \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n ... \"/kandinsky/frog.png\"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save(\"red_frog.png\")\n ```\n" def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Any , _UpperCamelCase : Any=8 ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 SCREAMING_SNAKE_CASE = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : List[Any]=5_12 , _UpperCamelCase : Union[str, Any]=5_12 ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) SCREAMING_SNAKE_CASE = np.array(pil_image.convert('RGB' ) ) SCREAMING_SNAKE_CASE = arr.astype(np.floataa ) / 1_27.5 - 1 SCREAMING_SNAKE_CASE = np.transpose(_UpperCamelCase , [2, 0, 1] ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).unsqueeze(0 ) return image class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : int , snake_case__ : UNetaDConditionModel , snake_case__ : DDPMScheduler , snake_case__ : VQModel , ): """simple docstring""" super().__init__() self.register_modules( unet=snake_case__ , scheduler=snake_case__ , movq=snake_case__ , ) SCREAMING_SNAKE_CASE = 2 ** (len(self.movq.config.block_out_channels ) - 1) def UpperCamelCase ( self : Any , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = min(int(num_inference_steps * strength ) , snake_case__ ) SCREAMING_SNAKE_CASE = max(num_inference_steps - init_timestep , 0 ) SCREAMING_SNAKE_CASE = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self : List[str] , snake_case__ : Dict , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : str=None ): """simple docstring""" if not isinstance(snake_case__ , (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(snake_case__ )}""" ) SCREAMING_SNAKE_CASE = image.to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = batch_size * num_images_per_prompt if image.shape[1] == 4: SCREAMING_SNAKE_CASE = image else: if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) != batch_size: raise ValueError( F"""You have passed a list of generators of length {len(snake_case__ )}, but requested an effective batch""" F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) elif isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(snake_case__ ) ] SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) else: SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ ).latent_dist.sample(snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.config.scaling_factor * init_latents SCREAMING_SNAKE_CASE = torch.cat([init_latents] , dim=0 ) SCREAMING_SNAKE_CASE = init_latents.shape SCREAMING_SNAKE_CASE = randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ , dtype=snake_case__ ) # get latents SCREAMING_SNAKE_CASE = self.scheduler.add_noise(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = init_latents return latents def UpperCamelCase ( self : int , snake_case__ : List[str]=0 ): """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) SCREAMING_SNAKE_CASE = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int]=0 ): """simple docstring""" if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=snake_case__ ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) SCREAMING_SNAKE_CASE = None for cpu_offloaded_model in [self.unet, self.movq]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cpu_offload_with_hook(snake_case__ , snake_case__ , prev_module_hook=snake_case__ ) # We'll offload the last model manually. SCREAMING_SNAKE_CASE = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self : Dict ): """simple docstring""" if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(snake_case__ , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(snake_case__ ) def __call__( self : str , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]] , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_1_2 , snake_case__ : int = 1_0_0 , snake_case__ : float = 4.0 , snake_case__ : float = 0.3 , snake_case__ : int = 1 , snake_case__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , ): """simple docstring""" SCREAMING_SNAKE_CASE = self._execution_device SCREAMING_SNAKE_CASE = guidance_scale > 1.0 if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = image_embeds.shape[0] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) if do_classifier_free_guidance: SCREAMING_SNAKE_CASE = image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = negative_image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=snake_case__ ) if not isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [image] if not all(isinstance(snake_case__ , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( F"""Input is in incorrect format: {[type(snake_case__ ) for i in image]}. Currently, we only support PIL image and pytorch tensor""" ) SCREAMING_SNAKE_CASE = torch.cat([prepare_image(snake_case__ , snake_case__ , snake_case__ ) for i in image] , dim=0 ) SCREAMING_SNAKE_CASE = image.to(dtype=image_embeds.dtype , device=snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ )['latents'] SCREAMING_SNAKE_CASE = latents.repeat_interleave(snake_case__ , dim=0 ) self.scheduler.set_timesteps(snake_case__ , device=snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_timesteps(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = timesteps[:1].repeat(batch_size * num_images_per_prompt ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = downscale_height_and_width(snake_case__ , snake_case__ , self.movq_scale_factor ) SCREAMING_SNAKE_CASE = self.prepare_latents( snake_case__ , snake_case__ , snake_case__ , snake_case__ , image_embeds.dtype , snake_case__ , snake_case__ ) for i, t in enumerate(self.progress_bar(snake_case__ ) ): # expand the latents if we are doing classifier free guidance SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents SCREAMING_SNAKE_CASE = {'image_embeds': image_embeds} SCREAMING_SNAKE_CASE = self.unet( sample=snake_case__ , timestep=snake_case__ , encoder_hidden_states=snake_case__ , added_cond_kwargs=snake_case__ , return_dict=snake_case__ , )[0] if do_classifier_free_guidance: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.chunk(2 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = variance_pred.chunk(2 ) SCREAMING_SNAKE_CASE = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) SCREAMING_SNAKE_CASE = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 SCREAMING_SNAKE_CASE = self.scheduler.step( snake_case__ , snake_case__ , snake_case__ , generator=snake_case__ , )[0] # post-processing SCREAMING_SNAKE_CASE = self.movq.decode(snake_case__ , force_not_quantize=snake_case__ )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}""" ) if output_type in ["np", "pil"]: SCREAMING_SNAKE_CASE = image * 0.5 + 0.5 SCREAMING_SNAKE_CASE = image.clamp(0 , 1 ) SCREAMING_SNAKE_CASE = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": SCREAMING_SNAKE_CASE = self.numpy_to_pil(snake_case__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case__ )
673
0
from itertools import count def __lowerCAmelCase ( _UpperCamelCase : int = 50 ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = [1] * min_block_length for n in count(_UpperCamelCase ): fill_count_functions.append(1 ) for block_length in range(_UpperCamelCase , n + 1 ): for block_start in range(n - block_length ): fill_count_functions[n] += fill_count_functions[ n - block_start - block_length - 1 ] fill_count_functions[n] += 1 if fill_count_functions[n] > 1_00_00_00: break return n if __name__ == "__main__": print(F"""{solution() = }""")
721
import argparse import numpy as np import torch from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging logging.set_verbosity_info() a_ : List[Any] = logging.get_logger("transformers.models.speecht5") def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Tuple , _UpperCamelCase : Any ) -> Dict: '''simple docstring''' hf_model.apply_weight_norm() SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.bias'] for i in range(len(config.upsample_rates ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.bias"""] for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ): for j in range(len(config.resblock_dilation_sizes ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.bias'] hf_model.remove_weight_norm() @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : Dict , _UpperCamelCase : Tuple , _UpperCamelCase : Any=None , _UpperCamelCase : List[str]=None , ) -> Tuple: '''simple docstring''' if config_path is not None: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig.from_pretrained(_UpperCamelCase ) else: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig() SCREAMING_SNAKE_CASE = SpeechTaHifiGan(_UpperCamelCase ) SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase ) load_weights(orig_checkpoint['model']['generator'] , _UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = np.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = stats[0].reshape(-1 ) SCREAMING_SNAKE_CASE = stats[1].reshape(-1 ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() model.save_pretrained(_UpperCamelCase ) if repo_id: print('Pushing to the hub...' ) model.push_to_hub(_UpperCamelCase ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint") parser.add_argument("--stats_path", required=True, default=None, type=str, help="Path to stats.npy file") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model." ) parser.add_argument( "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub." ) a_ : Tuple = parser.parse_args() convert_hifigan_checkpoint( args.checkpoint_path, args.stats_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )
673
0
from ..utils import DummyObject, requires_backends class UpperCamelCase ( metaclass=lowercase__ ): __UpperCamelCase =["torch", "scipy"] def __init__( self : List[Any] , *snake_case__ : int , **snake_case__ : Dict ): """simple docstring""" requires_backends(self , ['torch', 'scipy'] ) @classmethod def UpperCamelCase ( cls : Optional[int] , *snake_case__ : Union[str, Any] , **snake_case__ : str ): """simple docstring""" requires_backends(cls , ['torch', 'scipy'] ) @classmethod def UpperCamelCase ( cls : Any , *snake_case__ : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" requires_backends(cls , ['torch', 'scipy'] )
700
import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer a_ : Optional[int] = logging.get_logger(__name__) a_ : Union[str, Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json", }, "merges_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt", }, "tokenizer_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json", }, } a_ : List[Any] = { "allenai/led-base-16384": 1_6384, } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =LEDTokenizer __UpperCamelCase =["input_ids", "attention_mask"] def __init__( self : Tuple , snake_case__ : List[Any]=None , snake_case__ : List[str]=None , snake_case__ : List[str]=None , snake_case__ : Dict="replace" , snake_case__ : Tuple="<s>" , snake_case__ : Optional[Any]="</s>" , snake_case__ : int="</s>" , snake_case__ : Dict="<s>" , snake_case__ : Union[str, Any]="<unk>" , snake_case__ : Optional[int]="<pad>" , snake_case__ : List[str]="<mask>" , snake_case__ : List[Any]=False , snake_case__ : int=True , **snake_case__ : Dict , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , errors=snake_case__ , bos_token=snake_case__ , eos_token=snake_case__ , sep_token=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , add_prefix_space=snake_case__ , trim_offsets=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = getattr(snake_case__ , pre_tok_state.pop('type' ) ) SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = pre_tok_class(**snake_case__ ) SCREAMING_SNAKE_CASE = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` SCREAMING_SNAKE_CASE = 'post_processor' SCREAMING_SNAKE_CASE = getattr(self.backend_tokenizer , snake_case__ , snake_case__ ) if tokenizer_component_instance: SCREAMING_SNAKE_CASE = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: SCREAMING_SNAKE_CASE = tuple(state['sep'] ) if "cls" in state: SCREAMING_SNAKE_CASE = tuple(state['cls'] ) SCREAMING_SNAKE_CASE = False if state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = True if state.get('trim_offsets' , snake_case__ ) != trim_offsets: SCREAMING_SNAKE_CASE = trim_offsets SCREAMING_SNAKE_CASE = True if changes_to_apply: SCREAMING_SNAKE_CASE = getattr(snake_case__ , state.pop('type' ) ) SCREAMING_SNAKE_CASE = component_class(**snake_case__ ) setattr(self.backend_tokenizer , snake_case__ , snake_case__ ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" if self._mask_token is None: if self.verbose: logger.error('Using mask_token, but it is not set yet.' ) return None return str(self._mask_token ) @mask_token.setter def UpperCamelCase ( self : List[Any] , snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else value SCREAMING_SNAKE_CASE = value def UpperCamelCase ( self : Dict , *snake_case__ : Optional[Any] , **snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._batch_encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : List[str] , *snake_case__ : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : Tuple=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def UpperCamelCase ( self : Optional[int] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def UpperCamelCase ( self : Optional[Any] , snake_case__ : Union[Dict[str, EncodedInput], BatchEncoding] , snake_case__ : Optional[int] = None , snake_case__ : PaddingStrategy = PaddingStrategy.DO_NOT_PAD , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super()._pad( encoded_inputs=snake_case__ , max_length=snake_case__ , padding_strategy=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , ) # Load from model defaults if return_attention_mask is None: SCREAMING_SNAKE_CASE = 'attention_mask' in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: SCREAMING_SNAKE_CASE = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. SCREAMING_SNAKE_CASE = len(encoded_inputs['global_attention_mask'] ) != len(snake_case__ ) if needs_to_be_padded: SCREAMING_SNAKE_CASE = len(snake_case__ ) - len(encoded_inputs['global_attention_mask'] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` SCREAMING_SNAKE_CASE = ( encoded_inputs['global_attention_mask'] + [-1] * difference ) elif self.padding_side == "left": SCREAMING_SNAKE_CASE = [-1] * difference + encoded_inputs[ 'global_attention_mask' ] else: raise ValueError('Invalid padding strategy:' + str(self.padding_side ) ) return encoded_inputs
673
0
'''simple docstring''' import argparse import json import logging import os import shutil import sys import tempfile import unittest from unittest import mock import torch from accelerate.utils import write_basic_config from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device from transformers.utils import is_apex_available logging.basicConfig(level=logging.DEBUG) a_ : Optional[Any] = logging.getLogger() def __lowerCAmelCase ( ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = argparse.ArgumentParser() parser.add_argument('-f' ) SCREAMING_SNAKE_CASE = parser.parse_args() return args.f def __lowerCAmelCase ( _UpperCamelCase : List[str] ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = {} SCREAMING_SNAKE_CASE = os.path.join(_lowerCAmelCase , 'all_results.json' ) if os.path.exists(_lowerCAmelCase ): with open(_lowerCAmelCase , 'r' ) as f: SCREAMING_SNAKE_CASE = json.load(_lowerCAmelCase ) else: raise ValueError(f"""can't find {path}""" ) return results def __lowerCAmelCase ( ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = torch.cuda.is_available() and torch_device == 'cuda' return is_using_cuda and is_apex_available() a_ : Tuple = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class UpperCamelCase ( __UpperCAmelCase ): @classmethod def UpperCamelCase ( cls : str ): """simple docstring""" SCREAMING_SNAKE_CASE = tempfile.mkdtemp() SCREAMING_SNAKE_CASE = os.path.join(cls.tmpdir , 'default_config.yml' ) write_basic_config(save_location=cls.configPath ) SCREAMING_SNAKE_CASE = ['accelerate', 'launch', '--config_file', cls.configPath] @classmethod def UpperCamelCase ( cls : str ): """simple docstring""" shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n --model_name_or_path distilbert-base-uncased\n --output_dir {tmp_dir}\n --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --learning_rate=1e-4\n --seed=42\n --checkpointing_steps epoch\n --with_tracking\n """.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_accuracy'] , 0.75 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'glue_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n --model_name_or_path distilgpt2\n --train_file ./tests/fixtures/sample_text.txt\n --validation_file ./tests/fixtures/sample_text.txt\n --block_size 128\n --per_device_train_batch_size 5\n --per_device_eval_batch_size 5\n --num_train_epochs 2\n --output_dir {tmp_dir}\n --checkpointing_steps epoch\n --with_tracking\n """.split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertLess(result['perplexity'] , 1_0_0 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'clm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n --model_name_or_path distilroberta-base\n --train_file ./tests/fixtures/sample_text.txt\n --validation_file ./tests/fixtures/sample_text.txt\n --output_dir {tmp_dir}\n --num_train_epochs=1\n --checkpointing_steps epoch\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertLess(result['perplexity'] , 4_2 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'mlm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 7 if get_gpu_count() > 1 else 2 SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n --model_name_or_path bert-base-uncased\n --train_file tests/fixtures/tests_samples/conll/sample.json\n --validation_file tests/fixtures/tests_samples/conll/sample.json\n --output_dir {tmp_dir}\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=2\n --num_train_epochs={epochs}\n --seed 7\n --checkpointing_steps epoch\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_accuracy'] , 0.75 ) self.assertLess(result['train_loss'] , 0.5 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'ner_no_trainer' ) ) ) @unittest.skip(reason='Fix me @muellerzr' ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n --model_name_or_path bert-base-uncased\n --version_2_with_negative\n --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n --output_dir {tmp_dir}\n --seed=42\n --max_train_steps=10\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics. self.assertGreaterEqual(result['eval_f1'] , 2_8 ) self.assertGreaterEqual(result['eval_exact'] , 2_8 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'qa_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n --model_name_or_path bert-base-uncased\n --train_file tests/fixtures/tests_samples/swag/sample.json\n --validation_file tests/fixtures/tests_samples/swag/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=20\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_accuracy'] , 0.8 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'swag_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n --model_name_or_path t5-small\n --train_file tests/fixtures/tests_samples/xsum/sample.json\n --validation_file tests/fixtures/tests_samples/xsum/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=50\n --num_warmup_steps=8\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_rouge1'] , 1_0 ) self.assertGreaterEqual(result['eval_rouge2'] , 2 ) self.assertGreaterEqual(result['eval_rougeL'] , 7 ) self.assertGreaterEqual(result['eval_rougeLsum'] , 7 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'summarization_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n --model_name_or_path sshleifer/student_marian_en_ro_6_1\n --source_lang en\n --target_lang ro\n --train_file tests/fixtures/tests_samples/wmt16/sample.json\n --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=50\n --num_warmup_steps=8\n --num_beams=6\n --learning_rate=3e-3\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --source_lang en_XX\n --target_lang ro_RO\n --checkpointing_steps epoch\n --with_tracking\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_bleu'] , 3_0 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'translation_no_trainer' ) ) ) @slow def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = logging.StreamHandler(sys.stdout ) logger.addHandler(_lowerCamelCase ) SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n --dataset_name huggingface/semantic-segmentation-test-sample\n --output_dir {tmp_dir}\n --max_train_steps=10\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n """.split() run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) self.assertGreaterEqual(result['eval_overall_accuracy'] , 0.10 ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_auto_remove_tmp_dir() SCREAMING_SNAKE_CASE = F"""\n {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n --model_name_or_path google/vit-base-patch16-224-in21k\n --dataset_name hf-internal-testing/cats_vs_dogs_sample\n --learning_rate 1e-4\n --per_device_train_batch_size 2\n --per_device_eval_batch_size 1\n --max_train_steps 2\n --train_val_split 0.1\n --seed 42\n --output_dir {tmp_dir}\n --with_tracking\n --checkpointing_steps 1\n """.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) SCREAMING_SNAKE_CASE = get_results(_lowerCamelCase ) # The base model scores a 25% self.assertGreaterEqual(result['eval_accuracy'] , 0.6 ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'step_1' ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCamelCase , 'image_classification_no_trainer' ) ) )
701
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def __lowerCAmelCase ( *_UpperCamelCase : Optional[Any] ) -> Optional[int]: '''simple docstring''' with open(_UpperCamelCase , 'r' ) as fh: fcntl.flock(_UpperCamelCase , fcntl.LOCK_EX ) try: print(*_UpperCamelCase ) finally: fcntl.flock(_UpperCamelCase , fcntl.LOCK_UN ) a_ : int = int(os.environ["LOCAL_RANK"]) torch.cuda.set_device(local_rank) a_ : str = torch.device("cuda", local_rank) a_ : Optional[int] = socket.gethostname() a_ : Union[str, Any] = F"""[{hostname}-{local_rank}]""" try: # test distributed dist.init_process_group("nccl") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank a_ : Dict = dist.get_rank() a_ : Any = dist.get_world_size() printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""") dist.barrier() if rank == 0: printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""") except Exception: printflock(F"""{gpu} is broken""") raise
673
0
import flax.linen as nn import jax import jax.numpy as jnp class UpperCamelCase ( nn.Module ): __UpperCamelCase =42 __UpperCamelCase =jnp.floataa def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = nn.Conv( self.out_channels , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) def __call__( self : Tuple , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = hidden_states.shape SCREAMING_SNAKE_CASE = jax.image.resize( __lowerCamelCase , shape=(batch, height * 2, width * 2, channels) , method='nearest' , ) SCREAMING_SNAKE_CASE = self.conv(__lowerCamelCase ) return hidden_states class UpperCamelCase ( nn.Module ): __UpperCamelCase =42 __UpperCamelCase =jnp.floataa def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = nn.Conv( self.out_channels , kernel_size=(3, 3) , strides=(2, 2) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) def __call__( self : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.conv(__lowerCamelCase ) return hidden_states class UpperCamelCase ( nn.Module ): __UpperCamelCase =42 __UpperCamelCase =None __UpperCamelCase =0.0 __UpperCamelCase =None __UpperCamelCase =jnp.floataa def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.in_channels if self.out_channels is None else self.out_channels SCREAMING_SNAKE_CASE = nn.GroupNorm(num_groups=3_2 , epsilon=1E-5 ) SCREAMING_SNAKE_CASE = nn.Conv( __lowerCamelCase , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) SCREAMING_SNAKE_CASE = nn.Dense(__lowerCamelCase , dtype=self.dtype ) SCREAMING_SNAKE_CASE = nn.GroupNorm(num_groups=3_2 , epsilon=1E-5 ) SCREAMING_SNAKE_CASE = nn.Dropout(self.dropout_prob ) SCREAMING_SNAKE_CASE = nn.Conv( __lowerCamelCase , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) SCREAMING_SNAKE_CASE = self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut SCREAMING_SNAKE_CASE = None if use_nin_shortcut: SCREAMING_SNAKE_CASE = nn.Conv( __lowerCamelCase , kernel_size=(1, 1) , strides=(1, 1) , padding='VALID' , dtype=self.dtype , ) def __call__( self : Optional[int] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[Any]=True ): """simple docstring""" SCREAMING_SNAKE_CASE = hidden_states SCREAMING_SNAKE_CASE = self.norma(__lowerCamelCase ) SCREAMING_SNAKE_CASE = nn.swish(__lowerCamelCase ) SCREAMING_SNAKE_CASE = self.conva(__lowerCamelCase ) SCREAMING_SNAKE_CASE = self.time_emb_proj(nn.swish(__lowerCamelCase ) ) SCREAMING_SNAKE_CASE = jnp.expand_dims(jnp.expand_dims(__lowerCamelCase , 1 ) , 1 ) SCREAMING_SNAKE_CASE = hidden_states + temb SCREAMING_SNAKE_CASE = self.norma(__lowerCamelCase ) SCREAMING_SNAKE_CASE = nn.swish(__lowerCamelCase ) SCREAMING_SNAKE_CASE = self.dropout(__lowerCamelCase , __lowerCamelCase ) SCREAMING_SNAKE_CASE = self.conva(__lowerCamelCase ) if self.conv_shortcut is not None: SCREAMING_SNAKE_CASE = self.conv_shortcut(__lowerCamelCase ) return hidden_states + residual
702
from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_herbert import HerbertTokenizer a_ : Optional[Any] = logging.get_logger(__name__) a_ : Optional[Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json" }, "merges_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt" }, } a_ : Union[str, Any] = {"allegro/herbert-base-cased": 514} a_ : List[Any] = {} class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_INIT_CONFIGURATION __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =HerbertTokenizer def __init__( self : Tuple , snake_case__ : Optional[Any]=None , snake_case__ : int=None , snake_case__ : Optional[int]=None , snake_case__ : str="<s>" , snake_case__ : Tuple="<unk>" , snake_case__ : List[str]="<pad>" , snake_case__ : Tuple="<mask>" , snake_case__ : Dict="</s>" , **snake_case__ : List[str] , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , sep_token=snake_case__ , **snake_case__ , ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.cls_token_id] SCREAMING_SNAKE_CASE = [self.sep_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 UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ): """simple docstring""" if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ ) if token_ids_a is None: return [1] + ([0] * len(snake_case__ )) + [1] return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1] def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def UpperCamelCase ( self : Tuple , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ )
673
0
class UpperCamelCase : def __init__( self : Optional[int] , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = size SCREAMING_SNAKE_CASE = [0] * size SCREAMING_SNAKE_CASE = [0] * size @staticmethod def UpperCamelCase ( snake_case__ : int ): """simple docstring""" return index | (index + 1) @staticmethod def UpperCamelCase ( snake_case__ : int ): """simple docstring""" return (index & (index + 1)) - 1 def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = value while index < self.size: SCREAMING_SNAKE_CASE = self.get_prev(_lowercase ) + 1 if current_left_border == index: SCREAMING_SNAKE_CASE = value else: SCREAMING_SNAKE_CASE = max(_lowercase , _lowercase , _lowercase ) SCREAMING_SNAKE_CASE = self.get_next(_lowercase ) def UpperCamelCase ( self : Dict , snake_case__ : int , snake_case__ : int ): """simple docstring""" right -= 1 # Because of right is exclusive SCREAMING_SNAKE_CASE = 0 while left <= right: SCREAMING_SNAKE_CASE = self.get_prev(_lowercase ) if left <= current_left: SCREAMING_SNAKE_CASE = max(_lowercase , self.tree[right] ) SCREAMING_SNAKE_CASE = current_left else: SCREAMING_SNAKE_CASE = max(_lowercase , self.arr[right] ) right -= 1 return result if __name__ == "__main__": import doctest doctest.testmod()
703
def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 while n > 0: res += n % 10 n //= 10 return res def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) return n if n < 10 else n % 10 + sum_of_digits(n // 10 ) def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' return sum(int(_UpperCamelCase ) for c in str(abs(_UpperCamelCase ) ) ) def __lowerCAmelCase ( ) -> None: '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(_UpperCamelCase : Callable , _UpperCamelCase : int ) -> None: SCREAMING_SNAKE_CASE = f"""{func.__name__}({value})""" SCREAMING_SNAKE_CASE = timeit(f"""__main__.{call}""" , setup='import __main__' ) print(f"""{call:56} = {func(_UpperCamelCase )} -- {timing:.4f} seconds""" ) for value in (26_21_44, 11_25_89_99_06_84_26_24, 1_26_76_50_60_02_28_22_94_01_49_67_03_20_53_76): for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact): benchmark_a_function(_UpperCamelCase , _UpperCamelCase ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
673
0
from scipy.stats import spearmanr import datasets a_ : Optional[int] = "\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n" a_ : str = "\nArgs:\n predictions (`List[float]`): Predicted labels, as returned by a model.\n references (`List[float]`): Ground truth labels.\n return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n only the spearmanr score. Defaults to `False`.\nReturns:\n spearmanr (`float`): Spearman correlation coefficient.\n p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n Example 1:\n >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n >>> print(results)\n {'spearmanr': -0.7}\n\n Example 2:\n >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n ... predictions=[10, 9, 2.5, 6, 4],\n ... return_pvalue=True)\n >>> print(results['spearmanr'])\n -0.7\n >>> print(round(results['spearmanr_pvalue'], 2))\n 0.19\n" a_ : List[Any] = R"\\n@book{kokoska2000crc,\n title={CRC standard probability and statistics tables and formulae},\n author={Kokoska, Stephen and Zwillinger, Daniel},\n year={2000},\n publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n author = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n Kern, Robert and Larson, Eric and Carey, C J and\n Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and\n {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n Harris, Charles R. and Archibald, Anne M. and\n Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and\n {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n title = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n Computing in Python}},\n journal = {Nature Methods},\n year = {2020},\n volume = {17},\n pages = {261--272},\n adsurl = {https://rdcu.be/b08Wh},\n doi = {10.1038/s41592-019-0686-2},\n}\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : Optional[int] ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('float' ), 'references': datasets.Value('float' ), } ) , reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html'] , ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Union[str, Any] , snake_case__ : Any=False ): """simple docstring""" SCREAMING_SNAKE_CASE = spearmanr(lowercase_ , lowercase_ ) if return_pvalue: return {"spearmanr": results[0], "spearmanr_pvalue": results[1]} else: return {"spearmanr": results[0]}
704
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
673
0
import argparse import json import os from collections import OrderedDict import torch from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer from transformers.tokenization_utils_base import AddedToken @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Optional[Any] , _UpperCamelCase : List[str] ) -> int: '''simple docstring''' with open(_UpperCamelCase ) as metadata_file: SCREAMING_SNAKE_CASE = json.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = LukeConfig(use_entity_aware_attention=_UpperCamelCase , **metadata['model_config'] ) # Load in the weights from the checkpoint_path SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase , map_location='cpu' )['module'] # Load the entity vocab file SCREAMING_SNAKE_CASE = load_original_entity_vocab(_UpperCamelCase ) # add an entry for [MASK2] SCREAMING_SNAKE_CASE = max(entity_vocab.values() ) + 1 config.entity_vocab_size += 1 SCREAMING_SNAKE_CASE = XLMRobertaTokenizer.from_pretrained(metadata['model_config']['bert_model_name'] ) # Add special tokens to the token vocabulary for downstream tasks SCREAMING_SNAKE_CASE = AddedToken('<ent>' , lstrip=_UpperCamelCase , rstrip=_UpperCamelCase ) SCREAMING_SNAKE_CASE = AddedToken('<ent2>' , lstrip=_UpperCamelCase , rstrip=_UpperCamelCase ) tokenizer.add_special_tokens({'additional_special_tokens': [entity_token_a, entity_token_a]} ) config.vocab_size += 2 print(f"""Saving tokenizer to {pytorch_dump_folder_path}""" ) tokenizer.save_pretrained(_UpperCamelCase ) with open(os.path.join(_UpperCamelCase , 'tokenizer_config.json' ) , 'r' ) as f: SCREAMING_SNAKE_CASE = json.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 'MLukeTokenizer' with open(os.path.join(_UpperCamelCase , 'tokenizer_config.json' ) , 'w' ) as f: json.dump(_UpperCamelCase , _UpperCamelCase ) with open(os.path.join(_UpperCamelCase , MLukeTokenizer.vocab_files_names['entity_vocab_file'] ) , 'w' ) as f: json.dump(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase ) # Initialize the embeddings of the special tokens SCREAMING_SNAKE_CASE = tokenizer.convert_tokens_to_ids(['@'] )[0] SCREAMING_SNAKE_CASE = tokenizer.convert_tokens_to_ids(['#'] )[0] SCREAMING_SNAKE_CASE = state_dict['embeddings.word_embeddings.weight'] SCREAMING_SNAKE_CASE = word_emb[ent_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = word_emb[enta_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([word_emb, ent_emb, enta_emb] ) # add special tokens for 'entity_predictions.bias' for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]: SCREAMING_SNAKE_CASE = state_dict[bias_name] SCREAMING_SNAKE_CASE = decoder_bias[ent_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = decoder_bias[enta_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([decoder_bias, ent_decoder_bias, enta_decoder_bias] ) # Initialize the query layers of the entity-aware self-attention mechanism for layer_index in range(config.num_hidden_layers ): for matrix_name in ["query.weight", "query.bias"]: SCREAMING_SNAKE_CASE = f"""encoder.layer.{layer_index}.attention.self.""" SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks SCREAMING_SNAKE_CASE = state_dict['entity_embeddings.entity_embeddings.weight'] SCREAMING_SNAKE_CASE = entity_emb[entity_vocab['[MASK]']].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([entity_emb, entity_mask_emb] ) # add [MASK2] for 'entity_predictions.bias' SCREAMING_SNAKE_CASE = state_dict['entity_predictions.bias'] SCREAMING_SNAKE_CASE = entity_prediction_bias[entity_vocab['[MASK]']].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([entity_prediction_bias, entity_mask_bias] ) SCREAMING_SNAKE_CASE = LukeForMaskedLM(config=_UpperCamelCase ).eval() state_dict.pop('entity_predictions.decoder.weight' ) state_dict.pop('lm_head.decoder.weight' ) state_dict.pop('lm_head.decoder.bias' ) SCREAMING_SNAKE_CASE = OrderedDict() for key, value in state_dict.items(): if not (key.startswith('lm_head' ) or key.startswith('entity_predictions' )): SCREAMING_SNAKE_CASE = state_dict[key] else: SCREAMING_SNAKE_CASE = state_dict[key] SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = model.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) if set(_UpperCamelCase ) != {"luke.embeddings.position_ids"}: raise ValueError(f"""Unexpected unexpected_keys: {unexpected_keys}""" ) if set(_UpperCamelCase ) != { "lm_head.decoder.weight", "lm_head.decoder.bias", "entity_predictions.decoder.weight", }: raise ValueError(f"""Unexpected missing_keys: {missing_keys}""" ) model.tie_weights() assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all() assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all() # Check outputs SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase , task='entity_classification' ) SCREAMING_SNAKE_CASE = 'ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan).' SCREAMING_SNAKE_CASE = (0, 9) SCREAMING_SNAKE_CASE = tokenizer(_UpperCamelCase , entity_spans=[span] , return_tensors='pt' ) SCREAMING_SNAKE_CASE = model(**_UpperCamelCase ) # Verify word hidden states if model_size == "large": raise NotImplementedError else: # base SCREAMING_SNAKE_CASE = torch.Size((1, 33, 7_68) ) SCREAMING_SNAKE_CASE = torch.tensor([[0.08_92, 0.05_96, -0.28_19], [0.01_34, 0.11_99, 0.05_73], [-0.01_69, 0.09_27, 0.06_44]] ) if not (outputs.last_hidden_state.shape == expected_shape): raise ValueError( f"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}""" ) if not torch.allclose(outputs.last_hidden_state[0, :3, :3] , _UpperCamelCase , atol=1e-4 ): raise ValueError # Verify entity hidden states if model_size == "large": raise NotImplementedError else: # base SCREAMING_SNAKE_CASE = torch.Size((1, 1, 7_68) ) SCREAMING_SNAKE_CASE = torch.tensor([[-0.14_82, 0.06_09, 0.03_22]] ) if not (outputs.entity_last_hidden_state.shape == expected_shape): raise ValueError( f"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is""" f""" {expected_shape}""" ) if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3] , _UpperCamelCase , atol=1e-4 ): raise ValueError # Verify masked word/entity prediction SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 'Tokyo is the capital of <mask>.' SCREAMING_SNAKE_CASE = (24, 30) SCREAMING_SNAKE_CASE = tokenizer(_UpperCamelCase , entity_spans=[span] , return_tensors='pt' ) SCREAMING_SNAKE_CASE = model(**_UpperCamelCase ) SCREAMING_SNAKE_CASE = encoding['input_ids'][0].tolist() SCREAMING_SNAKE_CASE = input_ids.index(tokenizer.convert_tokens_to_ids('<mask>' ) ) SCREAMING_SNAKE_CASE = outputs.logits[0][mask_position_id].argmax(dim=-1 ) assert "Japan" == tokenizer.decode(_UpperCamelCase ) SCREAMING_SNAKE_CASE = outputs.entity_logits[0][0].argmax().item() SCREAMING_SNAKE_CASE = [ entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id ] assert [e for e in multilingual_predicted_entities if e.startswith('en:' )][0] == "en:Japan" # Finally, save our PyTorch model and tokenizer print('Saving PyTorch model to {}'.format(_UpperCamelCase ) ) model.save_pretrained(_UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Any ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = ['[MASK]', '[PAD]', '[UNK]'] SCREAMING_SNAKE_CASE = [json.loads(_UpperCamelCase ) for line in open(_UpperCamelCase )] SCREAMING_SNAKE_CASE = {} for entry in data: SCREAMING_SNAKE_CASE = entry['id'] for entity_name, language in entry["entities"]: if entity_name in SPECIAL_TOKENS: SCREAMING_SNAKE_CASE = entity_id break SCREAMING_SNAKE_CASE = f"""{language}:{entity_name}""" SCREAMING_SNAKE_CASE = entity_id return new_mapping if __name__ == "__main__": a_ : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.") parser.add_argument( "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration." ) parser.add_argument( "--entity_vocab_path", default=None, type=str, help="Path to an entity_vocab.tsv file, containing the entity vocabulary.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model." ) parser.add_argument( "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted." ) a_ : Union[str, Any] = parser.parse_args() convert_luke_checkpoint( args.checkpoint_path, args.metadata_path, args.entity_vocab_path, args.pytorch_dump_folder_path, args.model_size, )
705
import gc import unittest import numpy as np import torch import torch.nn.functional as F from transformers import ( ClapTextConfig, ClapTextModelWithProjection, RobertaTokenizer, SpeechTaHifiGan, SpeechTaHifiGanConfig, ) from diffusers import ( AudioLDMPipeline, AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.utils import is_xformers_available, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =AudioLDMPipeline __UpperCamelCase =TEXT_TO_AUDIO_PARAMS __UpperCamelCase =TEXT_TO_AUDIO_BATCH_PARAMS __UpperCamelCase =frozenset( [ "num_inference_steps", "num_waveforms_per_prompt", "generator", "latents", "output_type", "return_dict", "callback", "callback_steps", ] ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=(3_2, 6_4) , class_embed_type='simple_projection' , projection_class_embeddings_input_dim=3_2 , class_embeddings_concat=snake_case__ , ) SCREAMING_SNAKE_CASE = DDIMScheduler( beta_start=0.00_085 , beta_end=0.012 , beta_schedule='scaled_linear' , clip_sample=snake_case__ , set_alpha_to_one=snake_case__ , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=1 , out_channels=1 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = ClapTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , projection_dim=3_2 , ) SCREAMING_SNAKE_CASE = ClapTextModelWithProjection(snake_case__ ) SCREAMING_SNAKE_CASE = RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta' , model_max_length=7_7 ) SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig( model_in_dim=8 , sampling_rate=1_6_0_0_0 , upsample_initial_channel=1_6 , upsample_rates=[2, 2] , upsample_kernel_sizes=[4, 4] , resblock_kernel_sizes=[3, 7] , resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]] , normalize_before=snake_case__ , ) SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ) SCREAMING_SNAKE_CASE = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'vocoder': vocoder, } return components def UpperCamelCase ( self : Optional[int] , snake_case__ : int , snake_case__ : int=0 ): """simple docstring""" if str(snake_case__ ).startswith('mps' ): SCREAMING_SNAKE_CASE = torch.manual_seed(snake_case__ ) else: SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, } return inputs def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = prompt_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) SCREAMING_SNAKE_CASE = prompt_embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * ['this is a negative prompt'] SCREAMING_SNAKE_CASE = negative_prompt SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = [] for p in [prompt, negative_prompt]: SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = text_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) embeds.append(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 'egg cracking' SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ , negative_prompt=snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A hammer hitting a wooden surface' # test num_waveforms_per_prompt=1 (default) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 ).audios assert audios.shape == (1, 2_5_6) # test num_waveforms_per_prompt=1 (default) for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe([prompt] * batch_size , num_inference_steps=2 ).audios assert audios.shape == (batch_size, 2_5_6) # test num_waveforms_per_prompt for single prompt SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (num_waveforms_per_prompt, 2_5_6) # test num_waveforms_per_prompt for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe( [prompt] * batch_size , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config.sampling_rate SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.016 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.016 SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.032 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.032 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = ['hey'] SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape assert audio_shape == (1, 2_5_6) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config config.model_in_dim *= 2 SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ).to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram assert audio_shape == (1, 2_5_6) def UpperCamelCase ( self : Tuple ): """simple docstring""" self._test_attention_slicing_forward_pass(test_mean_pixel_difference=snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" self._test_inference_batch_single_identical(test_mean_pixel_difference=snake_case__ ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def UpperCamelCase ( self : Dict ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case__ ) @slow class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : Tuple="cpu" , snake_case__ : List[str]=torch.floataa , snake_case__ : Optional[Any]=0 ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = np.random.RandomState(snake_case__ ).standard_normal((1, 8, 1_2_8, 1_6) ) SCREAMING_SNAKE_CASE = torch.from_numpy(snake_case__ ).to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'latents': latents, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 2.5, } return inputs def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 2_5 SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[7_7_2_3_0:7_7_2_4_0] SCREAMING_SNAKE_CASE = np.array( [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 1E-2 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[2_7_7_8_0:2_7_7_9_0] SCREAMING_SNAKE_CASE = np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 3E-2
673
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) a_ : Dict = {'configuration_mbart': ['MBART_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MBartConfig', 'MBartOnnxConfig']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : List[str] = ['MBartTokenizer'] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Optional[Any] = ['MBartTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : List[Any] = [ 'MBART_PRETRAINED_MODEL_ARCHIVE_LIST', 'MBartForCausalLM', 'MBartForConditionalGeneration', 'MBartForQuestionAnswering', 'MBartForSequenceClassification', 'MBartModel', 'MBartPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Any = [ 'TFMBartForConditionalGeneration', 'TFMBartModel', 'TFMBartPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Optional[Any] = [ 'FlaxMBartForConditionalGeneration', 'FlaxMBartForQuestionAnswering', 'FlaxMBartForSequenceClassification', 'FlaxMBartModel', 'FlaxMBartPreTrainedModel', ] if TYPE_CHECKING: from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig, MBartOnnxConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mbart import MBartTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mbart_fast import MBartTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mbart import ( MBART_PRETRAINED_MODEL_ARCHIVE_LIST, MBartForCausalLM, MBartForConditionalGeneration, MBartForQuestionAnswering, MBartForSequenceClassification, MBartModel, MBartPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mbart import TFMBartForConditionalGeneration, TFMBartModel, TFMBartPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mbart import ( FlaxMBartForConditionalGeneration, FlaxMBartForQuestionAnswering, FlaxMBartForSequenceClassification, FlaxMBartModel, FlaxMBartPreTrainedModel, ) else: import sys a_ : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
706
import unittest from parameterized import parameterized from transformers import OpenLlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel class UpperCamelCase : def __init__( self : Dict , snake_case__ : str , snake_case__ : str=1_3 , snake_case__ : Tuple=7 , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : List[str]=False , snake_case__ : Any=True , snake_case__ : Union[str, Any]=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Optional[Any]=5 , snake_case__ : Optional[Any]=4 , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Tuple="gelu" , snake_case__ : Dict=0.1 , snake_case__ : Any=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Dict=1_6 , snake_case__ : str=2 , snake_case__ : Any=0.02 , snake_case__ : List[str]=3 , snake_case__ : int=4 , snake_case__ : List[str]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Dict ): """simple docstring""" return OpenLlamaConfig( 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=snake_case__ , initializer_range=self.initializer_range , use_stable_embedding=snake_case__ , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : int , snake_case__ : List[str] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : Tuple , ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : int , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() # first forward pass SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , use_cache=snake_case__ , ) SCREAMING_SNAKE_CASE = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([input_mask, next_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , past_key_values=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else () ) __UpperCamelCase =(OpenLlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": OpenLlamaModel, "text-classification": OpenLlamaForSequenceClassification, "text-generation": OpenLlamaForCausalLM, "zero-shot": OpenLlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'single_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test' ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" pass @parameterized.expand([('linear',), ('dynamic',)] ) def UpperCamelCase ( self : str , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = ids_tensor([1, 1_0] , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) original_model.to(snake_case__ ) original_model.eval() SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = {'type': scaling_type, 'factor': 10.0} SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) scaled_model.to(snake_case__ ) scaled_model.eval() SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) else: self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
673
0
from .imports import is_rich_available if is_rich_available(): from rich.traceback import install install(show_locals=False) else: raise ModuleNotFoundError("To use the rich extension, install rich with `pip install rich`")
707
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="openai/whisper-base" __UpperCamelCase =( "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the " "transcribed text." ) __UpperCamelCase ="transcriber" __UpperCamelCase =WhisperProcessor __UpperCamelCase =WhisperForConditionalGeneration __UpperCamelCase =["audio"] __UpperCamelCase =["text"] def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.pre_processor(snake_case__ , return_tensors='pt' ).input_features def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" return self.model.generate(inputs=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : Union[str, Any] ): """simple docstring""" return self.pre_processor.batch_decode(snake_case__ , skip_special_tokens=snake_case__ )[0]
673
0
from __future__ import annotations def __lowerCAmelCase ( _UpperCamelCase : list[float] , _UpperCamelCase : List[str] ) -> Optional[Any]: '''simple docstring''' print(f"""Vertex\tShortest Distance from vertex {src}""" ) for i, d in enumerate(_UpperCamelCase ): print(f"""{i}\t\t{d}""" ) def __lowerCAmelCase ( _UpperCamelCase : list[dict[str, int]] , _UpperCamelCase : list[float] , _UpperCamelCase : int ) -> Optional[Any]: '''simple docstring''' for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = (graph[j][k] for k in ["""src""", """dst""", """weight"""]) if distance[u] != float('inf' ) and distance[u] + w < distance[v]: return True return False def __lowerCAmelCase ( _UpperCamelCase : list[dict[str, int]] , _UpperCamelCase : int , _UpperCamelCase : int , _UpperCamelCase : int ) -> list[float]: '''simple docstring''' SCREAMING_SNAKE_CASE = [float('inf' )] * vertex_count SCREAMING_SNAKE_CASE = 0.0 for _ in range(vertex_count - 1 ): for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = (graph[j][k] for k in ["""src""", """dst""", """weight"""]) if distance[u] != float('inf' ) and distance[u] + w < distance[v]: SCREAMING_SNAKE_CASE = distance[u] + w SCREAMING_SNAKE_CASE = check_negative_cycle(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) if negative_cycle_exists: raise Exception('Negative cycle found' ) return distance if __name__ == "__main__": import doctest doctest.testmod() a_ : str = int(input("Enter number of vertices: ").strip()) a_ : str = int(input("Enter number of edges: ").strip()) a_ : int = [{} for _ in range(E)] for i in range(E): print("Edge ", i + 1) a_ , a_ , a_ : List[str] = ( int(x) for x in input("Enter source, destination, weight: ").strip().split(" ") ) a_ : int = {"src": src, "dst": dest, "weight": weight} a_ : Optional[int] = int(input("\nEnter shortest path source:").strip()) a_ : List[str] = bellman_ford(graph, V, E, source) print_distance(shortest_distance, 0)
708
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
673
0
import os import tempfile import unittest import uuid from pathlib import Path from transformers.testing_utils import get_tests_dir, require_soundfile, require_torch, require_vision from transformers.tools.agent_types import AgentAudio, AgentImage, AgentText from transformers.utils import is_soundfile_availble, is_torch_available, is_vision_available if is_torch_available(): import torch if is_soundfile_availble(): import soundfile as sf if is_vision_available(): from PIL import Image def __lowerCAmelCase ( _UpperCamelCase : int="" ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = tempfile.mkdtemp() return os.path.join(lowerCAmelCase__ , str(uuid.uuida() ) + suffix ) @require_soundfile @require_torch class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.rand(1_2 , dtype=torch.floataa ) - 0.5 SCREAMING_SNAKE_CASE = AgentAudio(UpperCamelCase__ ) SCREAMING_SNAKE_CASE = str(agent_type.to_string() ) # Ensure that the tensor and the agent_type's tensor are the same self.assertTrue(torch.allclose(UpperCamelCase__ , agent_type.to_raw() , atol=1E-4 ) ) del agent_type # Ensure the path remains even after the object deletion self.assertTrue(os.path.exists(UpperCamelCase__ ) ) # Ensure that the file contains the same value as the original tensor SCREAMING_SNAKE_CASE = sf.read(UpperCamelCase__ ) self.assertTrue(torch.allclose(UpperCamelCase__ , torch.tensor(UpperCamelCase__ ) , atol=1E-4 ) ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.rand(1_2 , dtype=torch.floataa ) - 0.5 SCREAMING_SNAKE_CASE = get_new_path(suffix='.wav' ) sf.write(UpperCamelCase__ , UpperCamelCase__ , 1_6_0_0_0 ) SCREAMING_SNAKE_CASE = AgentAudio(UpperCamelCase__ ) self.assertTrue(torch.allclose(UpperCamelCase__ , agent_type.to_raw() , atol=1E-4 ) ) self.assertEqual(agent_type.to_string() , UpperCamelCase__ ) @require_vision @require_torch class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.randint(0 , 2_5_6 , (6_4, 6_4, 3) ) SCREAMING_SNAKE_CASE = AgentImage(UpperCamelCase__ ) SCREAMING_SNAKE_CASE = str(agent_type.to_string() ) # Ensure that the tensor and the agent_type's tensor are the same self.assertTrue(torch.allclose(UpperCamelCase__ , agent_type._tensor , atol=1E-4 ) ) self.assertIsInstance(agent_type.to_raw() , Image.Image ) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(UpperCamelCase__ ) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = Path(get_tests_dir('fixtures/tests_samples/COCO' ) ) / '000000039769.png' SCREAMING_SNAKE_CASE = Image.open(UpperCamelCase__ ) SCREAMING_SNAKE_CASE = AgentImage(UpperCamelCase__ ) self.assertTrue(path.samefile(agent_type.to_string() ) ) self.assertTrue(image == agent_type.to_raw() ) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(UpperCamelCase__ ) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = Path(get_tests_dir('fixtures/tests_samples/COCO' ) ) / '000000039769.png' SCREAMING_SNAKE_CASE = Image.open(UpperCamelCase__ ) SCREAMING_SNAKE_CASE = AgentImage(UpperCamelCase__ ) self.assertFalse(path.samefile(agent_type.to_string() ) ) self.assertTrue(image == agent_type.to_raw() ) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(UpperCamelCase__ ) ) class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = 'Hey!' SCREAMING_SNAKE_CASE = AgentText(UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , agent_type.to_string() ) self.assertEqual(UpperCamelCase__ , agent_type.to_raw() ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ )
709
import numpy as np def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return 1 / (1 + np.exp(-vector )) def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return vector * sigmoid(_UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
673
0
from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class UpperCamelCase ( a__ ): __UpperCamelCase =DistilBertTokenizer __UpperCamelCase =DistilBertTokenizerFast __UpperCamelCase =True @slow def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = DistilBertTokenizer.from_pretrained('distilbert-base-uncased' ) SCREAMING_SNAKE_CASE = tokenizer.encode('sequence builders' , add_special_tokens=lowerCamelCase_ ) SCREAMING_SNAKE_CASE = tokenizer.encode('multi-sequence build' , add_special_tokens=lowerCamelCase_ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(lowerCamelCase_ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(lowerCamelCase_ , lowerCamelCase_ ) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]
710
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
673
0
def __lowerCAmelCase ( _UpperCamelCase : int = 10 , _UpperCamelCase : int = 10_00 , _UpperCamelCase : bool = True ) -> Any: '''simple docstring''' assert ( isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(_UpperCamelCase , _UpperCamelCase ) ), "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 __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : int ) -> int: '''simple docstring''' return int((number_a + number_a) / 2 ) def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : int , _UpperCamelCase : int ) -> Dict: '''simple docstring''' assert ( isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(_UpperCamelCase , _UpperCamelCase ) ), '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(_UpperCamelCase : int ) -> str: if number > to_guess: return "high" elif number < to_guess: return "low" else: return "same" print('started...' ) SCREAMING_SNAKE_CASE = lower SCREAMING_SNAKE_CASE = higher SCREAMING_SNAKE_CASE = [] while True: SCREAMING_SNAKE_CASE = get_avg(_UpperCamelCase , _UpperCamelCase ) last_numbers.append(_UpperCamelCase ) if answer(_UpperCamelCase ) == "low": SCREAMING_SNAKE_CASE = number elif answer(_UpperCamelCase ) == "high": SCREAMING_SNAKE_CASE = number else: break print(f"""guess the number : {last_numbers[-1]}""" ) print(f"""details : {last_numbers!s}""" ) def __lowerCAmelCase ( ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = int(input('Enter lower value : ' ).strip() ) SCREAMING_SNAKE_CASE = int(input('Enter high value : ' ).strip() ) SCREAMING_SNAKE_CASE = int(input('Enter value to guess : ' ).strip() ) guess_the_number(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) if __name__ == "__main__": main()
711
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
673
0
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig from transformers.utils import logging logging.set_verbosity_info() a_ : Optional[int] = logging.get_logger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] ) -> Dict: '''simple docstring''' if "resnet-50" in model_name: SCREAMING_SNAKE_CASE = ResNetConfig.from_pretrained('microsoft/resnet-50' ) elif "resnet-101" in model_name: SCREAMING_SNAKE_CASE = ResNetConfig.from_pretrained('microsoft/resnet-101' ) else: raise ValueError('Model name should include either resnet50 or resnet101' ) SCREAMING_SNAKE_CASE = DetrConfig(use_timm_backbone=__lowerCAmelCase , backbone_config=__lowerCAmelCase ) # set label attributes SCREAMING_SNAKE_CASE = 'panoptic' in model_name if is_panoptic: SCREAMING_SNAKE_CASE = 2_50 else: SCREAMING_SNAKE_CASE = 91 SCREAMING_SNAKE_CASE = 'huggingface/label-files' SCREAMING_SNAKE_CASE = 'coco-detection-id2label.json' SCREAMING_SNAKE_CASE = json.load(open(hf_hub_download(__lowerCAmelCase , __lowerCAmelCase , repo_type='dataset' ) , 'r' ) ) SCREAMING_SNAKE_CASE = {int(__lowerCAmelCase ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = idalabel SCREAMING_SNAKE_CASE = {v: k for k, v in idalabel.items()} return config, is_panoptic def __lowerCAmelCase ( _UpperCamelCase : Tuple ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = [] # stem # fmt: off rename_keys.append(('backbone.0.body.conv1.weight', 'backbone.conv_encoder.model.embedder.embedder.convolution.weight') ) rename_keys.append(('backbone.0.body.bn1.weight', 'backbone.conv_encoder.model.embedder.embedder.normalization.weight') ) rename_keys.append(('backbone.0.body.bn1.bias', 'backbone.conv_encoder.model.embedder.embedder.normalization.bias') ) rename_keys.append(('backbone.0.body.bn1.running_mean', 'backbone.conv_encoder.model.embedder.embedder.normalization.running_mean') ) rename_keys.append(('backbone.0.body.bn1.running_var', 'backbone.conv_encoder.model.embedder.embedder.normalization.running_var') ) # stages for stage_idx in range(len(config.backbone_config.depths ) ): for layer_idx in range(config.backbone_config.depths[stage_idx] ): # shortcut if layer_idx == 0: rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var""", ) ) # 3 convs for i in range(3 ): rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean""", ) ) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""", ) ) # fmt: on for i in range(config.encoder_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append( ( f"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""", f"""encoder.layers.{i}.self_attn.out_proj.weight""", ) ) rename_keys.append( (f"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", f"""encoder.layers.{i}.self_attn.out_proj.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""encoder.layers.{i}.fc1.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""encoder.layers.{i}.fc1.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""encoder.layers.{i}.fc2.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""encoder.layers.{i}.fc2.bias""") ) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm1.weight""", f"""encoder.layers.{i}.self_attn_layer_norm.weight""") ) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm1.bias""", f"""encoder.layers.{i}.self_attn_layer_norm.bias""") ) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm2.weight""", f"""encoder.layers.{i}.final_layer_norm.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""encoder.layers.{i}.final_layer_norm.bias""") ) # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms rename_keys.append( ( f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""decoder.layers.{i}.self_attn.out_proj.weight""", ) ) rename_keys.append( (f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""decoder.layers.{i}.self_attn.out_proj.bias""") ) rename_keys.append( ( f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""", f"""decoder.layers.{i}.encoder_attn.out_proj.weight""", ) ) rename_keys.append( ( f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""", f"""decoder.layers.{i}.encoder_attn.out_proj.bias""", ) ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""decoder.layers.{i}.fc1.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""decoder.layers.{i}.fc1.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""decoder.layers.{i}.fc2.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""decoder.layers.{i}.fc2.bias""") ) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm1.weight""", f"""decoder.layers.{i}.self_attn_layer_norm.weight""") ) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm1.bias""", f"""decoder.layers.{i}.self_attn_layer_norm.bias""") ) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm2.weight""", f"""decoder.layers.{i}.encoder_attn_layer_norm.weight""") ) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm2.bias""", f"""decoder.layers.{i}.encoder_attn_layer_norm.bias""") ) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm3.weight""", f"""decoder.layers.{i}.final_layer_norm.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""decoder.layers.{i}.final_layer_norm.bias""") ) # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads rename_keys.extend( [ ('input_proj.weight', 'input_projection.weight'), ('input_proj.bias', 'input_projection.bias'), ('query_embed.weight', 'query_position_embeddings.weight'), ('transformer.decoder.norm.weight', 'decoder.layernorm.weight'), ('transformer.decoder.norm.bias', 'decoder.layernorm.bias'), ('class_embed.weight', 'class_labels_classifier.weight'), ('class_embed.bias', 'class_labels_classifier.bias'), ('bbox_embed.layers.0.weight', 'bbox_predictor.layers.0.weight'), ('bbox_embed.layers.0.bias', 'bbox_predictor.layers.0.bias'), ('bbox_embed.layers.1.weight', 'bbox_predictor.layers.1.weight'), ('bbox_embed.layers.1.bias', 'bbox_predictor.layers.1.bias'), ('bbox_embed.layers.2.weight', 'bbox_predictor.layers.2.weight'), ('bbox_embed.layers.2.bias', 'bbox_predictor.layers.2.bias'), ] ) return rename_keys def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Optional[Any] , _UpperCamelCase : Any ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = state_dict.pop(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = val def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : str=False ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = '' if is_panoptic: SCREAMING_SNAKE_CASE = 'detr.' # first: transformer encoder for i in range(6 ): # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias) SCREAMING_SNAKE_CASE = state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias""" ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE = in_proj_weight[:2_56, :] SCREAMING_SNAKE_CASE = in_proj_bias[:2_56] SCREAMING_SNAKE_CASE = in_proj_weight[2_56:5_12, :] SCREAMING_SNAKE_CASE = in_proj_bias[2_56:5_12] SCREAMING_SNAKE_CASE = in_proj_weight[-2_56:, :] SCREAMING_SNAKE_CASE = in_proj_bias[-2_56:] # next: transformer decoder (which is a bit more complex because it also includes cross-attention) for i in range(6 ): # read in weights + bias of input projection layer of self-attention SCREAMING_SNAKE_CASE = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias""" ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE = in_proj_weight[:2_56, :] SCREAMING_SNAKE_CASE = in_proj_bias[:2_56] SCREAMING_SNAKE_CASE = in_proj_weight[2_56:5_12, :] SCREAMING_SNAKE_CASE = in_proj_bias[2_56:5_12] SCREAMING_SNAKE_CASE = in_proj_weight[-2_56:, :] SCREAMING_SNAKE_CASE = in_proj_bias[-2_56:] # read in weights + bias of input projection layer of cross-attention SCREAMING_SNAKE_CASE = state_dict.pop( f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias""" ) # next, add query, keys and values (in that order) of cross-attention to the state dict SCREAMING_SNAKE_CASE = in_proj_weight_cross_attn[:2_56, :] SCREAMING_SNAKE_CASE = in_proj_bias_cross_attn[:2_56] SCREAMING_SNAKE_CASE = in_proj_weight_cross_attn[2_56:5_12, :] SCREAMING_SNAKE_CASE = in_proj_bias_cross_attn[2_56:5_12] SCREAMING_SNAKE_CASE = in_proj_weight_cross_attn[-2_56:, :] SCREAMING_SNAKE_CASE = in_proj_bias_cross_attn[-2_56:] def __lowerCAmelCase ( ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = 'http://images.cocodataset.org/val2017/000000039769.jpg' SCREAMING_SNAKE_CASE = Image.open(requests.get(__lowerCAmelCase , stream=__lowerCAmelCase ).raw ) return im @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : Dict=None , _UpperCamelCase : Any=False ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = get_detr_config(__lowerCAmelCase ) # load original model from torch hub SCREAMING_SNAKE_CASE = { 'detr-resnet-50': 'detr_resnet50', 'detr-resnet-101': 'detr_resnet101', } logger.info(f"""Converting model {model_name}...""" ) SCREAMING_SNAKE_CASE = torch.hub.load('facebookresearch/detr' , model_name_to_original_name[model_name] , pretrained=__lowerCAmelCase ).eval() SCREAMING_SNAKE_CASE = detr.state_dict() # rename keys for src, dest in create_rename_keys(__lowerCAmelCase ): if is_panoptic: SCREAMING_SNAKE_CASE = 'detr.' + src rename_key(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) # query, key and value matrices need special treatment read_in_q_k_v(__lowerCAmelCase , is_panoptic=__lowerCAmelCase ) # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them SCREAMING_SNAKE_CASE = 'detr.model.' if is_panoptic else 'model.' for key in state_dict.copy().keys(): if is_panoptic: if ( key.startswith('detr' ) and not key.startswith('class_labels_classifier' ) and not key.startswith('bbox_predictor' ) ): SCREAMING_SNAKE_CASE = state_dict.pop(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = val elif "class_labels_classifier" in key or "bbox_predictor" in key: SCREAMING_SNAKE_CASE = state_dict.pop(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = val elif key.startswith('bbox_attention' ) or key.startswith('mask_head' ): continue else: SCREAMING_SNAKE_CASE = state_dict.pop(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = val else: if not key.startswith('class_labels_classifier' ) and not key.startswith('bbox_predictor' ): SCREAMING_SNAKE_CASE = state_dict.pop(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = val # finally, create HuggingFace model and load state dict SCREAMING_SNAKE_CASE = DetrForSegmentation(__lowerCAmelCase ) if is_panoptic else DetrForObjectDetection(__lowerCAmelCase ) model.load_state_dict(__lowerCAmelCase ) model.eval() # verify our conversion on an image SCREAMING_SNAKE_CASE = 'coco_panoptic' if is_panoptic else 'coco_detection' SCREAMING_SNAKE_CASE = DetrImageProcessor(format=__lowerCAmelCase ) SCREAMING_SNAKE_CASE = processor(images=prepare_img() , return_tensors='pt' ) SCREAMING_SNAKE_CASE = encoding['pixel_values'] SCREAMING_SNAKE_CASE = detr(__lowerCAmelCase ) SCREAMING_SNAKE_CASE = model(__lowerCAmelCase ) assert torch.allclose(outputs.logits , original_outputs['pred_logits'] , atol=1e-3 ) assert torch.allclose(outputs.pred_boxes , original_outputs['pred_boxes'] , atol=1e-3 ) if is_panoptic: assert torch.allclose(outputs.pred_masks , original_outputs['pred_masks'] , atol=1e-4 ) print('Looks ok!' ) if pytorch_dump_folder_path is not None: # Save model and image processor logger.info(f"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}...""" ) Path(__lowerCAmelCase ).mkdir(exist_ok=__lowerCAmelCase ) model.save_pretrained(__lowerCAmelCase ) processor.save_pretrained(__lowerCAmelCase ) if push_to_hub: # Upload model and image processor to the hub logger.info('Uploading PyTorch model and image processor to the hub...' ) model.push_to_hub(f"""nielsr/{model_name}""" ) processor.push_to_hub(f"""nielsr/{model_name}""" ) if __name__ == "__main__": a_ : Any = argparse.ArgumentParser() parser.add_argument( "--model_name", default="detr-resnet-50", type=str, choices=["detr-resnet-50", "detr-resnet-101"], help="Name of the DETR model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model." ) parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to the hub or not.") a_ : Tuple = parser.parse_args() convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
712
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : Dict = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Any , **snake_case__ : Optional[int] ): """simple docstring""" super().__init__(**snake_case__ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(snake_case__ ) def __call__( self : List[Any] , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(snake_case__ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {'image': image, 'candidate_labels': candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(snake_case__ , **snake_case__ ) return results def UpperCamelCase ( self : Union[str, Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs['threshold'] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs['top_k'] return {}, {}, postprocess_params def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs['candidate_labels'] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = self.tokenizer(snake_case__ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(snake_case__ , return_tensors=self.framework ) yield { "is_last": i == len(snake_case__ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**snake_case__ ) SCREAMING_SNAKE_CASE = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output['candidate_label'] SCREAMING_SNAKE_CASE = BaseModelOutput(snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=snake_case__ , threshold=snake_case__ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs['scores'][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {'score': score, 'label': label, 'box': box} results.append(snake_case__ ) SCREAMING_SNAKE_CASE = sorted(snake_case__ , key=lambda snake_case__ : x["score"] , reverse=snake_case__ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : List[Any] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
673
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a_ : Any = { "configuration_time_series_transformer": [ "TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP", "TimeSeriesTransformerConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Dict = [ "TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST", "TimeSeriesTransformerForPrediction", "TimeSeriesTransformerModel", "TimeSeriesTransformerPreTrainedModel", ] if TYPE_CHECKING: from .configuration_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimeSeriesTransformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimeSeriesTransformerForPrediction, TimeSeriesTransformerModel, TimeSeriesTransformerPreTrainedModel, ) else: import sys a_ : str = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
713
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
673
0
# Copyright 2023 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available a_ : str = { "configuration_efficientnet": [ "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "EfficientNetConfig", "EfficientNetOnnxConfig", ] } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : str = ["EfficientNetImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : str = [ "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST", "EfficientNetForImageClassification", "EfficientNetModel", "EfficientNetPreTrainedModel", ] if TYPE_CHECKING: from .configuration_efficientnet import ( EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientNetConfig, EfficientNetOnnxConfig, ) try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_efficientnet import EfficientNetImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_efficientnet import ( EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST, EfficientNetForImageClassification, EfficientNetModel, EfficientNetPreTrainedModel, ) else: import sys a_ : Tuple = _LazyModule(__name__, globals()["__file__"], _import_structure)
714
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
673
0
from ...configuration_utils import PretrainedConfig from ...utils import logging a_ : List[str] = logging.get_logger(__name__) a_ : Optional[Any] = { "google/switch-base-8": "https://huggingface.co/google/switch-base-8/blob/main/config.json", } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="switch_transformers" __UpperCamelCase =["past_key_values"] __UpperCamelCase ={"hidden_size": "d_model", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self : str , snake_case__ : int=3_2_1_2_8 , snake_case__ : Optional[Any]=7_6_8 , snake_case__ : Optional[Any]=6_4 , snake_case__ : Optional[int]=2_0_4_8 , snake_case__ : List[str]=6_4 , snake_case__ : int=1_2 , snake_case__ : List[Any]=3 , snake_case__ : Union[str, Any]=1_2 , snake_case__ : Optional[int]=3 , snake_case__ : str=1_2 , snake_case__ : Optional[int]=8 , snake_case__ : List[str]=False , snake_case__ : Any=0.01 , snake_case__ : Union[str, Any]="float32" , snake_case__ : List[str]=False , snake_case__ : int=3_2 , snake_case__ : Tuple=1_2_8 , snake_case__ : List[str]=0.1 , snake_case__ : Union[str, Any]=1E-6 , snake_case__ : Union[str, Any]=0.001 , snake_case__ : Any=0.001 , snake_case__ : Dict=1.0 , snake_case__ : Optional[int]="relu" , snake_case__ : List[str]=True , snake_case__ : List[str]=False , snake_case__ : int=True , snake_case__ : Tuple=0 , snake_case__ : Optional[Any]=1 , **snake_case__ : Optional[int] , ): """simple docstring""" SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = d_model SCREAMING_SNAKE_CASE = d_kv SCREAMING_SNAKE_CASE = d_ff SCREAMING_SNAKE_CASE = num_sparse_encoder_layers SCREAMING_SNAKE_CASE = num_layers SCREAMING_SNAKE_CASE = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry SCREAMING_SNAKE_CASE = num_sparse_decoder_layers # This tells us, each how many encoder layer we'll have to set a sparse layer. if self.num_sparse_encoder_layers > 0: SCREAMING_SNAKE_CASE = self.num_layers // self.num_sparse_encoder_layers else: SCREAMING_SNAKE_CASE = self.num_layers # HACK: this will create 0 sparse layers # This tells us, each how many encoder layer we'll have to set a sparse layer. if self.num_sparse_decoder_layers > 0: SCREAMING_SNAKE_CASE = self.num_decoder_layers // self.num_sparse_decoder_layers else: SCREAMING_SNAKE_CASE = self.num_decoder_layers # HACK: this will create 0 sparse layers SCREAMING_SNAKE_CASE = num_heads SCREAMING_SNAKE_CASE = num_experts SCREAMING_SNAKE_CASE = expert_capacity SCREAMING_SNAKE_CASE = router_bias SCREAMING_SNAKE_CASE = router_jitter_noise if router_dtype not in ["float32", "float16", "bfloat16"]: raise ValueError(F"""`router_dtype` must be one of \'float32\', \'float16\' or \'bfloat16\', got {router_dtype}""" ) SCREAMING_SNAKE_CASE = router_dtype SCREAMING_SNAKE_CASE = router_ignore_padding_tokens SCREAMING_SNAKE_CASE = relative_attention_num_buckets SCREAMING_SNAKE_CASE = relative_attention_max_distance SCREAMING_SNAKE_CASE = dropout_rate SCREAMING_SNAKE_CASE = layer_norm_epsilon SCREAMING_SNAKE_CASE = initializer_factor SCREAMING_SNAKE_CASE = feed_forward_proj SCREAMING_SNAKE_CASE = use_cache SCREAMING_SNAKE_CASE = add_router_probs SCREAMING_SNAKE_CASE = router_z_loss_coef SCREAMING_SNAKE_CASE = router_aux_loss_coef SCREAMING_SNAKE_CASE = self.feed_forward_proj.split('-' ) SCREAMING_SNAKE_CASE = act_info[-1] SCREAMING_SNAKE_CASE = act_info[0] == 'gated' if len(__UpperCamelCase ) > 1 and act_info[0] != "gated" or len(__UpperCamelCase ) > 2: raise ValueError( F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.""" 'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. ' '\'gated-gelu\' or \'relu\'' ) # for backwards compatibility if feed_forward_proj == "gated-gelu": SCREAMING_SNAKE_CASE = 'gelu_new' super().__init__( pad_token_id=__UpperCamelCase , eos_token_id=__UpperCamelCase , is_encoder_decoder=__UpperCamelCase , **__UpperCamelCase , )
715
# Note: if you intend to run this script make sure you look under scripts/fsmt/ # to locate the appropriate script to do the work correctly. There is a set of scripts to: # - download and prepare data and run the conversion script # - perform eval to get the best hparam into the config # - generate model_cards - useful if you have multiple models from the same paper import argparse import json import os import re from collections import OrderedDict from os.path import basename, dirname import fairseq import torch from fairseq import hub_utils from fairseq.data.dictionary import Dictionary from transformers import FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() a_ : str = 2 # based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping` # values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults: # # * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users) # * `early_stopping`: `False` consistently scored better # * `length_penalty` varied, so will assign the best one depending on the model a_ : int = { # fairseq: "wmt19-ru-en": {"length_penalty": 1.1}, "wmt19-en-ru": {"length_penalty": 1.1_5}, "wmt19-en-de": {"length_penalty": 1.0}, "wmt19-de-en": {"length_penalty": 1.1}, # allenai: "wmt16-en-de-dist-12-1": {"length_penalty": 0.6}, "wmt16-en-de-dist-6-1": {"length_penalty": 0.6}, "wmt16-en-de-12-1": {"length_penalty": 0.8}, "wmt19-de-en-6-6-base": {"length_penalty": 0.6}, "wmt19-de-en-6-6-big": {"length_penalty": 0.6}, } # this remaps the different models to their organization names a_ : str = {} for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: a_ : List[Any] = "facebook" for m in [ "wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1", "wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big", ]: a_ : Any = "allenai" def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = dict((re.sub(R'@@$' , '' , _UpperCamelCase ), v) if k.endswith('@@' ) else (re.sub(R'$' , '</w>' , _UpperCamelCase ), v) for k, v in d.items() ) SCREAMING_SNAKE_CASE = '<s> <pad> </s> <unk>'.split() # restore the special tokens for k in keep_keys: del da[f"""{k}</w>"""] SCREAMING_SNAKE_CASE = d[k] # restore return da def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[str] ) -> Dict: '''simple docstring''' assert os.path.exists(_UpperCamelCase ) os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) print(f"""Writing results to {pytorch_dump_folder_path}""" ) # handle various types of models SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel SCREAMING_SNAKE_CASE = cls.hub_models() SCREAMING_SNAKE_CASE = {'bpe': 'fastbpe', 'tokenizer': 'moses'} SCREAMING_SNAKE_CASE = '.' # note: since the model dump is old, fairseq has upgraded its model some # time later, and it does a whole lot of rewrites and splits on the saved # weights, therefore we can't use torch.load() directly on the model file. # see: upgrade_state_dict(state_dict) in fairseq_model.py print(f"""using checkpoint {checkpoint_file}""" ) SCREAMING_SNAKE_CASE = hub_utils.from_pretrained( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , archive_map=_UpperCamelCase , **_UpperCamelCase ) SCREAMING_SNAKE_CASE = vars(chkpt['args']['model'] ) SCREAMING_SNAKE_CASE = args['source_lang'] SCREAMING_SNAKE_CASE = args['target_lang'] SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) # dicts SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{src_lang}.txt""" ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{tgt_lang}.txt""" ) SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(src_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-src.json' ) print(f"""Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # detect whether this is a do_lower_case situation, which can be derived by checking whether we # have at least one uppercase letter in the source vocab SCREAMING_SNAKE_CASE = True for k in src_vocab.keys(): if not k.islower(): SCREAMING_SNAKE_CASE = False break SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(tgt_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-tgt.json' ) print(f"""Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # merges_file (bpecodes) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , VOCAB_FILES_NAMES['merges_file'] ) for fn in ["bpecodes", "code"]: # older fairseq called the merges file "code" SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) if os.path.exists(_UpperCamelCase ): break with open(_UpperCamelCase , encoding='utf-8' ) as fin: SCREAMING_SNAKE_CASE = fin.read() SCREAMING_SNAKE_CASE = re.sub(R' \d+$' , '' , _UpperCamelCase , 0 , re.M ) # remove frequency number print(f"""Generating {merges_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as fout: fout.write(_UpperCamelCase ) # model config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'config.json' ) # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe - # may have to modify the tokenizer if a different type is used by a future model assert args["bpe"] == "fastbpe", f"""need to extend tokenizer to support bpe={args['bpe']}""" assert args["tokenizer"] == "moses", f"""need to extend tokenizer to support bpe={args['tokenizer']}""" SCREAMING_SNAKE_CASE = { 'architectures': ['FSMTForConditionalGeneration'], 'model_type': 'fsmt', 'activation_dropout': args['activation_dropout'], 'activation_function': 'relu', 'attention_dropout': args['attention_dropout'], 'd_model': args['decoder_embed_dim'], 'dropout': args['dropout'], 'init_std': 0.02, 'max_position_embeddings': args['max_source_positions'], 'num_hidden_layers': args['encoder_layers'], 'src_vocab_size': src_vocab_size, 'tgt_vocab_size': tgt_vocab_size, 'langs': [src_lang, tgt_lang], 'encoder_attention_heads': args['encoder_attention_heads'], 'encoder_ffn_dim': args['encoder_ffn_embed_dim'], 'encoder_layerdrop': args['encoder_layerdrop'], 'encoder_layers': args['encoder_layers'], 'decoder_attention_heads': args['decoder_attention_heads'], 'decoder_ffn_dim': args['decoder_ffn_embed_dim'], 'decoder_layerdrop': args['decoder_layerdrop'], 'decoder_layers': args['decoder_layers'], 'bos_token_id': 0, 'pad_token_id': 1, 'eos_token_id': 2, 'is_encoder_decoder': True, 'scale_embedding': not args['no_scale_embedding'], 'tie_word_embeddings': args['share_all_embeddings'], } # good hparam defaults to start with SCREAMING_SNAKE_CASE = 5 SCREAMING_SNAKE_CASE = False if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]: SCREAMING_SNAKE_CASE = best_score_hparams[model_dir]['length_penalty'] else: SCREAMING_SNAKE_CASE = 1.0 print(f"""Generating {fsmt_model_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # tokenizer config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = { 'langs': [src_lang, tgt_lang], 'model_max_length': 10_24, 'do_lower_case': do_lower_case, } print(f"""Generating {fsmt_tokenizer_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # model SCREAMING_SNAKE_CASE = chkpt['models'][0] SCREAMING_SNAKE_CASE = model.state_dict() # rename keys to start with 'model.' SCREAMING_SNAKE_CASE = OrderedDict(('model.' + k, v) for k, v in model_state_dict.items() ) # remove unneeded keys SCREAMING_SNAKE_CASE = [ 'model.model', 'model.encoder.version', 'model.decoder.version', 'model.encoder_embed_tokens.weight', 'model.decoder_embed_tokens.weight', 'model.encoder.embed_positions._float_tensor', 'model.decoder.embed_positions._float_tensor', ] for k in ignore_keys: model_state_dict.pop(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTForConditionalGeneration(_UpperCamelCase ) # check that it loads ok model_new.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) # save SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) print(f"""Generating {pytorch_weights_dump_path}""" ) torch.save(_UpperCamelCase , _UpperCamelCase ) print('Conversion is done!' ) print('\nLast step is to upload the files to s3' ) print(f"""cd {data_root}""" ) print(f"""transformers-cli upload {model_dir}""" ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--fsmt_checkpoint_path", default=None, type=str, required=True, help=( "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts," " bpecodes, etc." ), ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) a_ : int = parser.parse_args() convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
673
0
class UpperCamelCase ( SCREAMING_SNAKE_CASE ): pass class UpperCamelCase ( SCREAMING_SNAKE_CASE ): pass class UpperCamelCase : def __init__( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = [ [], [], [], ] def UpperCamelCase ( self : List[Any] , snake_case__ : Any , snake_case__ : Optional[Any] ): """simple docstring""" try: if len(self.queues[priority] ) >= 1_0_0: raise OverflowError('Maximum queue size is 100' ) self.queues[priority].append(snake_case__ ) except IndexError: raise ValueError('Valid priorities are 0, 1, and 2' ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" for queue in self.queues: if queue: return queue.pop(0 ) raise UnderFlowError('All queues are empty' ) def __str__( self : Tuple ): """simple docstring""" return "\n".join(F"""Priority {i}: {q}""" for i, q in enumerate(self.queues ) ) class UpperCamelCase : def __init__( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = [] def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Dict ): """simple docstring""" if len(self.queue ) == 1_0_0: raise OverFlowError('Maximum queue size is 100' ) self.queue.append(snake_case__ ) def UpperCamelCase ( self : str ): """simple docstring""" if not self.queue: raise UnderFlowError('The queue is empty' ) else: SCREAMING_SNAKE_CASE = min(self.queue ) self.queue.remove(snake_case__ ) return data def __str__( self : int ): """simple docstring""" return str(self.queue ) def __lowerCAmelCase ( ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = FixedPriorityQueue() fpq.enqueue(0 , 10 ) fpq.enqueue(1 , 70 ) fpq.enqueue(0 , 1_00 ) fpq.enqueue(2 , 1 ) fpq.enqueue(2 , 5 ) fpq.enqueue(1 , 7 ) fpq.enqueue(2 , 4 ) fpq.enqueue(1 , 64 ) fpq.enqueue(0 , 1_28 ) print(_UpperCamelCase ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(_UpperCamelCase ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) print(fpq.dequeue() ) def __lowerCAmelCase ( ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = ElementPriorityQueue() epq.enqueue(10 ) epq.enqueue(70 ) epq.enqueue(1_00 ) epq.enqueue(1 ) epq.enqueue(5 ) epq.enqueue(7 ) epq.enqueue(4 ) epq.enqueue(64 ) epq.enqueue(1_28 ) print(_UpperCamelCase ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(_UpperCamelCase ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) print(epq.dequeue() ) if __name__ == "__main__": fixed_priority_queue() element_priority_queue()
716
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
673
0
import unittest from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin a_ : Any = get_tests_dir("fixtures/test_sentencepiece.model") @require_sentencepiece @require_tokenizers class UpperCamelCase ( __UpperCAmelCase , unittest.TestCase ): __UpperCamelCase =XLNetTokenizer __UpperCamelCase =XLNetTokenizerFast __UpperCamelCase =True __UpperCamelCase =True def UpperCamelCase ( self : List[str] ): """simple docstring""" super().setUp() # We have a SentencePiece fixture for testing SCREAMING_SNAKE_CASE = XLNetTokenizer(snake_case__ , keep_accents=snake_case__ ) tokenizer.sanitize_special_tokens() tokenizer.save_pretrained(self.tmpdirname ) def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = '<s>' SCREAMING_SNAKE_CASE = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case__ ) , snake_case__ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case__ ) , snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '<unk>' ) self.assertEqual(vocab_keys[1] , '<s>' ) self.assertEqual(vocab_keys[-1] , '<eod>' ) self.assertEqual(len(snake_case__ ) , 1_0_0_6 ) def UpperCamelCase ( self : Dict ): """simple docstring""" self.assertEqual(self.get_tokenizer().vocab_size , 1_0_0_0 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = XLNetTokenizer(snake_case__ , keep_accents=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('This is a test' ) self.assertListEqual(snake_case__ , ['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2] ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( snake_case__ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.', ] , ) SCREAMING_SNAKE_CASE = tokenizer.convert_tokens_to_ids(snake_case__ ) self.assertListEqual(snake_case__ , [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4] ) SCREAMING_SNAKE_CASE = tokenizer.convert_ids_to_tokens(snake_case__ ) self.assertListEqual( snake_case__ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.', ] , ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = XLNetTokenizer(snake_case__ , do_lower_case=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( snake_case__ , [ SPIECE_UNDERLINE + '', 'i', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 'se', '.', ] , ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['▁he', 'll', 'o'] ) def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = XLNetTokenizer(snake_case__ , do_lower_case=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( snake_case__ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 'se', '.', ] , ) @slow def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = XLNetTokenizer.from_pretrained('xlnet-base-cased' ) SCREAMING_SNAKE_CASE = tokenizer.encode('sequence builders' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.encode('multi-sequence build' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ , snake_case__ ) assert encoded_sentence == text + [4, 3] assert encoded_pair == text + [4] + text_a + [4, 3] @slow def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = {'input_ids': [[1_7, 2_1_4_4_2, 2_7_0, 1_7, 1_0, 1_4_6_4_5, 3_1_8, 3_4, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 7_7_5_2, 2_2_0_1_8, 2_3, 2_1, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 3_3_5_2, 1_4_4_3_1, 1_3, 5_5_0_0, 1_1, 1_1_7_6, 5_8_0, 1_3, 1_6_8_1_9, 4_7_9_7, 2_3, 1_7, 1_0, 1_7_1_3_5, 6_5_8, 1_9, 4_5_7, 7_9_3_2, 1_3, 1_8_4, 1_9, 3_1_5_4, 1_7_1_3_5, 6_4_6_8, 1_9, 1_4_0_4, 1_2_2_6_9, 1_9, 4_2_2_9, 5_3_5_6, 1_6_2_6_4, 4_6, 1_9, 1_7, 2_0_5_4_5, 1_0_3_9_5, 9, 9, 9, 1_1, 2_8, 6_4_2_1, 9_5_3_1, 2_0_7_2_9, 1_7, 1_0, 3_5_3, 1_7_0_2_2, 1_1, 2_1, 6_4_2_1, 9_5_3_1, 1_6_9_4_9, 1_7, 1_0, 1_1_5_0_9, 7_5_3, 1_1, 3_3, 9_5, 2_4_2_1, 7_3_8_5, 9_5_6, 1_4_4_3_1, 2_6_2_6, 2_5, 8_4_2, 7_3_8_5, 4_8_3_6, 2_1, 1_4_2_9, 2_2_7_2, 9_8_5_5, 3_1_2_0, 1_6_1, 2_4_7_3_8, 1_9, 1_3_2_0_3, 6_5_8, 2_1_8, 7_8_7, 2_1, 4_3_0, 1_8_4_8_2, 8_4_7, 2_6_3_7, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2_2, 2_2_1_7_8, 2_7, 1_0_6_4, 2_2, 9_5_6, 1_3, 1_1_1_0_1, 1_4_2_9, 5_8_5_4, 2_4_3_1_3, 1_8_9_5_3, 4_0, 4_2_2, 2_4_3_6_6, 6_8, 1_7_5_8, 3_7, 1_0_4_8_3, 1_4_2_5_7, 3_1, 2_0_7, 2_6_3, 2_1, 2_0_3, 3_7_7_3, 2_5, 7_1, 9_7_3_5, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2, 2_0_4_9, 3_4_4_2, 1_7, 1_3_8_9_4, 3_3_8_0, 2_3, 9_5, 1_8, 1_7_6_3_4, 2_2_8_8, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case__ , model_name='xlnet-base-cased' , revision='c841166438c31ec7ca9a106dee7bb312b73ae511' , )
717
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
673
0
import unittest from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_tf, require_torch, require_vision, slow, ) from .test_pipelines_common import ANY if is_vision_available(): from PIL import Image else: class UpperCamelCase : @staticmethod def UpperCamelCase ( *snake_case__ : int , **snake_case__ : str ): """simple docstring""" pass @is_pipeline_test @require_vision @require_torch class UpperCamelCase ( unittest.TestCase ): __UpperCamelCase =MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING def UpperCamelCase ( self : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Any , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = pipeline( 'zero-shot-object-detection' , model='hf-internal-testing/tiny-random-owlvit-object-detection' ) SCREAMING_SNAKE_CASE = [ { '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''', '''candidate_labels''': ['''cat''', '''remote''', '''couch'''], } ] return object_detector, examples def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : str ): """simple docstring""" SCREAMING_SNAKE_CASE = object_detector(examples[0] , threshold=0.0 ) SCREAMING_SNAKE_CASE = len(lowerCamelCase__ ) self.assertGreater(lowerCamelCase__ , 0 ) self.assertEqual( lowerCamelCase__ , [ { 'score': ANY(lowerCamelCase__ ), 'label': ANY(lowerCamelCase__ ), 'box': {'xmin': ANY(lowerCamelCase__ ), 'ymin': ANY(lowerCamelCase__ ), 'xmax': ANY(lowerCamelCase__ ), 'ymax': ANY(lowerCamelCase__ )}, } for i in range(lowerCamelCase__ ) ] , ) @require_tf @unittest.skip('Zero Shot Object Detection not implemented in TF' ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" pass @require_torch def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = pipeline( 'zero-shot-object-detection' , model='hf-internal-testing/tiny-random-owlvit-object-detection' ) SCREAMING_SNAKE_CASE = object_detector( './tests/fixtures/tests_samples/COCO/000000039769.png' , candidate_labels=['cat', 'remote', 'couch'] , threshold=0.64 , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ {'score': 0.7_235, 'label': 'cat', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.7_218, 'label': 'remote', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.7_184, 'label': 'couch', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.6_748, 'label': 'remote', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_656, 'label': 'cat', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_614, 'label': 'couch', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_456, 'label': 'remote', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}}, {'score': 0.642, 'label': 'remote', 'box': {'xmin': 6_7, 'ymin': 2_7_4, 'xmax': 9_3, 'ymax': 2_9_7}}, {'score': 0.6_419, 'label': 'cat', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}}, ] , ) SCREAMING_SNAKE_CASE = object_detector( [ { 'image': './tests/fixtures/tests_samples/COCO/000000039769.png', 'candidate_labels': ['cat', 'remote', 'couch'], } ] , threshold=0.64 , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ [ {'score': 0.7_235, 'label': 'cat', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.7_218, 'label': 'remote', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.7_184, 'label': 'couch', 'box': {'xmin': 2_0_4, 'ymin': 1_6_7, 'xmax': 2_3_2, 'ymax': 1_9_0}}, {'score': 0.6_748, 'label': 'remote', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_656, 'label': 'cat', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_614, 'label': 'couch', 'box': {'xmin': 5_7_1, 'ymin': 8_3, 'xmax': 5_9_8, 'ymax': 1_0_3}}, {'score': 0.6_456, 'label': 'remote', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}}, {'score': 0.642, 'label': 'remote', 'box': {'xmin': 6_7, 'ymin': 2_7_4, 'xmax': 9_3, 'ymax': 2_9_7}}, {'score': 0.6_419, 'label': 'cat', 'box': {'xmin': 4_9_4, 'ymin': 1_0_5, 'xmax': 5_2_1, 'ymax': 1_2_7}}, ] ] , ) @require_torch @slow def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = pipeline('zero-shot-object-detection' ) SCREAMING_SNAKE_CASE = object_detector( 'http://images.cocodataset.org/val2017/000000039769.jpg' , candidate_labels=['cat', 'remote', 'couch'] , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}}, {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}}, {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}}, {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}}, {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}}, ] , ) SCREAMING_SNAKE_CASE = object_detector( [ { 'image': 'http://images.cocodataset.org/val2017/000000039769.jpg', 'candidate_labels': ['cat', 'remote', 'couch'], }, { 'image': 'http://images.cocodataset.org/val2017/000000039769.jpg', 'candidate_labels': ['cat', 'remote', 'couch'], }, ] , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ [ {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}}, {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}}, {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}}, {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}}, {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}}, ], [ {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}}, {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}}, {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}}, {'score': 0.1_474, 'label': 'remote', 'box': {'xmin': 3_3_5, 'ymin': 7_4, 'xmax': 3_7_1, 'ymax': 1_8_7}}, {'score': 0.1_208, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 6_4_2, 'ymax': 4_7_6}}, ], ] , ) @require_tf @unittest.skip('Zero Shot Object Detection not implemented in TF' ) def UpperCamelCase ( self : Tuple ): """simple docstring""" pass @require_torch @slow def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = 0.2 SCREAMING_SNAKE_CASE = pipeline('zero-shot-object-detection' ) SCREAMING_SNAKE_CASE = object_detector( 'http://images.cocodataset.org/val2017/000000039769.jpg' , candidate_labels=['cat', 'remote', 'couch'] , threshold=lowerCamelCase__ , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}}, {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}}, {'score': 0.2_537, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 5_5, 'xmax': 3_1_5, 'ymax': 4_7_2}}, ] , ) @require_torch @slow def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = pipeline('zero-shot-object-detection' ) SCREAMING_SNAKE_CASE = object_detector( 'http://images.cocodataset.org/val2017/000000039769.jpg' , candidate_labels=['cat', 'remote', 'couch'] , top_k=lowerCamelCase__ , ) self.assertEqual( nested_simplify(lowerCamelCase__ , decimals=4 ) , [ {'score': 0.2_868, 'label': 'cat', 'box': {'xmin': 3_2_4, 'ymin': 2_0, 'xmax': 6_4_0, 'ymax': 3_7_3}}, {'score': 0.277, 'label': 'remote', 'box': {'xmin': 4_0, 'ymin': 7_2, 'xmax': 1_7_7, 'ymax': 1_1_5}}, ] , )
718
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
673
0
import logging import random import ray from transformers import RagConfig, RagRetriever, RagTokenizer from transformers.models.rag.retrieval_rag import CustomHFIndex a_ : str = logging.getLogger(__name__) class UpperCamelCase : def __init__( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = False def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str ): """simple docstring""" if not self.initialized: SCREAMING_SNAKE_CASE = RagRetriever( snake_case__ , question_encoder_tokenizer=snake_case__ , generator_tokenizer=snake_case__ , index=snake_case__ , init_retrieval=snake_case__ , ) SCREAMING_SNAKE_CASE = True def UpperCamelCase ( self : Tuple ): """simple docstring""" self.retriever.index.init_index() def UpperCamelCase ( self : Tuple , snake_case__ : List[Any] , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.retriever._main_retrieve(snake_case__ , snake_case__ ) return doc_ids, retrieved_doc_embeds class UpperCamelCase ( UpperCamelCase_ ): def __init__( self : Optional[Any] , snake_case__ : int , snake_case__ : Tuple , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int=None ): """simple docstring""" if index is not None and index.is_initialized() and len(snake_case__ ) > 0: raise ValueError( 'When using Ray for distributed fine-tuning, ' 'you\'ll need to provide the paths instead, ' 'as the dataset and the index are loaded ' 'separately. More info in examples/rag/use_own_knowledge_dataset.py ' ) super().__init__( snake_case__ , question_encoder_tokenizer=snake_case__ , generator_tokenizer=snake_case__ , index=snake_case__ , init_retrieval=snake_case__ , ) SCREAMING_SNAKE_CASE = retrieval_workers if len(self.retrieval_workers ) > 0: ray.get( [ worker.create_rag_retriever.remote(snake_case__ , snake_case__ , snake_case__ , snake_case__ ) for worker in self.retrieval_workers ] ) def UpperCamelCase ( self : Tuple ): """simple docstring""" logger.info('initializing retrieval' ) if len(self.retrieval_workers ) > 0: ray.get([worker.init_retrieval.remote() for worker in self.retrieval_workers] ) else: # Non-distributed training. Load index into this same process. self.index.init_index() def UpperCamelCase ( self : Dict , snake_case__ : str , snake_case__ : int ): """simple docstring""" if len(self.retrieval_workers ) > 0: # Select a random retrieval actor. SCREAMING_SNAKE_CASE = self.retrieval_workers[random.randint(0 , len(self.retrieval_workers ) - 1 )] SCREAMING_SNAKE_CASE = ray.get(random_worker.retrieve.remote(snake_case__ , snake_case__ ) ) else: SCREAMING_SNAKE_CASE = self._main_retrieve(snake_case__ , snake_case__ ) return retrieved_doc_embeds, doc_ids, self.index.get_doc_dicts(snake_case__ ) @classmethod def UpperCamelCase ( cls : List[str] , snake_case__ : Optional[Any] , snake_case__ : List[Any]=None , **snake_case__ : int ): """simple docstring""" return super(snake_case__ , cls ).get_tokenizers(snake_case__ , snake_case__ , **snake_case__ ) @classmethod def UpperCamelCase ( cls : int , snake_case__ : str , snake_case__ : str , snake_case__ : Union[str, Any]=None , **snake_case__ : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.pop('config' , snake_case__ ) or RagConfig.from_pretrained(snake_case__ , **snake_case__ ) SCREAMING_SNAKE_CASE = RagTokenizer.from_pretrained(snake_case__ , config=snake_case__ ) SCREAMING_SNAKE_CASE = rag_tokenizer.question_encoder SCREAMING_SNAKE_CASE = rag_tokenizer.generator if indexed_dataset is not None: SCREAMING_SNAKE_CASE = '''custom''' SCREAMING_SNAKE_CASE = CustomHFIndex(config.retrieval_vector_size , snake_case__ ) else: SCREAMING_SNAKE_CASE = cls._build_index(snake_case__ ) return cls( snake_case__ , question_encoder_tokenizer=snake_case__ , generator_tokenizer=snake_case__ , retrieval_workers=snake_case__ , index=snake_case__ , )
719
import heapq import sys import numpy as np a_ : Optional[int] = tuple[int, int] class UpperCamelCase : def __init__( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() def UpperCamelCase ( self : List[Any] ): """simple docstring""" if not self.empty(): return self.elements[0][0] else: return float('inf' ) def UpperCamelCase ( self : List[str] ): """simple docstring""" return len(self.elements ) == 0 def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] ): """simple docstring""" if item not in self.set: heapq.heappush(self.elements , (priority, item) ) self.set.add(snake_case__ ) else: # update # print("update", item) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pri, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) temp.append((priority, item) ) for pro, xxx in temp: heapq.heappush(self.elements , (pro, xxx) ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" if item in self.set: self.set.remove(snake_case__ ) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pro, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) for prito, yyy in temp: heapq.heappush(self.elements , (prito, yyy) ) def UpperCamelCase ( self : str ): """simple docstring""" return self.elements[0][1] def UpperCamelCase ( self : Tuple ): """simple docstring""" ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) self.set.remove(snake_case__ ) return (priority, item) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) return np.linalg.norm(a - b ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Dict: '''simple docstring''' return consistent_heuristic(_UpperCamelCase , _UpperCamelCase ) // t def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[int]: '''simple docstring''' return abs(p[0] - goal[0] ) + abs(p[1] - goal[1] ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : int , _UpperCamelCase : TPos , _UpperCamelCase : dict[TPos, float] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = g_function[start] + Wa * heuristics[i](_UpperCamelCase , _UpperCamelCase ) return ans def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : int , _UpperCamelCase : Tuple ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = np.chararray((n, n) ) for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = '*' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): if (j, (n - 1) - i) in blocks: SCREAMING_SNAKE_CASE = '#' SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = x # print(x) SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[x] SCREAMING_SNAKE_CASE = '-' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): 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:-' ) SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: print(_UpperCamelCase , end=' ' ) SCREAMING_SNAKE_CASE = back_pointer[x] print(_UpperCamelCase ) sys.exit() def __lowerCAmelCase ( _UpperCamelCase : TPos ) -> Any: '''simple docstring''' 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 __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : Tuple , _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Optional[Any] , ) -> List[Any]: '''simple docstring''' for itera in range(_UpperCamelCase ): open_list[itera].remove_element(_UpperCamelCase ) # print("s", s) # print("j", j) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = s SCREAMING_SNAKE_CASE = (x - 1, y) SCREAMING_SNAKE_CASE = (x + 1, y) SCREAMING_SNAKE_CASE = (x, y + 1) SCREAMING_SNAKE_CASE = (x, y - 1) for neighbours in [left, right, up, down]: if neighbours not in blocks: if valid(_UpperCamelCase ) and neighbours not in visited: # print("neighbour", neighbours) visited.add(_UpperCamelCase ) SCREAMING_SNAKE_CASE = -1 SCREAMING_SNAKE_CASE = float('inf' ) if valid(_UpperCamelCase ) and g_function[neighbours] > g_function[s] + 1: SCREAMING_SNAKE_CASE = g_function[s] + 1 SCREAMING_SNAKE_CASE = s if neighbours not in close_list_anchor: open_list[0].put(_UpperCamelCase , key(_UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ) ) if neighbours not in close_list_inad: for var in range(1 , _UpperCamelCase ): if key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) <= Wa * key( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ): open_list[j].put( _UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = [] 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 a_ : str = {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a} a_ : List[str] = [ (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), ] a_ : Union[str, Any] = make_common_ground() a_ : Tuple = blocks_blk # hyper parameters a_ : Any = 1 a_ : List[str] = 1 a_ : Union[str, Any] = 20 a_ : Optional[Any] = 3 # one consistent and two other inconsistent # start and end destination a_ : int = (0, 0) a_ : Optional[int] = (n - 1, n - 1) a_ : Union[str, Any] = 1 def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos , _UpperCamelCase : int ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = {start: 0, goal: float('inf' )} SCREAMING_SNAKE_CASE = {start: -1, goal: -1} SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() for i in range(_UpperCamelCase ): open_list.append(PriorityQueue() ) open_list[i].put(_UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] while open_list[0].minkey() < float('inf' ): for i in range(1 , _UpperCamelCase ): # 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(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = open_list[i].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_inad.append(_UpperCamelCase ) else: if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float('inf' ): do_something(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE = open_list[0].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_anchor.append(_UpperCamelCase ) print('No path found to goal' ) print() for i in range(n - 1 , -1 , -1 ): for j in range(_UpperCamelCase ): 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)
673
0
import json import os from typing import Dict, List, Optional, Tuple import regex as re from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging a_ : Optional[int] = logging.get_logger(__name__) a_ : str = { """vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_config_file""": """tokenizer_config.json""", } a_ : Optional[Any] = { """vocab_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json""" }, """merges_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt""" }, """tokenizer_config_file""": { """facebook/blenderbot_small-90M""": ( """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json""" ) }, } a_ : Dict = {"""facebook/blenderbot_small-90M""": 512} def __lowerCAmelCase ( _UpperCamelCase : Dict ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = set() SCREAMING_SNAKE_CASE = word[0] for char in word[1:]: pairs.add((prev_char, char) ) SCREAMING_SNAKE_CASE = char SCREAMING_SNAKE_CASE = set(UpperCamelCase__ ) return pairs class UpperCamelCase ( lowercase_ ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =['''input_ids''', '''attention_mask'''] def __init__( self : Optional[Any] , snake_case__ : int , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any]="__start__" , snake_case__ : Optional[int]="__end__" , snake_case__ : List[Any]="__unk__" , snake_case__ : Union[str, Any]="__null__" , **snake_case__ : int , ): """simple docstring""" super().__init__(unk_token=snake_case__ , bos_token=snake_case__ , eos_token=snake_case__ , pad_token=snake_case__ , **snake_case__ ) with open(snake_case__ , encoding='utf-8' ) as vocab_handle: SCREAMING_SNAKE_CASE = json.load(snake_case__ ) SCREAMING_SNAKE_CASE = {v: k for k, v in self.encoder.items()} with open(snake_case__ , encoding='utf-8' ) as merges_handle: SCREAMING_SNAKE_CASE = merges_handle.read().split('\n' )[1:-1] SCREAMING_SNAKE_CASE = [tuple(merge.split() ) for merge in merges] SCREAMING_SNAKE_CASE = dict(zip(snake_case__ , range(len(snake_case__ ) ) ) ) SCREAMING_SNAKE_CASE = {} @property def UpperCamelCase ( self : Any ): """simple docstring""" return len(self.encoder ) def UpperCamelCase ( self : str ): """simple docstring""" return dict(self.encoder , **self.added_tokens_encoder ) def UpperCamelCase ( self : Optional[int] , snake_case__ : str ): """simple docstring""" if token in self.cache: return self.cache[token] SCREAMING_SNAKE_CASE = re.sub('([.,!?()])' , r' \1' , snake_case__ ) SCREAMING_SNAKE_CASE = re.sub('(\')' , r' \1 ' , snake_case__ ) SCREAMING_SNAKE_CASE = re.sub(r'\s{2,}' , ' ' , snake_case__ ) if "\n" in token: SCREAMING_SNAKE_CASE = token.replace('\n' , ' __newln__' ) SCREAMING_SNAKE_CASE = token.split(' ' ) SCREAMING_SNAKE_CASE = [] for token in tokens: if not len(snake_case__ ): continue SCREAMING_SNAKE_CASE = token.lower() SCREAMING_SNAKE_CASE = tuple(snake_case__ ) SCREAMING_SNAKE_CASE = tuple(list(word[:-1] ) + [word[-1] + '</w>'] ) SCREAMING_SNAKE_CASE = get_pairs(snake_case__ ) if not pairs: words.append(snake_case__ ) continue while True: SCREAMING_SNAKE_CASE = min(snake_case__ , key=lambda snake_case__ : self.bpe_ranks.get(snake_case__ , float('inf' ) ) ) if bigram not in self.bpe_ranks: break SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = bigram SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = 0 while i < len(snake_case__ ): try: SCREAMING_SNAKE_CASE = word.index(snake_case__ , snake_case__ ) new_word.extend(word[i:j] ) SCREAMING_SNAKE_CASE = j except ValueError: new_word.extend(word[i:] ) break if word[i] == first and i < len(snake_case__ ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 SCREAMING_SNAKE_CASE = tuple(snake_case__ ) SCREAMING_SNAKE_CASE = new_word if len(snake_case__ ) == 1: break else: SCREAMING_SNAKE_CASE = get_pairs(snake_case__ ) SCREAMING_SNAKE_CASE = '@@ '.join(snake_case__ ) SCREAMING_SNAKE_CASE = word[:-4] SCREAMING_SNAKE_CASE = word words.append(snake_case__ ) return " ".join(snake_case__ ) def UpperCamelCase ( self : List[str] , snake_case__ : str ): """simple docstring""" SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = re.findall(r'\S+\n?' , snake_case__ ) for token in words: split_tokens.extend(list(self.bpe(snake_case__ ).split(' ' ) ) ) return split_tokens def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = token.lower() return self.encoder.get(snake_case__ , self.encoder.get(self.unk_token ) ) def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.decoder.get(snake_case__ , self.unk_token ) def UpperCamelCase ( self : List[Any] , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ' '.join(snake_case__ ).replace('@@ ' , '' ).strip() return out_string def UpperCamelCase ( self : Any , snake_case__ : List[str] , snake_case__ : Optional[int] = None ): """simple docstring""" if not os.path.isdir(snake_case__ ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return SCREAMING_SNAKE_CASE = os.path.join( snake_case__ , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) SCREAMING_SNAKE_CASE = os.path.join( snake_case__ , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'] ) with open(snake_case__ , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=snake_case__ , ensure_ascii=snake_case__ ) + '\n' ) SCREAMING_SNAKE_CASE = 0 with open(snake_case__ , 'w' , encoding='utf-8' ) as writer: writer.write('#version: 0.2\n' ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda snake_case__ : kv[1] ): if index != token_index: logger.warning( F"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.""" ' Please check that the tokenizer is not corrupted!' ) SCREAMING_SNAKE_CASE = token_index writer.write(' '.join(snake_case__ ) + '\n' ) index += 1 return vocab_file, merge_file
720
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) a_ : Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name a_ : str = "\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to(\"cuda\")\n\n >>> prompt = \"A red cartoon frog, 4k\"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-decoder\", torch_dtype=torch.float16\n ... )\n >>> pipe.to(\"cuda\")\n\n >>> init_image = load_image(\n ... \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n ... \"/kandinsky/frog.png\"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save(\"red_frog.png\")\n ```\n" def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Any , _UpperCamelCase : Any=8 ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 SCREAMING_SNAKE_CASE = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : List[Any]=5_12 , _UpperCamelCase : Union[str, Any]=5_12 ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) SCREAMING_SNAKE_CASE = np.array(pil_image.convert('RGB' ) ) SCREAMING_SNAKE_CASE = arr.astype(np.floataa ) / 1_27.5 - 1 SCREAMING_SNAKE_CASE = np.transpose(_UpperCamelCase , [2, 0, 1] ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).unsqueeze(0 ) return image class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : int , snake_case__ : UNetaDConditionModel , snake_case__ : DDPMScheduler , snake_case__ : VQModel , ): """simple docstring""" super().__init__() self.register_modules( unet=snake_case__ , scheduler=snake_case__ , movq=snake_case__ , ) SCREAMING_SNAKE_CASE = 2 ** (len(self.movq.config.block_out_channels ) - 1) def UpperCamelCase ( self : Any , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = min(int(num_inference_steps * strength ) , snake_case__ ) SCREAMING_SNAKE_CASE = max(num_inference_steps - init_timestep , 0 ) SCREAMING_SNAKE_CASE = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self : List[str] , snake_case__ : Dict , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : str=None ): """simple docstring""" if not isinstance(snake_case__ , (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(snake_case__ )}""" ) SCREAMING_SNAKE_CASE = image.to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = batch_size * num_images_per_prompt if image.shape[1] == 4: SCREAMING_SNAKE_CASE = image else: if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) != batch_size: raise ValueError( F"""You have passed a list of generators of length {len(snake_case__ )}, but requested an effective batch""" F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) elif isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(snake_case__ ) ] SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) else: SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ ).latent_dist.sample(snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.config.scaling_factor * init_latents SCREAMING_SNAKE_CASE = torch.cat([init_latents] , dim=0 ) SCREAMING_SNAKE_CASE = init_latents.shape SCREAMING_SNAKE_CASE = randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ , dtype=snake_case__ ) # get latents SCREAMING_SNAKE_CASE = self.scheduler.add_noise(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = init_latents return latents def UpperCamelCase ( self : int , snake_case__ : List[str]=0 ): """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) SCREAMING_SNAKE_CASE = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int]=0 ): """simple docstring""" if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=snake_case__ ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) SCREAMING_SNAKE_CASE = None for cpu_offloaded_model in [self.unet, self.movq]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cpu_offload_with_hook(snake_case__ , snake_case__ , prev_module_hook=snake_case__ ) # We'll offload the last model manually. SCREAMING_SNAKE_CASE = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self : Dict ): """simple docstring""" if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(snake_case__ , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(snake_case__ ) def __call__( self : str , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]] , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_1_2 , snake_case__ : int = 1_0_0 , snake_case__ : float = 4.0 , snake_case__ : float = 0.3 , snake_case__ : int = 1 , snake_case__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , ): """simple docstring""" SCREAMING_SNAKE_CASE = self._execution_device SCREAMING_SNAKE_CASE = guidance_scale > 1.0 if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = image_embeds.shape[0] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) if do_classifier_free_guidance: SCREAMING_SNAKE_CASE = image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = negative_image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=snake_case__ ) if not isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [image] if not all(isinstance(snake_case__ , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( F"""Input is in incorrect format: {[type(snake_case__ ) for i in image]}. Currently, we only support PIL image and pytorch tensor""" ) SCREAMING_SNAKE_CASE = torch.cat([prepare_image(snake_case__ , snake_case__ , snake_case__ ) for i in image] , dim=0 ) SCREAMING_SNAKE_CASE = image.to(dtype=image_embeds.dtype , device=snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ )['latents'] SCREAMING_SNAKE_CASE = latents.repeat_interleave(snake_case__ , dim=0 ) self.scheduler.set_timesteps(snake_case__ , device=snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_timesteps(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = timesteps[:1].repeat(batch_size * num_images_per_prompt ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = downscale_height_and_width(snake_case__ , snake_case__ , self.movq_scale_factor ) SCREAMING_SNAKE_CASE = self.prepare_latents( snake_case__ , snake_case__ , snake_case__ , snake_case__ , image_embeds.dtype , snake_case__ , snake_case__ ) for i, t in enumerate(self.progress_bar(snake_case__ ) ): # expand the latents if we are doing classifier free guidance SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents SCREAMING_SNAKE_CASE = {'image_embeds': image_embeds} SCREAMING_SNAKE_CASE = self.unet( sample=snake_case__ , timestep=snake_case__ , encoder_hidden_states=snake_case__ , added_cond_kwargs=snake_case__ , return_dict=snake_case__ , )[0] if do_classifier_free_guidance: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.chunk(2 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = variance_pred.chunk(2 ) SCREAMING_SNAKE_CASE = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) SCREAMING_SNAKE_CASE = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 SCREAMING_SNAKE_CASE = self.scheduler.step( snake_case__ , snake_case__ , snake_case__ , generator=snake_case__ , )[0] # post-processing SCREAMING_SNAKE_CASE = self.movq.decode(snake_case__ , force_not_quantize=snake_case__ )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}""" ) if output_type in ["np", "pil"]: SCREAMING_SNAKE_CASE = image * 0.5 + 0.5 SCREAMING_SNAKE_CASE = image.clamp(0 , 1 ) SCREAMING_SNAKE_CASE = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": SCREAMING_SNAKE_CASE = self.numpy_to_pil(snake_case__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case__ )
673
0
import json import pathlib import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import DeformableDetrImageProcessor class UpperCamelCase ( unittest.TestCase ): def __init__( self : Union[str, Any] , snake_case__ : Dict , snake_case__ : Tuple=7 , snake_case__ : Optional[Any]=3 , snake_case__ : List[str]=3_0 , snake_case__ : List[str]=4_0_0 , snake_case__ : List[str]=True , snake_case__ : Any=None , snake_case__ : List[Any]=True , snake_case__ : Any=[0.5, 0.5, 0.5] , snake_case__ : int=[0.5, 0.5, 0.5] , snake_case__ : Dict=True , snake_case__ : Optional[Any]=1 / 2_5_5 , snake_case__ : Optional[int]=True , ): """simple docstring""" SCREAMING_SNAKE_CASE = size if size is not None else {'shortest_edge': 1_8, 'longest_edge': 1_3_3_3} SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = min_resolution SCREAMING_SNAKE_CASE = max_resolution SCREAMING_SNAKE_CASE = do_resize SCREAMING_SNAKE_CASE = size SCREAMING_SNAKE_CASE = do_normalize SCREAMING_SNAKE_CASE = image_mean SCREAMING_SNAKE_CASE = image_std SCREAMING_SNAKE_CASE = do_rescale SCREAMING_SNAKE_CASE = rescale_factor SCREAMING_SNAKE_CASE = do_pad def UpperCamelCase ( self : str ): """simple docstring""" return { "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, "image_mean": self.image_mean, "image_std": self.image_std, "do_rescale": self.do_rescale, "rescale_factor": self.rescale_factor, "do_pad": self.do_pad, } def UpperCamelCase ( self : List[str] , snake_case__ : Tuple , snake_case__ : Optional[Any]=False ): """simple docstring""" if not batched: SCREAMING_SNAKE_CASE = image_inputs[0] if isinstance(snake_case__ , Image.Image ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = image.size else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = image.shape[1], image.shape[2] if w < h: SCREAMING_SNAKE_CASE = int(self.size['shortest_edge'] * h / w ) SCREAMING_SNAKE_CASE = self.size['shortest_edge'] elif w > h: SCREAMING_SNAKE_CASE = self.size['shortest_edge'] SCREAMING_SNAKE_CASE = int(self.size['shortest_edge'] * w / h ) else: SCREAMING_SNAKE_CASE = self.size['shortest_edge'] SCREAMING_SNAKE_CASE = self.size['shortest_edge'] else: SCREAMING_SNAKE_CASE = [] for image in image_inputs: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) SCREAMING_SNAKE_CASE = max(snake_case__ , key=lambda snake_case__ : item[0] )[0] SCREAMING_SNAKE_CASE = max(snake_case__ , key=lambda snake_case__ : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =DeformableDetrImageProcessor if is_vision_available() else None def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = DeformableDetrImageProcessingTester(self ) @property def UpperCamelCase ( self : str ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case__ , 'image_mean' ) ) self.assertTrue(hasattr(snake_case__ , 'image_std' ) ) self.assertTrue(hasattr(snake_case__ , 'do_normalize' ) ) self.assertTrue(hasattr(snake_case__ , 'do_resize' ) ) self.assertTrue(hasattr(snake_case__ , 'do_rescale' ) ) self.assertTrue(hasattr(snake_case__ , 'do_pad' ) ) self.assertTrue(hasattr(snake_case__ , 'size' ) ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {'shortest_edge': 1_8, 'longest_edge': 1_3_3_3} ) self.assertEqual(image_processor.do_pad , snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processing_class.from_dict( self.image_processor_dict , size=4_2 , max_size=8_4 , pad_and_return_pixel_mask=snake_case__ ) self.assertEqual(image_processor.size , {'shortest_edge': 4_2, 'longest_edge': 8_4} ) self.assertEqual(image_processor.do_pad , snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" pass def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random PIL images SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , Image.Image ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ , numpify=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , np.ndarray ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ , torchify=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , torch.Tensor ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) @slow def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) with open('./tests/fixtures/tests_samples/COCO/coco_annotations.txt' , 'r' ) as f: SCREAMING_SNAKE_CASE = json.loads(f.read() ) SCREAMING_SNAKE_CASE = {'image_id': 3_9_7_6_9, 'annotations': target} # encode them SCREAMING_SNAKE_CASE = DeformableDetrImageProcessor() SCREAMING_SNAKE_CASE = image_processing(images=snake_case__ , annotations=snake_case__ , return_tensors='pt' ) # verify pixel values SCREAMING_SNAKE_CASE = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['pixel_values'].shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] , snake_case__ , atol=1E-4 ) ) # verify area SCREAMING_SNAKE_CASE = torch.tensor([5_887.9_600, 11_250.2_061, 489_353.8_438, 837_122.7_500, 147_967.5_156, 165_732.3_438] ) self.assertTrue(torch.allclose(encoding['labels'][0]['area'] , snake_case__ ) ) # verify boxes SCREAMING_SNAKE_CASE = torch.Size([6, 4] ) self.assertEqual(encoding['labels'][0]['boxes'].shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([0.5_503, 0.2_765, 0.0_604, 0.2_215] ) self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] , snake_case__ , atol=1E-3 ) ) # verify image_id SCREAMING_SNAKE_CASE = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] , snake_case__ ) ) # verify is_crowd SCREAMING_SNAKE_CASE = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] , snake_case__ ) ) # verify class_labels SCREAMING_SNAKE_CASE = torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7] ) self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] , snake_case__ ) ) # verify orig_size SCREAMING_SNAKE_CASE = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] , snake_case__ ) ) # verify size SCREAMING_SNAKE_CASE = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['labels'][0]['size'] , snake_case__ ) ) @slow def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) with open('./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt' , 'r' ) as f: SCREAMING_SNAKE_CASE = json.loads(f.read() ) SCREAMING_SNAKE_CASE = {'file_name': '000000039769.png', 'image_id': 3_9_7_6_9, 'segments_info': target} SCREAMING_SNAKE_CASE = pathlib.Path('./tests/fixtures/tests_samples/COCO/coco_panoptic' ) # encode them SCREAMING_SNAKE_CASE = DeformableDetrImageProcessor(format='coco_panoptic' ) SCREAMING_SNAKE_CASE = image_processing(images=snake_case__ , annotations=snake_case__ , masks_path=snake_case__ , return_tensors='pt' ) # verify pixel values SCREAMING_SNAKE_CASE = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['pixel_values'].shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding['pixel_values'][0, 0, 0, :3] , snake_case__ , atol=1E-4 ) ) # verify area SCREAMING_SNAKE_CASE = torch.tensor([147_979.6_875, 165_527.0_469, 484_638.5_938, 11_292.9_375, 5_879.6_562, 7_634.1_147] ) self.assertTrue(torch.allclose(encoding['labels'][0]['area'] , snake_case__ ) ) # verify boxes SCREAMING_SNAKE_CASE = torch.Size([6, 4] ) self.assertEqual(encoding['labels'][0]['boxes'].shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([0.2_625, 0.5_437, 0.4_688, 0.8_625] ) self.assertTrue(torch.allclose(encoding['labels'][0]['boxes'][0] , snake_case__ , atol=1E-3 ) ) # verify image_id SCREAMING_SNAKE_CASE = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['labels'][0]['image_id'] , snake_case__ ) ) # verify is_crowd SCREAMING_SNAKE_CASE = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['labels'][0]['iscrowd'] , snake_case__ ) ) # verify class_labels SCREAMING_SNAKE_CASE = torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3] ) self.assertTrue(torch.allclose(encoding['labels'][0]['class_labels'] , snake_case__ ) ) # verify masks SCREAMING_SNAKE_CASE = 8_2_2_8_7_3 self.assertEqual(encoding['labels'][0]['masks'].sum().item() , snake_case__ ) # verify orig_size SCREAMING_SNAKE_CASE = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['labels'][0]['orig_size'] , snake_case__ ) ) # verify size SCREAMING_SNAKE_CASE = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['labels'][0]['size'] , snake_case__ ) )
721
import argparse import numpy as np import torch from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging logging.set_verbosity_info() a_ : List[Any] = logging.get_logger("transformers.models.speecht5") def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Tuple , _UpperCamelCase : Any ) -> Dict: '''simple docstring''' hf_model.apply_weight_norm() SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.bias'] for i in range(len(config.upsample_rates ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.bias"""] for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ): for j in range(len(config.resblock_dilation_sizes ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.bias'] hf_model.remove_weight_norm() @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : Dict , _UpperCamelCase : Tuple , _UpperCamelCase : Any=None , _UpperCamelCase : List[str]=None , ) -> Tuple: '''simple docstring''' if config_path is not None: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig.from_pretrained(_UpperCamelCase ) else: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig() SCREAMING_SNAKE_CASE = SpeechTaHifiGan(_UpperCamelCase ) SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase ) load_weights(orig_checkpoint['model']['generator'] , _UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = np.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = stats[0].reshape(-1 ) SCREAMING_SNAKE_CASE = stats[1].reshape(-1 ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() model.save_pretrained(_UpperCamelCase ) if repo_id: print('Pushing to the hub...' ) model.push_to_hub(_UpperCamelCase ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint") parser.add_argument("--stats_path", required=True, default=None, type=str, help="Path to stats.npy file") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model." ) parser.add_argument( "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub." ) a_ : Tuple = parser.parse_args() convert_hifigan_checkpoint( args.checkpoint_path, args.stats_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )
673
0
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
700
import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer a_ : Optional[int] = logging.get_logger(__name__) a_ : Union[str, Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json", }, "merges_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt", }, "tokenizer_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json", }, } a_ : List[Any] = { "allenai/led-base-16384": 1_6384, } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =LEDTokenizer __UpperCamelCase =["input_ids", "attention_mask"] def __init__( self : Tuple , snake_case__ : List[Any]=None , snake_case__ : List[str]=None , snake_case__ : List[str]=None , snake_case__ : Dict="replace" , snake_case__ : Tuple="<s>" , snake_case__ : Optional[Any]="</s>" , snake_case__ : int="</s>" , snake_case__ : Dict="<s>" , snake_case__ : Union[str, Any]="<unk>" , snake_case__ : Optional[int]="<pad>" , snake_case__ : List[str]="<mask>" , snake_case__ : List[Any]=False , snake_case__ : int=True , **snake_case__ : Dict , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , errors=snake_case__ , bos_token=snake_case__ , eos_token=snake_case__ , sep_token=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , add_prefix_space=snake_case__ , trim_offsets=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = getattr(snake_case__ , pre_tok_state.pop('type' ) ) SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = pre_tok_class(**snake_case__ ) SCREAMING_SNAKE_CASE = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` SCREAMING_SNAKE_CASE = 'post_processor' SCREAMING_SNAKE_CASE = getattr(self.backend_tokenizer , snake_case__ , snake_case__ ) if tokenizer_component_instance: SCREAMING_SNAKE_CASE = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: SCREAMING_SNAKE_CASE = tuple(state['sep'] ) if "cls" in state: SCREAMING_SNAKE_CASE = tuple(state['cls'] ) SCREAMING_SNAKE_CASE = False if state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = True if state.get('trim_offsets' , snake_case__ ) != trim_offsets: SCREAMING_SNAKE_CASE = trim_offsets SCREAMING_SNAKE_CASE = True if changes_to_apply: SCREAMING_SNAKE_CASE = getattr(snake_case__ , state.pop('type' ) ) SCREAMING_SNAKE_CASE = component_class(**snake_case__ ) setattr(self.backend_tokenizer , snake_case__ , snake_case__ ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" if self._mask_token is None: if self.verbose: logger.error('Using mask_token, but it is not set yet.' ) return None return str(self._mask_token ) @mask_token.setter def UpperCamelCase ( self : List[Any] , snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else value SCREAMING_SNAKE_CASE = value def UpperCamelCase ( self : Dict , *snake_case__ : Optional[Any] , **snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._batch_encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : List[str] , *snake_case__ : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : Tuple=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def UpperCamelCase ( self : Optional[int] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def UpperCamelCase ( self : Optional[Any] , snake_case__ : Union[Dict[str, EncodedInput], BatchEncoding] , snake_case__ : Optional[int] = None , snake_case__ : PaddingStrategy = PaddingStrategy.DO_NOT_PAD , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super()._pad( encoded_inputs=snake_case__ , max_length=snake_case__ , padding_strategy=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , ) # Load from model defaults if return_attention_mask is None: SCREAMING_SNAKE_CASE = 'attention_mask' in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: SCREAMING_SNAKE_CASE = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. SCREAMING_SNAKE_CASE = len(encoded_inputs['global_attention_mask'] ) != len(snake_case__ ) if needs_to_be_padded: SCREAMING_SNAKE_CASE = len(snake_case__ ) - len(encoded_inputs['global_attention_mask'] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` SCREAMING_SNAKE_CASE = ( encoded_inputs['global_attention_mask'] + [-1] * difference ) elif self.padding_side == "left": SCREAMING_SNAKE_CASE = [-1] * difference + encoded_inputs[ 'global_attention_mask' ] else: raise ValueError('Invalid padding strategy:' + str(self.padding_side ) ) return encoded_inputs
673
0
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a_ : Dict = { "configuration_luke": ["LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP", "LukeConfig"], "tokenization_luke": ["LukeTokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Tuple = [ "LUKE_PRETRAINED_MODEL_ARCHIVE_LIST", "LukeForEntityClassification", "LukeForEntityPairClassification", "LukeForEntitySpanClassification", "LukeForMultipleChoice", "LukeForQuestionAnswering", "LukeForSequenceClassification", "LukeForTokenClassification", "LukeForMaskedLM", "LukeModel", "LukePreTrainedModel", ] if TYPE_CHECKING: from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig from .tokenization_luke import LukeTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_luke import ( LUKE_PRETRAINED_MODEL_ARCHIVE_LIST, LukeForEntityClassification, LukeForEntityPairClassification, LukeForEntitySpanClassification, LukeForMaskedLM, LukeForMultipleChoice, LukeForQuestionAnswering, LukeForSequenceClassification, LukeForTokenClassification, LukeModel, LukePreTrainedModel, ) else: import sys a_ : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
701
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def __lowerCAmelCase ( *_UpperCamelCase : Optional[Any] ) -> Optional[int]: '''simple docstring''' with open(_UpperCamelCase , 'r' ) as fh: fcntl.flock(_UpperCamelCase , fcntl.LOCK_EX ) try: print(*_UpperCamelCase ) finally: fcntl.flock(_UpperCamelCase , fcntl.LOCK_UN ) a_ : int = int(os.environ["LOCAL_RANK"]) torch.cuda.set_device(local_rank) a_ : str = torch.device("cuda", local_rank) a_ : Optional[int] = socket.gethostname() a_ : Union[str, Any] = F"""[{hostname}-{local_rank}]""" try: # test distributed dist.init_process_group("nccl") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank a_ : Dict = dist.get_rank() a_ : Any = dist.get_world_size() printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""") dist.barrier() if rank == 0: printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""") except Exception: printflock(F"""{gpu} is broken""") raise
673
0
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
702
from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_herbert import HerbertTokenizer a_ : Optional[Any] = logging.get_logger(__name__) a_ : Optional[Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json" }, "merges_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt" }, } a_ : Union[str, Any] = {"allegro/herbert-base-cased": 514} a_ : List[Any] = {} class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_INIT_CONFIGURATION __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =HerbertTokenizer def __init__( self : Tuple , snake_case__ : Optional[Any]=None , snake_case__ : int=None , snake_case__ : Optional[int]=None , snake_case__ : str="<s>" , snake_case__ : Tuple="<unk>" , snake_case__ : List[str]="<pad>" , snake_case__ : Tuple="<mask>" , snake_case__ : Dict="</s>" , **snake_case__ : List[str] , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , sep_token=snake_case__ , **snake_case__ , ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.cls_token_id] SCREAMING_SNAKE_CASE = [self.sep_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 UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ): """simple docstring""" if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ ) if token_ids_a is None: return [1] + ([0] * len(snake_case__ )) + [1] return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1] def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def UpperCamelCase ( self : Tuple , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ )
673
0
import argparse import datetime def __lowerCAmelCase ( _UpperCamelCase : str ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = { '0': 'Sunday', '1': 'Monday', '2': 'Tuesday', '3': 'Wednesday', '4': 'Thursday', '5': 'Friday', '6': 'Saturday', } SCREAMING_SNAKE_CASE = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0} # Validate if not 0 < len(_UpperCamelCase ) < 11: raise ValueError('Must be 10 characters long' ) # Get month SCREAMING_SNAKE_CASE = int(date_input[0] + date_input[1] ) # Validate if not 0 < m < 13: raise ValueError('Month must be between 1 - 12' ) SCREAMING_SNAKE_CASE = date_input[2] # Validate if sep_a not in ["-", "/"]: raise ValueError('Date separator must be \'-\' or \'/\'' ) # Get day SCREAMING_SNAKE_CASE = int(date_input[3] + date_input[4] ) # Validate if not 0 < d < 32: raise ValueError('Date must be between 1 - 31' ) # Get second separator SCREAMING_SNAKE_CASE = date_input[5] # Validate if sep_a not in ["-", "/"]: raise ValueError('Date separator must be \'-\' or \'/\'' ) # Get year SCREAMING_SNAKE_CASE = int(date_input[6] + date_input[7] + date_input[8] + date_input[9] ) # Arbitrary year range if not 45 < y < 85_00: raise ValueError( 'Year out of range. There has to be some sort of limit...right?' ) # Get datetime obj for validation SCREAMING_SNAKE_CASE = datetime.date(int(_UpperCamelCase ) , int(_UpperCamelCase ) , int(_UpperCamelCase ) ) # Start math if m <= 2: SCREAMING_SNAKE_CASE = y - 1 SCREAMING_SNAKE_CASE = m + 12 # maths var SCREAMING_SNAKE_CASE = int(str(_UpperCamelCase )[:2] ) SCREAMING_SNAKE_CASE = int(str(_UpperCamelCase )[2:] ) SCREAMING_SNAKE_CASE = int(2.6 * m - 5.39 ) SCREAMING_SNAKE_CASE = int(c / 4 ) SCREAMING_SNAKE_CASE = int(k / 4 ) SCREAMING_SNAKE_CASE = int(d + k ) SCREAMING_SNAKE_CASE = int(t + u + v + x ) SCREAMING_SNAKE_CASE = int(z - (2 * c) ) SCREAMING_SNAKE_CASE = round(w % 7 ) # End math # Validate math if f != convert_datetime_days[dt_ck.weekday()]: raise AssertionError('The date was evaluated incorrectly. Contact developer.' ) # Response SCREAMING_SNAKE_CASE = f"""Your date {date_input}, is a {days[str(_UpperCamelCase )]}!""" return response if __name__ == "__main__": import doctest doctest.testmod() a_ : Any = argparse.ArgumentParser( description=( "Find out what day of the week nearly any date is or was. Enter " "date as a string in the mm-dd-yyyy or mm/dd/yyyy format" ) ) parser.add_argument( "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)" ) a_ : Optional[Any] = parser.parse_args() zeller(args.date_input)
703
def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 while n > 0: res += n % 10 n //= 10 return res def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) return n if n < 10 else n % 10 + sum_of_digits(n // 10 ) def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' return sum(int(_UpperCamelCase ) for c in str(abs(_UpperCamelCase ) ) ) def __lowerCAmelCase ( ) -> None: '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(_UpperCamelCase : Callable , _UpperCamelCase : int ) -> None: SCREAMING_SNAKE_CASE = f"""{func.__name__}({value})""" SCREAMING_SNAKE_CASE = timeit(f"""__main__.{call}""" , setup='import __main__' ) print(f"""{call:56} = {func(_UpperCamelCase )} -- {timing:.4f} seconds""" ) for value in (26_21_44, 11_25_89_99_06_84_26_24, 1_26_76_50_60_02_28_22_94_01_49_67_03_20_53_76): for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact): benchmark_a_function(_UpperCamelCase , _UpperCamelCase ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
673
0
import glob import os import random from string import ascii_lowercase, digits import cva import numpy as np # Parrameters a_ : Dict = (720, 1280) # Height, Width a_ : Tuple = (0.4, 0.6) # if height or width lower than this scale, drop it. a_ : str = 1 / 100 a_ : Dict = "" a_ : Optional[int] = "" a_ : int = "" a_ : Any = 250 def __lowerCAmelCase ( ) -> None: '''simple docstring''' SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = get_dataset(_UpperCamelCase , _UpperCamelCase ) for index in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = random.sample(range(len(_UpperCamelCase ) ) , 4 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = update_image_and_anno( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , filter_scale=_UpperCamelCase , ) # Get random string code: '7b7ad245cdff75241935e4dd860f3bad' SCREAMING_SNAKE_CASE = random_chars(32 ) SCREAMING_SNAKE_CASE = path.split(os.sep )[-1].rsplit('.' , 1 )[0] SCREAMING_SNAKE_CASE = f"""{OUTPUT_DIR}/{file_name}_MOSAIC_{letter_code}""" cva.imwrite(f"""{file_root}.jpg""" , _UpperCamelCase , [cva.IMWRITE_JPEG_QUALITY, 85] ) print(f"""Succeeded {index+1}/{NUMBER_IMAGES} with {file_name}""" ) SCREAMING_SNAKE_CASE = [] for anno in new_annos: SCREAMING_SNAKE_CASE = anno[3] - anno[1] SCREAMING_SNAKE_CASE = anno[4] - anno[2] SCREAMING_SNAKE_CASE = anno[1] + width / 2 SCREAMING_SNAKE_CASE = anno[2] + height / 2 SCREAMING_SNAKE_CASE = f"""{anno[0]} {x_center} {y_center} {width} {height}""" annos_list.append(_UpperCamelCase ) with open(f"""{file_root}.txt""" , 'w' ) as outfile: outfile.write('\n'.join(line for line in annos_list ) ) def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : str ) -> tuple[list, list]: '''simple docstring''' SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] for label_file in glob.glob(os.path.join(_UpperCamelCase , '*.txt' ) ): SCREAMING_SNAKE_CASE = label_file.split(os.sep )[-1].rsplit('.' , 1 )[0] with open(_UpperCamelCase ) as in_file: SCREAMING_SNAKE_CASE = in_file.readlines() SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""{label_name}.jpg""" ) SCREAMING_SNAKE_CASE = [] for obj_list in obj_lists: SCREAMING_SNAKE_CASE = obj_list.rstrip('\n' ).split(' ' ) SCREAMING_SNAKE_CASE = float(obj[1] ) - float(obj[3] ) / 2 SCREAMING_SNAKE_CASE = float(obj[2] ) - float(obj[4] ) / 2 SCREAMING_SNAKE_CASE = float(obj[1] ) + float(obj[3] ) / 2 SCREAMING_SNAKE_CASE = float(obj[2] ) + float(obj[4] ) / 2 boxes.append([int(obj[0] ), xmin, ymin, xmax, ymax] ) if not boxes: continue img_paths.append(_UpperCamelCase ) labels.append(_UpperCamelCase ) return img_paths, labels def __lowerCAmelCase ( _UpperCamelCase : list , _UpperCamelCase : list , _UpperCamelCase : list[int] , _UpperCamelCase : tuple[int, int] , _UpperCamelCase : tuple[float, float] , _UpperCamelCase : float = 0.0 , ) -> tuple[list, list, str]: '''simple docstring''' SCREAMING_SNAKE_CASE = np.zeros([output_size[0], output_size[1], 3] , dtype=np.uinta ) SCREAMING_SNAKE_CASE = scale_range[0] + random.random() * (scale_range[1] - scale_range[0]) SCREAMING_SNAKE_CASE = scale_range[0] + random.random() * (scale_range[1] - scale_range[0]) SCREAMING_SNAKE_CASE = int(scale_x * output_size[1] ) SCREAMING_SNAKE_CASE = int(scale_y * output_size[0] ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] for i, index in enumerate(_UpperCamelCase ): SCREAMING_SNAKE_CASE = all_img_list[index] path_list.append(_UpperCamelCase ) SCREAMING_SNAKE_CASE = all_annos[index] SCREAMING_SNAKE_CASE = cva.imread(_UpperCamelCase ) if i == 0: # top-left SCREAMING_SNAKE_CASE = cva.resize(_UpperCamelCase , (divid_point_x, divid_point_y) ) SCREAMING_SNAKE_CASE = img for bbox in img_annos: SCREAMING_SNAKE_CASE = bbox[1] * scale_x SCREAMING_SNAKE_CASE = bbox[2] * scale_y SCREAMING_SNAKE_CASE = bbox[3] * scale_x SCREAMING_SNAKE_CASE = bbox[4] * scale_y new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) elif i == 1: # top-right SCREAMING_SNAKE_CASE = cva.resize(_UpperCamelCase , (output_size[1] - divid_point_x, divid_point_y) ) SCREAMING_SNAKE_CASE = img for bbox in img_annos: SCREAMING_SNAKE_CASE = scale_x + bbox[1] * (1 - scale_x) SCREAMING_SNAKE_CASE = bbox[2] * scale_y SCREAMING_SNAKE_CASE = scale_x + bbox[3] * (1 - scale_x) SCREAMING_SNAKE_CASE = bbox[4] * scale_y new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) elif i == 2: # bottom-left SCREAMING_SNAKE_CASE = cva.resize(_UpperCamelCase , (divid_point_x, output_size[0] - divid_point_y) ) SCREAMING_SNAKE_CASE = img for bbox in img_annos: SCREAMING_SNAKE_CASE = bbox[1] * scale_x SCREAMING_SNAKE_CASE = scale_y + bbox[2] * (1 - scale_y) SCREAMING_SNAKE_CASE = bbox[3] * scale_x SCREAMING_SNAKE_CASE = scale_y + bbox[4] * (1 - scale_y) new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) else: # bottom-right SCREAMING_SNAKE_CASE = cva.resize( _UpperCamelCase , (output_size[1] - divid_point_x, output_size[0] - divid_point_y) ) SCREAMING_SNAKE_CASE = img for bbox in img_annos: SCREAMING_SNAKE_CASE = scale_x + bbox[1] * (1 - scale_x) SCREAMING_SNAKE_CASE = scale_y + bbox[2] * (1 - scale_y) SCREAMING_SNAKE_CASE = scale_x + bbox[3] * (1 - scale_x) SCREAMING_SNAKE_CASE = scale_y + bbox[4] * (1 - scale_y) new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) # Remove bounding box small than scale of filter if filter_scale > 0: SCREAMING_SNAKE_CASE = [ anno for anno in new_anno if filter_scale < (anno[3] - anno[1]) and filter_scale < (anno[4] - anno[2]) ] return output_img, new_anno, path_list[0] def __lowerCAmelCase ( _UpperCamelCase : int ) -> str: '''simple docstring''' assert number_char > 1, "The number of character should greater than 1" SCREAMING_SNAKE_CASE = ascii_lowercase + digits return "".join(random.choice(_UpperCamelCase ) for _ in range(_UpperCamelCase ) ) if __name__ == "__main__": main() print("DONE ✅")
704
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
673
0
import math class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Optional[int]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" SCREAMING_SNAKE_CASE = n SCREAMING_SNAKE_CASE = [ [math.inf for j in range(0 , snake_case__ )] for i in range(0 , snake_case__ ) ] # adjacency matrix for weight SCREAMING_SNAKE_CASE = [ [math.inf for j in range(0 , snake_case__ )] for i in range(0 , snake_case__ ) ] # dp[i][j] stores minimum distance from i to j def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = w def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): SCREAMING_SNAKE_CASE = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : Optional[int] ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": a_ : Tuple = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
705
import gc import unittest import numpy as np import torch import torch.nn.functional as F from transformers import ( ClapTextConfig, ClapTextModelWithProjection, RobertaTokenizer, SpeechTaHifiGan, SpeechTaHifiGanConfig, ) from diffusers import ( AudioLDMPipeline, AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.utils import is_xformers_available, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =AudioLDMPipeline __UpperCamelCase =TEXT_TO_AUDIO_PARAMS __UpperCamelCase =TEXT_TO_AUDIO_BATCH_PARAMS __UpperCamelCase =frozenset( [ "num_inference_steps", "num_waveforms_per_prompt", "generator", "latents", "output_type", "return_dict", "callback", "callback_steps", ] ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=(3_2, 6_4) , class_embed_type='simple_projection' , projection_class_embeddings_input_dim=3_2 , class_embeddings_concat=snake_case__ , ) SCREAMING_SNAKE_CASE = DDIMScheduler( beta_start=0.00_085 , beta_end=0.012 , beta_schedule='scaled_linear' , clip_sample=snake_case__ , set_alpha_to_one=snake_case__ , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=1 , out_channels=1 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = ClapTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , projection_dim=3_2 , ) SCREAMING_SNAKE_CASE = ClapTextModelWithProjection(snake_case__ ) SCREAMING_SNAKE_CASE = RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta' , model_max_length=7_7 ) SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig( model_in_dim=8 , sampling_rate=1_6_0_0_0 , upsample_initial_channel=1_6 , upsample_rates=[2, 2] , upsample_kernel_sizes=[4, 4] , resblock_kernel_sizes=[3, 7] , resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]] , normalize_before=snake_case__ , ) SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ) SCREAMING_SNAKE_CASE = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'vocoder': vocoder, } return components def UpperCamelCase ( self : Optional[int] , snake_case__ : int , snake_case__ : int=0 ): """simple docstring""" if str(snake_case__ ).startswith('mps' ): SCREAMING_SNAKE_CASE = torch.manual_seed(snake_case__ ) else: SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, } return inputs def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = prompt_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) SCREAMING_SNAKE_CASE = prompt_embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * ['this is a negative prompt'] SCREAMING_SNAKE_CASE = negative_prompt SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = [] for p in [prompt, negative_prompt]: SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = text_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) embeds.append(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 'egg cracking' SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ , negative_prompt=snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A hammer hitting a wooden surface' # test num_waveforms_per_prompt=1 (default) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 ).audios assert audios.shape == (1, 2_5_6) # test num_waveforms_per_prompt=1 (default) for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe([prompt] * batch_size , num_inference_steps=2 ).audios assert audios.shape == (batch_size, 2_5_6) # test num_waveforms_per_prompt for single prompt SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (num_waveforms_per_prompt, 2_5_6) # test num_waveforms_per_prompt for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe( [prompt] * batch_size , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config.sampling_rate SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.016 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.016 SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.032 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.032 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = ['hey'] SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape assert audio_shape == (1, 2_5_6) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config config.model_in_dim *= 2 SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ).to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram assert audio_shape == (1, 2_5_6) def UpperCamelCase ( self : Tuple ): """simple docstring""" self._test_attention_slicing_forward_pass(test_mean_pixel_difference=snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" self._test_inference_batch_single_identical(test_mean_pixel_difference=snake_case__ ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def UpperCamelCase ( self : Dict ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case__ ) @slow class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : Tuple="cpu" , snake_case__ : List[str]=torch.floataa , snake_case__ : Optional[Any]=0 ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = np.random.RandomState(snake_case__ ).standard_normal((1, 8, 1_2_8, 1_6) ) SCREAMING_SNAKE_CASE = torch.from_numpy(snake_case__ ).to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'latents': latents, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 2.5, } return inputs def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 2_5 SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[7_7_2_3_0:7_7_2_4_0] SCREAMING_SNAKE_CASE = np.array( [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 1E-2 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[2_7_7_8_0:2_7_7_9_0] SCREAMING_SNAKE_CASE = np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 3E-2
673
0
from datetime import datetime import matplotlib.pyplot as plt import torch def __lowerCAmelCase ( _UpperCamelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' for param in module.parameters(): SCREAMING_SNAKE_CASE = False def __lowerCAmelCase ( ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = 'cuda' if torch.cuda.is_available() else 'cpu' if torch.backends.mps.is_available() and torch.backends.mps.is_built(): SCREAMING_SNAKE_CASE = 'mps' if device == "mps": print( 'WARNING: MPS currently doesn\'t seem to work, and messes up backpropagation without any visible torch' ' errors. I recommend using CUDA on a colab notebook or CPU instead if you\'re facing inexplicable issues' ' with generations.' ) return device def __lowerCAmelCase ( _UpperCamelCase : List[str] ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = plt.imshow(_UpperCamelCase ) fig.axes.get_xaxis().set_visible(_UpperCamelCase ) fig.axes.get_yaxis().set_visible(_UpperCamelCase ) plt.show() def __lowerCAmelCase ( ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = datetime.now() SCREAMING_SNAKE_CASE = current_time.strftime('%H:%M:%S' ) return timestamp
706
import unittest from parameterized import parameterized from transformers import OpenLlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel class UpperCamelCase : def __init__( self : Dict , snake_case__ : str , snake_case__ : str=1_3 , snake_case__ : Tuple=7 , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : List[str]=False , snake_case__ : Any=True , snake_case__ : Union[str, Any]=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Optional[Any]=5 , snake_case__ : Optional[Any]=4 , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Tuple="gelu" , snake_case__ : Dict=0.1 , snake_case__ : Any=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Dict=1_6 , snake_case__ : str=2 , snake_case__ : Any=0.02 , snake_case__ : List[str]=3 , snake_case__ : int=4 , snake_case__ : List[str]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Dict ): """simple docstring""" return OpenLlamaConfig( 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=snake_case__ , initializer_range=self.initializer_range , use_stable_embedding=snake_case__ , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : int , snake_case__ : List[str] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : Tuple , ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : int , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() # first forward pass SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , use_cache=snake_case__ , ) SCREAMING_SNAKE_CASE = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([input_mask, next_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , past_key_values=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else () ) __UpperCamelCase =(OpenLlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": OpenLlamaModel, "text-classification": OpenLlamaForSequenceClassification, "text-generation": OpenLlamaForCausalLM, "zero-shot": OpenLlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'single_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test' ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" pass @parameterized.expand([('linear',), ('dynamic',)] ) def UpperCamelCase ( self : str , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = ids_tensor([1, 1_0] , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) original_model.to(snake_case__ ) original_model.eval() SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = {'type': scaling_type, 'factor': 10.0} SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) scaled_model.to(snake_case__ ) scaled_model.eval() SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) else: self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
673
0
import argparse import torch from torch import nn from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration def __lowerCAmelCase ( _UpperCamelCase : str ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', 'decoder.output_projection.weight', '_float_tensor', 'encoder.embed_positions._float_tensor', 'decoder.embed_positions._float_tensor', ] for k in ignore_keys: state_dict.pop(_UpperCamelCase , _UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Optional[int] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = list(s_dict.keys() ) for key in keys: if "transformer_layers" in key: SCREAMING_SNAKE_CASE = s_dict.pop(_UpperCamelCase ) elif "subsample" in key: SCREAMING_SNAKE_CASE = s_dict.pop(_UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : List[str] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = emb.weight.shape SCREAMING_SNAKE_CASE = nn.Linear(_UpperCamelCase , _UpperCamelCase , bias=_UpperCamelCase ) SCREAMING_SNAKE_CASE = emb.weight.data return lin_layer def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : List[str] ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase , map_location='cpu' ) SCREAMING_SNAKE_CASE = mam_aaa['args'] SCREAMING_SNAKE_CASE = mam_aaa['model'] SCREAMING_SNAKE_CASE = state_dict['decoder.output_projection.weight'] remove_ignore_keys_(_UpperCamelCase ) rename_keys(_UpperCamelCase ) SCREAMING_SNAKE_CASE = state_dict['decoder.embed_tokens.weight'].shape[0] SCREAMING_SNAKE_CASE = args.share_decoder_input_output_embed SCREAMING_SNAKE_CASE = [int(_UpperCamelCase ) for i in args.conv_kernel_sizes.split(',' )] SCREAMING_SNAKE_CASE = SpeechaTextConfig( vocab_size=_UpperCamelCase , max_source_positions=args.max_source_positions , max_target_positions=args.max_target_positions , encoder_layers=args.encoder_layers , decoder_layers=args.decoder_layers , encoder_attention_heads=args.encoder_attention_heads , decoder_attention_heads=args.decoder_attention_heads , encoder_ffn_dim=args.encoder_ffn_embed_dim , decoder_ffn_dim=args.decoder_ffn_embed_dim , d_model=args.encoder_embed_dim , dropout=args.dropout , attention_dropout=args.attention_dropout , activation_dropout=args.activation_dropout , activation_function='relu' , num_conv_layers=len(_UpperCamelCase ) , conv_channels=args.conv_channels , conv_kernel_sizes=_UpperCamelCase , input_feat_per_channel=args.input_feat_per_channel , input_channels=args.input_channels , tie_word_embeddings=_UpperCamelCase , num_beams=5 , max_length=2_00 , use_cache=_UpperCamelCase , decoder_start_token_id=2 , early_stopping=_UpperCamelCase , ) SCREAMING_SNAKE_CASE = SpeechaTextForConditionalGeneration(_UpperCamelCase ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = model.model.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) if len(_UpperCamelCase ) > 0 and not set(_UpperCamelCase ) <= { "encoder.embed_positions.weights", "decoder.embed_positions.weights", }: raise ValueError( 'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights` are allowed to be missing,' f""" but all the following weights are missing {missing}""" ) if tie_embeds: SCREAMING_SNAKE_CASE = make_linear_from_emb(model.model.decoder.embed_tokens ) else: SCREAMING_SNAKE_CASE = lm_head_weights model.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": a_ : Optional[int] = argparse.ArgumentParser() # Required parameters parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.") parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") a_ : str = parser.parse_args() convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)
707
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="openai/whisper-base" __UpperCamelCase =( "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the " "transcribed text." ) __UpperCamelCase ="transcriber" __UpperCamelCase =WhisperProcessor __UpperCamelCase =WhisperForConditionalGeneration __UpperCamelCase =["audio"] __UpperCamelCase =["text"] def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.pre_processor(snake_case__ , return_tensors='pt' ).input_features def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" return self.model.generate(inputs=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : Union[str, Any] ): """simple docstring""" return self.pre_processor.batch_decode(snake_case__ , skip_special_tokens=snake_case__ )[0]
673
0
def __lowerCAmelCase ( _UpperCamelCase : int ) -> bool: '''simple docstring''' if number < 0: raise ValueError('number must not be negative' ) return number & (number - 1) == 0 if __name__ == "__main__": import doctest doctest.testmod()
708
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
673
0
import argparse import json from pathlib import Path import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DeiTConfig, DeiTForImageClassificationWithTeacher, DeiTImageProcessor from transformers.utils import logging logging.set_verbosity_info() a_ : Optional[int] = logging.get_logger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : int=False ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f"""blocks.{i}.norm1.weight""", f"""deit.encoder.layer.{i}.layernorm_before.weight""") ) rename_keys.append((f"""blocks.{i}.norm1.bias""", f"""deit.encoder.layer.{i}.layernorm_before.bias""") ) rename_keys.append((f"""blocks.{i}.attn.proj.weight""", f"""deit.encoder.layer.{i}.attention.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.attn.proj.bias""", f"""deit.encoder.layer.{i}.attention.output.dense.bias""") ) rename_keys.append((f"""blocks.{i}.norm2.weight""", f"""deit.encoder.layer.{i}.layernorm_after.weight""") ) rename_keys.append((f"""blocks.{i}.norm2.bias""", f"""deit.encoder.layer.{i}.layernorm_after.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.weight""", f"""deit.encoder.layer.{i}.intermediate.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.bias""", f"""deit.encoder.layer.{i}.intermediate.dense.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.weight""", f"""deit.encoder.layer.{i}.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.bias""", f"""deit.encoder.layer.{i}.output.dense.bias""") ) # projection layer + position embeddings rename_keys.extend( [ ('cls_token', 'deit.embeddings.cls_token'), ('dist_token', 'deit.embeddings.distillation_token'), ('patch_embed.proj.weight', 'deit.embeddings.patch_embeddings.projection.weight'), ('patch_embed.proj.bias', 'deit.embeddings.patch_embeddings.projection.bias'), ('pos_embed', 'deit.embeddings.position_embeddings'), ] ) if base_model: # layernorm + pooler rename_keys.extend( [ ('norm.weight', 'layernorm.weight'), ('norm.bias', 'layernorm.bias'), ('pre_logits.fc.weight', 'pooler.dense.weight'), ('pre_logits.fc.bias', 'pooler.dense.bias'), ] ) # if just the base model, we should remove "deit" from all keys that start with "deit" SCREAMING_SNAKE_CASE = [(pair[0], pair[1][4:]) if pair[1].startswith('deit' ) else pair for pair in rename_keys] else: # layernorm + classification heads rename_keys.extend( [ ('norm.weight', 'deit.layernorm.weight'), ('norm.bias', 'deit.layernorm.bias'), ('head.weight', 'cls_classifier.weight'), ('head.bias', 'cls_classifier.bias'), ('head_dist.weight', 'distillation_classifier.weight'), ('head_dist.bias', 'distillation_classifier.bias'), ] ) return rename_keys def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : str , _UpperCamelCase : Tuple=False ) -> Optional[int]: '''simple docstring''' for i in range(config.num_hidden_layers ): if base_model: SCREAMING_SNAKE_CASE = '' else: SCREAMING_SNAKE_CASE = 'deit.' # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) SCREAMING_SNAKE_CASE = state_dict.pop(f"""blocks.{i}.attn.qkv.weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""blocks.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE = in_proj_weight[ : config.hidden_size, : ] SCREAMING_SNAKE_CASE = in_proj_bias[: config.hidden_size] SCREAMING_SNAKE_CASE = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] SCREAMING_SNAKE_CASE = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] SCREAMING_SNAKE_CASE = in_proj_weight[ -config.hidden_size :, : ] SCREAMING_SNAKE_CASE = in_proj_bias[-config.hidden_size :] def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Optional[int] , _UpperCamelCase : Union[str, Any] ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = dct.pop(_UpperCamelCase ) SCREAMING_SNAKE_CASE = val def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = 'http://images.cocodataset.org/val2017/000000039769.jpg' SCREAMING_SNAKE_CASE = Image.open(requests.get(_UpperCamelCase , stream=_UpperCamelCase ).raw ) return im @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : Union[str, Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = DeiTConfig() # all deit models have fine-tuned heads SCREAMING_SNAKE_CASE = False # dataset (fine-tuned on ImageNet 2012), patch_size and image_size SCREAMING_SNAKE_CASE = 10_00 SCREAMING_SNAKE_CASE = 'huggingface/label-files' SCREAMING_SNAKE_CASE = 'imagenet-1k-id2label.json' SCREAMING_SNAKE_CASE = json.load(open(hf_hub_download(_UpperCamelCase , _UpperCamelCase , repo_type='dataset' ) , 'r' ) ) SCREAMING_SNAKE_CASE = {int(_UpperCamelCase ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = idalabel SCREAMING_SNAKE_CASE = {v: k for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = int(deit_name[-6:-4] ) SCREAMING_SNAKE_CASE = int(deit_name[-3:] ) # size of the architecture if deit_name[9:].startswith('tiny' ): SCREAMING_SNAKE_CASE = 1_92 SCREAMING_SNAKE_CASE = 7_68 SCREAMING_SNAKE_CASE = 12 SCREAMING_SNAKE_CASE = 3 elif deit_name[9:].startswith('small' ): SCREAMING_SNAKE_CASE = 3_84 SCREAMING_SNAKE_CASE = 15_36 SCREAMING_SNAKE_CASE = 12 SCREAMING_SNAKE_CASE = 6 if deit_name[9:].startswith('base' ): pass elif deit_name[4:].startswith('large' ): SCREAMING_SNAKE_CASE = 10_24 SCREAMING_SNAKE_CASE = 40_96 SCREAMING_SNAKE_CASE = 24 SCREAMING_SNAKE_CASE = 16 # load original model from timm SCREAMING_SNAKE_CASE = timm.create_model(_UpperCamelCase , pretrained=_UpperCamelCase ) timm_model.eval() # load state_dict of original model, remove and rename some keys SCREAMING_SNAKE_CASE = timm_model.state_dict() SCREAMING_SNAKE_CASE = create_rename_keys(_UpperCamelCase , _UpperCamelCase ) for src, dest in rename_keys: rename_key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) read_in_q_k_v(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # load HuggingFace model SCREAMING_SNAKE_CASE = DeiTForImageClassificationWithTeacher(_UpperCamelCase ).eval() model.load_state_dict(_UpperCamelCase ) # Check outputs on an image, prepared by DeiTImageProcessor SCREAMING_SNAKE_CASE = int( (2_56 / 2_24) * config.image_size ) # to maintain same ratio w.r.t. 224 images, see https://github.com/facebookresearch/deit/blob/ab5715372db8c6cad5740714b2216d55aeae052e/datasets.py#L103 SCREAMING_SNAKE_CASE = DeiTImageProcessor(size=_UpperCamelCase , crop_size=config.image_size ) SCREAMING_SNAKE_CASE = image_processor(images=prepare_img() , return_tensors='pt' ) SCREAMING_SNAKE_CASE = encoding['pixel_values'] SCREAMING_SNAKE_CASE = model(_UpperCamelCase ) SCREAMING_SNAKE_CASE = timm_model(_UpperCamelCase ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(_UpperCamelCase , outputs.logits , atol=1e-3 ) Path(_UpperCamelCase ).mkdir(exist_ok=_UpperCamelCase ) print(f"""Saving model {deit_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(_UpperCamelCase ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": a_ : str = argparse.ArgumentParser() # Required parameters parser.add_argument( "--deit_name", default="vit_deit_base_distilled_patch16_224", type=str, help="Name of the DeiT timm model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory." ) a_ : Optional[Any] = parser.parse_args() convert_deit_checkpoint(args.deit_name, args.pytorch_dump_folder_path)
709
import numpy as np def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return 1 / (1 + np.exp(-vector )) def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return vector * sigmoid(_UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
673
0
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
710
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
673
0
from pickle import UnpicklingError import jax import jax.numpy as jnp import numpy as np from flax.serialization import from_bytes from flax.traverse_util import flatten_dict from ..utils import logging a_ : List[str] = logging.get_logger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[Any] ) -> Dict: '''simple docstring''' try: with open(_UpperCamelCase , 'rb' ) as flax_state_f: SCREAMING_SNAKE_CASE = from_bytes(_UpperCamelCase , flax_state_f.read() ) except UnpicklingError as e: try: with open(_UpperCamelCase ) as f: if f.read().startswith('version' ): raise OSError( 'You seem to have cloned a repository without having git-lfs installed. Please' ' install git-lfs and run `git lfs install` followed by `git lfs pull` in the' ' folder you cloned.' ) else: raise ValueError from e except (UnicodeDecodeError, ValueError): raise EnvironmentError(f"""Unable to convert {model_file} to Flax deserializable object. """ ) return load_flax_weights_in_pytorch_model(_UpperCamelCase , _UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Union[str, Any] , _UpperCamelCase : List[Any] ) -> List[Any]: '''simple docstring''' try: import torch # noqa: F401 except ImportError: logger.error( 'Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see' ' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation' ' instructions.' ) raise # check if we have bf16 weights SCREAMING_SNAKE_CASE = flatten_dict(jax.tree_util.tree_map(lambda _UpperCamelCase : x.dtype == jnp.bfloataa , _UpperCamelCase ) ).values() if any(_UpperCamelCase ): # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16 # and bf16 is not fully supported in PT yet. logger.warning( 'Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` ' 'before loading those in PyTorch model.' ) SCREAMING_SNAKE_CASE = jax.tree_util.tree_map( lambda _UpperCamelCase : params.astype(np.floataa ) if params.dtype == jnp.bfloataa else params , _UpperCamelCase ) SCREAMING_SNAKE_CASE = '' SCREAMING_SNAKE_CASE = flatten_dict(_UpperCamelCase , sep='.' ) SCREAMING_SNAKE_CASE = pt_model.state_dict() # keep track of unexpected & missing keys SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set(pt_model_dict.keys() ) for flax_key_tuple, flax_tensor in flax_state_dict.items(): SCREAMING_SNAKE_CASE = flax_key_tuple.split('.' ) if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4: SCREAMING_SNAKE_CASE = flax_key_tuple_array[:-1] + ['weight'] SCREAMING_SNAKE_CASE = jnp.transpose(_UpperCamelCase , (3, 2, 0, 1) ) elif flax_key_tuple_array[-1] == "kernel": SCREAMING_SNAKE_CASE = flax_key_tuple_array[:-1] + ['weight'] SCREAMING_SNAKE_CASE = flax_tensor.T elif flax_key_tuple_array[-1] == "scale": SCREAMING_SNAKE_CASE = flax_key_tuple_array[:-1] + ['weight'] if "time_embedding" not in flax_key_tuple_array: for i, flax_key_tuple_string in enumerate(_UpperCamelCase ): SCREAMING_SNAKE_CASE = ( flax_key_tuple_string.replace('_0' , '.0' ) .replace('_1' , '.1' ) .replace('_2' , '.2' ) .replace('_3' , '.3' ) .replace('_4' , '.4' ) .replace('_5' , '.5' ) .replace('_6' , '.6' ) .replace('_7' , '.7' ) .replace('_8' , '.8' ) .replace('_9' , '.9' ) ) SCREAMING_SNAKE_CASE = '.'.join(_UpperCamelCase ) if flax_key in pt_model_dict: if flax_tensor.shape != pt_model_dict[flax_key].shape: raise ValueError( f"""Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected """ f"""to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.""" ) else: # add weight to pytorch dict SCREAMING_SNAKE_CASE = np.asarray(_UpperCamelCase ) if not isinstance(_UpperCamelCase , np.ndarray ) else flax_tensor SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ) # remove from missing keys missing_keys.remove(_UpperCamelCase ) else: # weight is not expected by PyTorch model unexpected_keys.append(_UpperCamelCase ) pt_model.load_state_dict(_UpperCamelCase ) # re-transform missing_keys to list SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) if len(_UpperCamelCase ) > 0: logger.warning( 'Some weights of the Flax model were not used when initializing the PyTorch model' f""" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing""" f""" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture""" ' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This' f""" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect""" ' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a' ' FlaxBertForSequenceClassification model).' ) if len(_UpperCamelCase ) > 0: logger.warning( f"""Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly""" f""" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to""" ' use it for predictions and inference.' ) return pt_model
711
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
673
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, is_vision_available, ) a_ : Any = {"processing_layoutxlm": ["LayoutXLMProcessor"]} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : List[str] = ["LayoutXLMTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Optional[Any] = ["LayoutXLMTokenizerFast"] if TYPE_CHECKING: from .processing_layoutxlm import LayoutXLMProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_layoutxlm import LayoutXLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_layoutxlm_fast import LayoutXLMTokenizerFast else: import sys a_ : List[str] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
712
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : Dict = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Any , **snake_case__ : Optional[int] ): """simple docstring""" super().__init__(**snake_case__ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(snake_case__ ) def __call__( self : List[Any] , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(snake_case__ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {'image': image, 'candidate_labels': candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(snake_case__ , **snake_case__ ) return results def UpperCamelCase ( self : Union[str, Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs['threshold'] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs['top_k'] return {}, {}, postprocess_params def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs['candidate_labels'] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = self.tokenizer(snake_case__ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(snake_case__ , return_tensors=self.framework ) yield { "is_last": i == len(snake_case__ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**snake_case__ ) SCREAMING_SNAKE_CASE = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output['candidate_label'] SCREAMING_SNAKE_CASE = BaseModelOutput(snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=snake_case__ , threshold=snake_case__ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs['scores'][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {'score': score, 'label': label, 'box': box} results.append(snake_case__ ) SCREAMING_SNAKE_CASE = sorted(snake_case__ , key=lambda snake_case__ : x["score"] , reverse=snake_case__ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : List[Any] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
673
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) a_ : str = { "configuration_albert": ["ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "AlbertConfig", "AlbertOnnxConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Any = ["AlbertTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Union[str, Any] = ["AlbertTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : List[str] = [ "ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "AlbertForMaskedLM", "AlbertForMultipleChoice", "AlbertForPreTraining", "AlbertForQuestionAnswering", "AlbertForSequenceClassification", "AlbertForTokenClassification", "AlbertModel", "AlbertPreTrainedModel", "load_tf_weights_in_albert", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Any = [ "TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFAlbertForMaskedLM", "TFAlbertForMultipleChoice", "TFAlbertForPreTraining", "TFAlbertForQuestionAnswering", "TFAlbertForSequenceClassification", "TFAlbertForTokenClassification", "TFAlbertMainLayer", "TFAlbertModel", "TFAlbertPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : List[Any] = [ "FlaxAlbertForMaskedLM", "FlaxAlbertForMultipleChoice", "FlaxAlbertForPreTraining", "FlaxAlbertForQuestionAnswering", "FlaxAlbertForSequenceClassification", "FlaxAlbertForTokenClassification", "FlaxAlbertModel", "FlaxAlbertPreTrainedModel", ] if TYPE_CHECKING: from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_albert import AlbertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_albert_fast import AlbertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_albert import ( ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST, AlbertForMaskedLM, AlbertForMultipleChoice, AlbertForPreTraining, AlbertForQuestionAnswering, AlbertForSequenceClassification, AlbertForTokenClassification, AlbertModel, AlbertPreTrainedModel, load_tf_weights_in_albert, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_albert import ( TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFAlbertForMaskedLM, TFAlbertForMultipleChoice, TFAlbertForPreTraining, TFAlbertForQuestionAnswering, TFAlbertForSequenceClassification, TFAlbertForTokenClassification, TFAlbertMainLayer, TFAlbertModel, TFAlbertPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_albert import ( FlaxAlbertForMaskedLM, FlaxAlbertForMultipleChoice, FlaxAlbertForPreTraining, FlaxAlbertForQuestionAnswering, FlaxAlbertForSequenceClassification, FlaxAlbertForTokenClassification, FlaxAlbertModel, FlaxAlbertPreTrainedModel, ) else: import sys a_ : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
713
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
673
0
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 __lowerCAmelCase ( ) -> List[Any]: '''simple docstring''' raise RuntimeError('CUDA out of memory.' ) class UpperCamelCase ( nn.Module ): def __init__( self : Any ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = nn.Linear(3 , 4 ) SCREAMING_SNAKE_CASE = nn.BatchNormad(4 ) SCREAMING_SNAKE_CASE = nn.Linear(4 , 5 ) def UpperCamelCase ( self : Any , snake_case__ : str ): """simple docstring""" return self.lineara(self.batchnorm(self.lineara(snake_case__ ) ) ) class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = [] @find_executable_batch_size(starting_batch_size=1_2_8 ) def mock_training_loop_function(snake_case__ : int ): nonlocal batch_sizes batch_sizes.append(snake_case__ ) if batch_size != 8: raise_fake_out_of_memory() mock_training_loop_function() self.assertListEqual(snake_case__ , [1_2_8, 6_4, 3_2, 1_6, 8] ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = [] @find_executable_batch_size(starting_batch_size=1_2_8 ) def mock_training_loop_function(snake_case__ : Union[str, Any] , snake_case__ : Any ): nonlocal batch_sizes batch_sizes.append(snake_case__ ) if batch_size != 8: raise_fake_out_of_memory() return batch_size, arga SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = mock_training_loop_function('hello' ) self.assertListEqual(snake_case__ , [1_2_8, 6_4, 3_2, 1_6, 8] ) self.assertListEqual([bs, arga] , [8, 'hello'] ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" @find_executable_batch_size(starting_batch_size=0 ) def mock_training_loop_function(snake_case__ : Union[str, Any] ): pass with self.assertRaises(snake_case__ ) as cm: mock_training_loop_function() self.assertIn('No executable batch size found, reached zero.' , cm.exception.args[0] ) def UpperCamelCase ( self : int ): """simple docstring""" @find_executable_batch_size(starting_batch_size=1_6 ) def mock_training_loop_function(snake_case__ : Union[str, Any] ): if batch_size > 0: raise_fake_out_of_memory() pass with self.assertRaises(snake_case__ ) as cm: mock_training_loop_function() self.assertIn('No executable batch size found, reached zero.' , cm.exception.args[0] ) def UpperCamelCase ( self : int ): """simple docstring""" @find_executable_batch_size(starting_batch_size=1_2_8 ) def mock_training_loop_function(snake_case__ : int , snake_case__ : Tuple , snake_case__ : Tuple ): if batch_size != 8: raise raise_fake_out_of_memory() with self.assertRaises(snake_case__ ) as cm: mock_training_loop_function(1_2_8 , '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 UpperCamelCase ( self : Optional[Any] ): """simple docstring""" @find_executable_batch_size(starting_batch_size=1_6 ) def mock_training_loop_function(snake_case__ : Dict ): raise ValueError('Oops, we had an error!' ) with self.assertRaises(snake_case__ ) as cm: mock_training_loop_function() self.assertIn('Oops, we had an error!' , cm.exception.args[0] ) @require_cuda def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.cuda.memory_allocated() SCREAMING_SNAKE_CASE = ModelForTest() model.cuda() self.assertGreater(torch.cuda.memory_allocated() , snake_case__ ) SCREAMING_SNAKE_CASE = release_memory(snake_case__ ) self.assertEqual(torch.cuda.memory_allocated() , snake_case__ )
714
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
673
0
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import cached_download, hf_hub_url from PIL import Image from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor from transformers.utils import logging logging.set_verbosity_info() a_ : Any = logging.get_logger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = DPTConfig() if "large" in checkpoint_url: SCREAMING_SNAKE_CASE = 10_24 SCREAMING_SNAKE_CASE = 40_96 SCREAMING_SNAKE_CASE = 24 SCREAMING_SNAKE_CASE = 16 SCREAMING_SNAKE_CASE = [5, 11, 17, 23] SCREAMING_SNAKE_CASE = [2_56, 5_12, 10_24, 10_24] SCREAMING_SNAKE_CASE = (1, 3_84, 3_84) if "ade" in checkpoint_url: SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = 1_50 SCREAMING_SNAKE_CASE = 'huggingface/label-files' SCREAMING_SNAKE_CASE = 'ade20k-id2label.json' SCREAMING_SNAKE_CASE = json.load(open(cached_download(hf_hub_url(_UpperCamelCase , _UpperCamelCase , repo_type='dataset' ) ) , 'r' ) ) SCREAMING_SNAKE_CASE = {int(_UpperCamelCase ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = idalabel SCREAMING_SNAKE_CASE = {v: k for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = [1, 1_50, 4_80, 4_80] return config, expected_shape def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = ['pretrained.model.head.weight', 'pretrained.model.head.bias'] for k in ignore_keys: state_dict.pop(_UpperCamelCase , _UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] ) -> Optional[Any]: '''simple docstring''' if ( "pretrained.model" in name and "cls_token" not in name and "pos_embed" not in name and "patch_embed" not in name ): SCREAMING_SNAKE_CASE = name.replace('pretrained.model' , 'dpt.encoder' ) if "pretrained.model" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.model' , 'dpt.embeddings' ) if "patch_embed" in name: SCREAMING_SNAKE_CASE = name.replace('patch_embed' , 'patch_embeddings' ) if "pos_embed" in name: SCREAMING_SNAKE_CASE = name.replace('pos_embed' , 'position_embeddings' ) if "attn.proj" in name: SCREAMING_SNAKE_CASE = name.replace('attn.proj' , 'attention.output.dense' ) if "proj" in name and "project" not in name: SCREAMING_SNAKE_CASE = name.replace('proj' , 'projection' ) if "blocks" in name: SCREAMING_SNAKE_CASE = name.replace('blocks' , 'layer' ) if "mlp.fc1" in name: SCREAMING_SNAKE_CASE = name.replace('mlp.fc1' , 'intermediate.dense' ) if "mlp.fc2" in name: SCREAMING_SNAKE_CASE = name.replace('mlp.fc2' , 'output.dense' ) if "norm1" in name: SCREAMING_SNAKE_CASE = name.replace('norm1' , 'layernorm_before' ) if "norm2" in name: SCREAMING_SNAKE_CASE = name.replace('norm2' , 'layernorm_after' ) if "scratch.output_conv" in name: SCREAMING_SNAKE_CASE = name.replace('scratch.output_conv' , 'head' ) if "scratch" in name: SCREAMING_SNAKE_CASE = name.replace('scratch' , 'neck' ) if "layer1_rn" in name: SCREAMING_SNAKE_CASE = name.replace('layer1_rn' , 'convs.0' ) if "layer2_rn" in name: SCREAMING_SNAKE_CASE = name.replace('layer2_rn' , 'convs.1' ) if "layer3_rn" in name: SCREAMING_SNAKE_CASE = name.replace('layer3_rn' , 'convs.2' ) if "layer4_rn" in name: SCREAMING_SNAKE_CASE = name.replace('layer4_rn' , 'convs.3' ) if "refinenet" in name: SCREAMING_SNAKE_CASE = int(name[len('neck.refinenet' ) : len('neck.refinenet' ) + 1] ) # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3 SCREAMING_SNAKE_CASE = name.replace(f"""refinenet{layer_idx}""" , f"""fusion_stage.layers.{abs(layer_idx-4 )}""" ) if "out_conv" in name: SCREAMING_SNAKE_CASE = name.replace('out_conv' , 'projection' ) if "resConfUnit1" in name: SCREAMING_SNAKE_CASE = name.replace('resConfUnit1' , 'residual_layer1' ) if "resConfUnit2" in name: SCREAMING_SNAKE_CASE = name.replace('resConfUnit2' , 'residual_layer2' ) if "conv1" in name: SCREAMING_SNAKE_CASE = name.replace('conv1' , 'convolution1' ) if "conv2" in name: SCREAMING_SNAKE_CASE = name.replace('conv2' , 'convolution2' ) # readout blocks if "pretrained.act_postprocess1.0.project.0" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess1.0.project.0' , 'neck.reassemble_stage.readout_projects.0.0' ) if "pretrained.act_postprocess2.0.project.0" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess2.0.project.0' , 'neck.reassemble_stage.readout_projects.1.0' ) if "pretrained.act_postprocess3.0.project.0" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess3.0.project.0' , 'neck.reassemble_stage.readout_projects.2.0' ) if "pretrained.act_postprocess4.0.project.0" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess4.0.project.0' , 'neck.reassemble_stage.readout_projects.3.0' ) # resize blocks if "pretrained.act_postprocess1.3" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess1.3' , 'neck.reassemble_stage.layers.0.projection' ) if "pretrained.act_postprocess1.4" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess1.4' , 'neck.reassemble_stage.layers.0.resize' ) if "pretrained.act_postprocess2.3" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess2.3' , 'neck.reassemble_stage.layers.1.projection' ) if "pretrained.act_postprocess2.4" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess2.4' , 'neck.reassemble_stage.layers.1.resize' ) if "pretrained.act_postprocess3.3" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess3.3' , 'neck.reassemble_stage.layers.2.projection' ) if "pretrained.act_postprocess4.3" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess4.3' , 'neck.reassemble_stage.layers.3.projection' ) if "pretrained.act_postprocess4.4" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained.act_postprocess4.4' , 'neck.reassemble_stage.layers.3.resize' ) if "pretrained" in name: SCREAMING_SNAKE_CASE = name.replace('pretrained' , 'dpt' ) if "bn" in name: SCREAMING_SNAKE_CASE = name.replace('bn' , 'batch_norm' ) if "head" in name: SCREAMING_SNAKE_CASE = name.replace('head' , 'head.head' ) if "encoder.norm" in name: SCREAMING_SNAKE_CASE = name.replace('encoder.norm' , 'layernorm' ) if "auxlayer" in name: SCREAMING_SNAKE_CASE = name.replace('auxlayer' , 'auxiliary_head.head' ) return name def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : Optional[Any] ) -> Any: '''simple docstring''' for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) SCREAMING_SNAKE_CASE = state_dict.pop(f"""dpt.encoder.layer.{i}.attn.qkv.weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""dpt.encoder.layer.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE = in_proj_weight[: config.hidden_size, :] SCREAMING_SNAKE_CASE = in_proj_bias[: config.hidden_size] SCREAMING_SNAKE_CASE = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] SCREAMING_SNAKE_CASE = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] SCREAMING_SNAKE_CASE = in_proj_weight[ -config.hidden_size :, : ] SCREAMING_SNAKE_CASE = in_proj_bias[-config.hidden_size :] def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = 'http://images.cocodataset.org/val2017/000000039769.jpg' SCREAMING_SNAKE_CASE = Image.open(requests.get(_UpperCamelCase , stream=_UpperCamelCase ).raw ) return im @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Optional[Any] , _UpperCamelCase : Dict , _UpperCamelCase : Dict , _UpperCamelCase : int ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = get_dpt_config(_UpperCamelCase ) # load original state_dict from URL SCREAMING_SNAKE_CASE = torch.hub.load_state_dict_from_url(_UpperCamelCase , map_location='cpu' ) # remove certain keys remove_ignore_keys_(_UpperCamelCase ) # rename keys for key in state_dict.copy().keys(): SCREAMING_SNAKE_CASE = state_dict.pop(_UpperCamelCase ) SCREAMING_SNAKE_CASE = val # read in qkv matrices read_in_q_k_v(_UpperCamelCase , _UpperCamelCase ) # load HuggingFace model SCREAMING_SNAKE_CASE = DPTForSemanticSegmentation(_UpperCamelCase ) if 'ade' in checkpoint_url else DPTForDepthEstimation(_UpperCamelCase ) model.load_state_dict(_UpperCamelCase ) model.eval() # Check outputs on an image SCREAMING_SNAKE_CASE = 4_80 if 'ade' in checkpoint_url else 3_84 SCREAMING_SNAKE_CASE = DPTImageProcessor(size=_UpperCamelCase ) SCREAMING_SNAKE_CASE = prepare_img() SCREAMING_SNAKE_CASE = image_processor(_UpperCamelCase , return_tensors='pt' ) # forward pass SCREAMING_SNAKE_CASE = model(**_UpperCamelCase ).logits if 'ade' in checkpoint_url else model(**_UpperCamelCase ).predicted_depth # Assert logits SCREAMING_SNAKE_CASE = torch.tensor([[6.31_99, 6.36_29, 6.41_48], [6.38_50, 6.36_15, 6.41_66], [6.35_19, 6.31_76, 6.35_75]] ) if "ade" in checkpoint_url: SCREAMING_SNAKE_CASE = torch.tensor([[4.04_80, 4.24_20, 4.43_60], [4.31_24, 4.56_93, 4.82_61], [4.57_68, 4.89_65, 5.21_63]] ) assert outputs.shape == torch.Size(_UpperCamelCase ) assert ( torch.allclose(outputs[0, 0, :3, :3] , _UpperCamelCase , atol=1e-4 ) if "ade" in checkpoint_url else torch.allclose(outputs[0, :3, :3] , _UpperCamelCase ) ) Path(_UpperCamelCase ).mkdir(exist_ok=_UpperCamelCase ) print(f"""Saving model to {pytorch_dump_folder_path}""" ) model.save_pretrained(_UpperCamelCase ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(_UpperCamelCase ) if push_to_hub: print('Pushing model to hub...' ) model.push_to_hub( repo_path_or_name=Path(_UpperCamelCase , _UpperCamelCase ) , organization='nielsr' , commit_message='Add model' , use_temp_dir=_UpperCamelCase , ) image_processor.push_to_hub( repo_path_or_name=Path(_UpperCamelCase , _UpperCamelCase ) , organization='nielsr' , commit_message='Add image processor' , use_temp_dir=_UpperCamelCase , ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( "--checkpoint_url", default="https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt", type=str, help="URL of the original DPT checkpoint you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model directory.", ) parser.add_argument( "--push_to_hub", action="store_true", ) parser.add_argument( "--model_name", default="dpt-large", type=str, help="Name of the model, in case you're pushing to the hub.", ) a_ : Any = parser.parse_args() convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)
715
# Note: if you intend to run this script make sure you look under scripts/fsmt/ # to locate the appropriate script to do the work correctly. There is a set of scripts to: # - download and prepare data and run the conversion script # - perform eval to get the best hparam into the config # - generate model_cards - useful if you have multiple models from the same paper import argparse import json import os import re from collections import OrderedDict from os.path import basename, dirname import fairseq import torch from fairseq import hub_utils from fairseq.data.dictionary import Dictionary from transformers import FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() a_ : str = 2 # based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping` # values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults: # # * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users) # * `early_stopping`: `False` consistently scored better # * `length_penalty` varied, so will assign the best one depending on the model a_ : int = { # fairseq: "wmt19-ru-en": {"length_penalty": 1.1}, "wmt19-en-ru": {"length_penalty": 1.1_5}, "wmt19-en-de": {"length_penalty": 1.0}, "wmt19-de-en": {"length_penalty": 1.1}, # allenai: "wmt16-en-de-dist-12-1": {"length_penalty": 0.6}, "wmt16-en-de-dist-6-1": {"length_penalty": 0.6}, "wmt16-en-de-12-1": {"length_penalty": 0.8}, "wmt19-de-en-6-6-base": {"length_penalty": 0.6}, "wmt19-de-en-6-6-big": {"length_penalty": 0.6}, } # this remaps the different models to their organization names a_ : str = {} for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: a_ : List[Any] = "facebook" for m in [ "wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1", "wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big", ]: a_ : Any = "allenai" def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = dict((re.sub(R'@@$' , '' , _UpperCamelCase ), v) if k.endswith('@@' ) else (re.sub(R'$' , '</w>' , _UpperCamelCase ), v) for k, v in d.items() ) SCREAMING_SNAKE_CASE = '<s> <pad> </s> <unk>'.split() # restore the special tokens for k in keep_keys: del da[f"""{k}</w>"""] SCREAMING_SNAKE_CASE = d[k] # restore return da def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[str] ) -> Dict: '''simple docstring''' assert os.path.exists(_UpperCamelCase ) os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) print(f"""Writing results to {pytorch_dump_folder_path}""" ) # handle various types of models SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel SCREAMING_SNAKE_CASE = cls.hub_models() SCREAMING_SNAKE_CASE = {'bpe': 'fastbpe', 'tokenizer': 'moses'} SCREAMING_SNAKE_CASE = '.' # note: since the model dump is old, fairseq has upgraded its model some # time later, and it does a whole lot of rewrites and splits on the saved # weights, therefore we can't use torch.load() directly on the model file. # see: upgrade_state_dict(state_dict) in fairseq_model.py print(f"""using checkpoint {checkpoint_file}""" ) SCREAMING_SNAKE_CASE = hub_utils.from_pretrained( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , archive_map=_UpperCamelCase , **_UpperCamelCase ) SCREAMING_SNAKE_CASE = vars(chkpt['args']['model'] ) SCREAMING_SNAKE_CASE = args['source_lang'] SCREAMING_SNAKE_CASE = args['target_lang'] SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) # dicts SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{src_lang}.txt""" ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{tgt_lang}.txt""" ) SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(src_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-src.json' ) print(f"""Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # detect whether this is a do_lower_case situation, which can be derived by checking whether we # have at least one uppercase letter in the source vocab SCREAMING_SNAKE_CASE = True for k in src_vocab.keys(): if not k.islower(): SCREAMING_SNAKE_CASE = False break SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(tgt_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-tgt.json' ) print(f"""Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # merges_file (bpecodes) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , VOCAB_FILES_NAMES['merges_file'] ) for fn in ["bpecodes", "code"]: # older fairseq called the merges file "code" SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) if os.path.exists(_UpperCamelCase ): break with open(_UpperCamelCase , encoding='utf-8' ) as fin: SCREAMING_SNAKE_CASE = fin.read() SCREAMING_SNAKE_CASE = re.sub(R' \d+$' , '' , _UpperCamelCase , 0 , re.M ) # remove frequency number print(f"""Generating {merges_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as fout: fout.write(_UpperCamelCase ) # model config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'config.json' ) # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe - # may have to modify the tokenizer if a different type is used by a future model assert args["bpe"] == "fastbpe", f"""need to extend tokenizer to support bpe={args['bpe']}""" assert args["tokenizer"] == "moses", f"""need to extend tokenizer to support bpe={args['tokenizer']}""" SCREAMING_SNAKE_CASE = { 'architectures': ['FSMTForConditionalGeneration'], 'model_type': 'fsmt', 'activation_dropout': args['activation_dropout'], 'activation_function': 'relu', 'attention_dropout': args['attention_dropout'], 'd_model': args['decoder_embed_dim'], 'dropout': args['dropout'], 'init_std': 0.02, 'max_position_embeddings': args['max_source_positions'], 'num_hidden_layers': args['encoder_layers'], 'src_vocab_size': src_vocab_size, 'tgt_vocab_size': tgt_vocab_size, 'langs': [src_lang, tgt_lang], 'encoder_attention_heads': args['encoder_attention_heads'], 'encoder_ffn_dim': args['encoder_ffn_embed_dim'], 'encoder_layerdrop': args['encoder_layerdrop'], 'encoder_layers': args['encoder_layers'], 'decoder_attention_heads': args['decoder_attention_heads'], 'decoder_ffn_dim': args['decoder_ffn_embed_dim'], 'decoder_layerdrop': args['decoder_layerdrop'], 'decoder_layers': args['decoder_layers'], 'bos_token_id': 0, 'pad_token_id': 1, 'eos_token_id': 2, 'is_encoder_decoder': True, 'scale_embedding': not args['no_scale_embedding'], 'tie_word_embeddings': args['share_all_embeddings'], } # good hparam defaults to start with SCREAMING_SNAKE_CASE = 5 SCREAMING_SNAKE_CASE = False if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]: SCREAMING_SNAKE_CASE = best_score_hparams[model_dir]['length_penalty'] else: SCREAMING_SNAKE_CASE = 1.0 print(f"""Generating {fsmt_model_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # tokenizer config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = { 'langs': [src_lang, tgt_lang], 'model_max_length': 10_24, 'do_lower_case': do_lower_case, } print(f"""Generating {fsmt_tokenizer_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # model SCREAMING_SNAKE_CASE = chkpt['models'][0] SCREAMING_SNAKE_CASE = model.state_dict() # rename keys to start with 'model.' SCREAMING_SNAKE_CASE = OrderedDict(('model.' + k, v) for k, v in model_state_dict.items() ) # remove unneeded keys SCREAMING_SNAKE_CASE = [ 'model.model', 'model.encoder.version', 'model.decoder.version', 'model.encoder_embed_tokens.weight', 'model.decoder_embed_tokens.weight', 'model.encoder.embed_positions._float_tensor', 'model.decoder.embed_positions._float_tensor', ] for k in ignore_keys: model_state_dict.pop(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTForConditionalGeneration(_UpperCamelCase ) # check that it loads ok model_new.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) # save SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) print(f"""Generating {pytorch_weights_dump_path}""" ) torch.save(_UpperCamelCase , _UpperCamelCase ) print('Conversion is done!' ) print('\nLast step is to upload the files to s3' ) print(f"""cd {data_root}""" ) print(f"""transformers-cli upload {model_dir}""" ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--fsmt_checkpoint_path", default=None, type=str, required=True, help=( "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts," " bpecodes, etc." ), ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) a_ : int = parser.parse_args() convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
673
0
import argparse import os from pathlib import Path import fairseq import torch from packaging import version from torch import nn from transformers import ( BartConfig, BartForConditionalGeneration, BartForSequenceClassification, BartModel, BartTokenizer, ) from transformers.utils import logging a_ : List[str] = ["bart.large", "bart.large.mnli", "bart.large.cnn", "bart_xsum/model.pt"] a_ : Tuple = {"bart.large": BartModel, "bart.large.mnli": BartForSequenceClassification} if version.parse(fairseq.__version__) < version.parse("0.9.0"): raise Exception("requires fairseq >= 0.9.0") logging.set_verbosity_info() a_ : Optional[int] = logging.get_logger(__name__) a_ : List[Any] = " Hello world! cécé herlolip" a_ : List[str] = [ ("model.classification_heads.mnli.dense.weight", "classification_head.dense.weight"), ("model.classification_heads.mnli.dense.bias", "classification_head.dense.bias"), ("model.classification_heads.mnli.out_proj.weight", "classification_head.out_proj.weight"), ("model.classification_heads.mnli.out_proj.bias", "classification_head.out_proj.bias"), ] def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', '_float_tensor', ] for k in ignore_keys: state_dict.pop(_UpperCamelCase , _UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : Optional[Any] , _UpperCamelCase : Optional[int] ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = dct.pop(_UpperCamelCase ) SCREAMING_SNAKE_CASE = val def __lowerCAmelCase ( _UpperCamelCase : Any ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase , map_location='cpu' ) SCREAMING_SNAKE_CASE = torch.hub.load('pytorch/fairseq' , 'bart.large.cnn' ).eval() hub_interface.model.load_state_dict(sd['model'] ) return hub_interface def __lowerCAmelCase ( _UpperCamelCase : Union[str, Any] ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = emb.weight.shape SCREAMING_SNAKE_CASE = nn.Linear(_UpperCamelCase , _UpperCamelCase , bias=_UpperCamelCase ) SCREAMING_SNAKE_CASE = emb.weight.data return lin_layer @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : str , _UpperCamelCase : Tuple=None ) -> Tuple: '''simple docstring''' if not os.path.exists(_UpperCamelCase ): SCREAMING_SNAKE_CASE = torch.hub.load('pytorch/fairseq' , _UpperCamelCase ).eval() else: SCREAMING_SNAKE_CASE = load_xsum_checkpoint(_UpperCamelCase ) bart.model.upgrade_state_dict(bart.model.state_dict() ) if hf_checkpoint_name is None: SCREAMING_SNAKE_CASE = checkpoint_path.replace('.' , '-' ) SCREAMING_SNAKE_CASE = BartConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = bart.encode(_UpperCamelCase ).unsqueeze(0 ) SCREAMING_SNAKE_CASE = BartTokenizer.from_pretrained(_UpperCamelCase ).encode(_UpperCamelCase , return_tensors='pt' ).unsqueeze(0 ) if not torch.eq(_UpperCamelCase , _UpperCamelCase ).all(): raise ValueError( f"""converted tokenizer and pretrained tokenizer returned different output: {tokens} != {tokensa}""" ) if checkpoint_path == "bart.large.mnli": SCREAMING_SNAKE_CASE = bart.state_dict() remove_ignore_keys_(_UpperCamelCase ) SCREAMING_SNAKE_CASE = state_dict['model.decoder.embed_tokens.weight'] for src, dest in mnli_rename_keys: rename_key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = BartForSequenceClassification(_UpperCamelCase ).eval() model.load_state_dict(_UpperCamelCase ) SCREAMING_SNAKE_CASE = bart.predict('mnli' , _UpperCamelCase , return_logits=_UpperCamelCase ) SCREAMING_SNAKE_CASE = model(_UpperCamelCase )[0] # logits else: # no classification heads to worry about SCREAMING_SNAKE_CASE = bart.model.state_dict() remove_ignore_keys_(_UpperCamelCase ) SCREAMING_SNAKE_CASE = state_dict['decoder.embed_tokens.weight'] SCREAMING_SNAKE_CASE = bart.extract_features(_UpperCamelCase ) if hf_checkpoint_name == "facebook/bart-large": SCREAMING_SNAKE_CASE = BartModel(_UpperCamelCase ).eval() model.load_state_dict(_UpperCamelCase ) SCREAMING_SNAKE_CASE = model(_UpperCamelCase ).model[0] else: SCREAMING_SNAKE_CASE = BartForConditionalGeneration(_UpperCamelCase ).eval() # an existing summarization ckpt model.model.load_state_dict(_UpperCamelCase ) if hasattr(_UpperCamelCase , 'lm_head' ): SCREAMING_SNAKE_CASE = make_linear_from_emb(model.model.shared ) SCREAMING_SNAKE_CASE = model.model(_UpperCamelCase )[0] # Check results if fairseq_output.shape != new_model_outputs.shape: raise ValueError( f"""`fairseq_output` shape and `new_model_output` shape are different: {fairseq_output.shape=}, {new_model_outputs.shape}""" ) if (fairseq_output != new_model_outputs).any().item(): raise ValueError('Some values in `fairseq_output` are different from `new_model_outputs`' ) Path(_UpperCamelCase ).mkdir(exist_ok=_UpperCamelCase ) model.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "fairseq_path", type=str, help="bart.large, bart.large.cnn or a path to a model.pt on local filesystem." ) parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument( "--hf_config", default=None, type=str, help="Which huggingface architecture to use: bart-large-xsum" ) a_ : Optional[Any] = parser.parse_args() convert_bart_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, hf_checkpoint_name=args.hf_config)
716
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
673
0
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 : Dict , snake_case__ : List[str] , snake_case__ : bool = True , snake_case__ : Dict[str, int] = None , snake_case__ : int = 3_2 , snake_case__ : bool = True , snake_case__ : Union[int, float] = 1 / 2_5_5 , snake_case__ : bool = True , snake_case__ : bool = True , snake_case__ : Optional[Union[float, List[float]]] = [0.48_145_466, 0.4_578_275, 0.40_821_073] , snake_case__ : Optional[Union[float, List[float]]] = [0.26_862_954, 0.26_130_258, 0.27_577_711] , snake_case__ : bool = True , snake_case__ : List[Any]=7 , snake_case__ : Optional[int]=3_0 , snake_case__ : Tuple=4_0_0 , snake_case__ : Any=3 , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = do_resize SCREAMING_SNAKE_CASE = size if size is not None else {'shortest_edge': 2_8_8} SCREAMING_SNAKE_CASE = size_divisor SCREAMING_SNAKE_CASE = do_rescale SCREAMING_SNAKE_CASE = rescale_factor SCREAMING_SNAKE_CASE = do_normalize SCREAMING_SNAKE_CASE = do_center_crop SCREAMING_SNAKE_CASE = image_mean SCREAMING_SNAKE_CASE = image_std SCREAMING_SNAKE_CASE = do_pad SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = min_resolution SCREAMING_SNAKE_CASE = max_resolution def UpperCamelCase ( self : Any ): """simple docstring""" return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, "size_divisor": self.size_divisor, } def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : List[str]=False ): """simple docstring""" if not batched: SCREAMING_SNAKE_CASE = self.size['shortest_edge'] SCREAMING_SNAKE_CASE = image_inputs[0] if isinstance(snake_case__ , Image.Image ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = image.size else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = image.shape[1], image.shape[2] SCREAMING_SNAKE_CASE = size / min(snake_case__ , snake_case__ ) if h < w: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = size, scale * w else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = scale * h, size SCREAMING_SNAKE_CASE = int((1_3_3_3 / 8_0_0) * size ) if max(snake_case__ , snake_case__ ) > max_size: SCREAMING_SNAKE_CASE = max_size / max(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = newh * scale SCREAMING_SNAKE_CASE = neww * scale SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = int(newh + 0.5 ), int(neww + 0.5 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = ( newh // self.size_divisor * self.size_divisor, neww // self.size_divisor * self.size_divisor, ) else: SCREAMING_SNAKE_CASE = [] for image in image_inputs: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) SCREAMING_SNAKE_CASE = max(snake_case__ , key=lambda snake_case__ : item[0] )[0] SCREAMING_SNAKE_CASE = max(snake_case__ , key=lambda snake_case__ : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =BridgeTowerImageProcessor if is_vision_available() else None def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = BridgeTowerImageProcessingTester(self ) @property def UpperCamelCase ( self : str ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case__ , 'image_mean' ) ) self.assertTrue(hasattr(snake_case__ , 'image_std' ) ) self.assertTrue(hasattr(snake_case__ , 'do_normalize' ) ) self.assertTrue(hasattr(snake_case__ , 'do_resize' ) ) self.assertTrue(hasattr(snake_case__ , 'size' ) ) self.assertTrue(hasattr(snake_case__ , 'size_divisor' ) ) def UpperCamelCase ( self : Tuple ): """simple docstring""" pass def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random PIL images SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , Image.Image ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ , numpify=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , np.ndarray ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors SCREAMING_SNAKE_CASE = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case__ , torchify=snake_case__ ) for image in image_inputs: self.assertIsInstance(snake_case__ , torch.Tensor ) # Test not batched input SCREAMING_SNAKE_CASE = image_processing(image_inputs[0] , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched SCREAMING_SNAKE_CASE = image_processing(snake_case__ , return_tensors='pt' ).pixel_values SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.image_processor_tester.get_expected_values(snake_case__ , batched=snake_case__ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , )
717
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
673
0
# DISCLAIMER: This file is strongly influenced by https://github.com/yang-song/score_sde_pytorch import math from typing import Union import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import randn_tensor from .scheduling_utils import SchedulerMixin class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ): __UpperCamelCase =1 @register_to_config def __init__( self : Union[str, Any] , snake_case__ : Any=2_0_0_0 , snake_case__ : Optional[int]=0.1 , snake_case__ : List[Any]=2_0 , snake_case__ : Dict=1E-3 ): """simple docstring""" SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None def UpperCamelCase ( self : Optional[int] , snake_case__ : str , snake_case__ : Union[str, torch.device] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.linspace(1 , self.config.sampling_eps , snake_case__ , device=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : str , snake_case__ : int , snake_case__ : int , snake_case__ : List[Any]=None ): """simple docstring""" if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) # TODO(Patrick) better comments + non-PyTorch # postprocess model score SCREAMING_SNAKE_CASE = ( -0.25 * t**2 * (self.config.beta_max - self.config.beta_min) - 0.5 * t * self.config.beta_min ) SCREAMING_SNAKE_CASE = torch.sqrt(1.0 - torch.exp(2.0 * log_mean_coeff ) ) SCREAMING_SNAKE_CASE = std.flatten() while len(std.shape ) < len(score.shape ): SCREAMING_SNAKE_CASE = std.unsqueeze(-1 ) SCREAMING_SNAKE_CASE = -score / std # compute SCREAMING_SNAKE_CASE = -1.0 / len(self.timesteps ) SCREAMING_SNAKE_CASE = self.config.beta_min + t * (self.config.beta_max - self.config.beta_min) SCREAMING_SNAKE_CASE = beta_t.flatten() while len(beta_t.shape ) < len(x.shape ): SCREAMING_SNAKE_CASE = beta_t.unsqueeze(-1 ) SCREAMING_SNAKE_CASE = -0.5 * beta_t * x SCREAMING_SNAKE_CASE = torch.sqrt(snake_case__ ) SCREAMING_SNAKE_CASE = drift - diffusion**2 * score SCREAMING_SNAKE_CASE = x + drift * dt # add noise SCREAMING_SNAKE_CASE = randn_tensor(x.shape , layout=x.layout , generator=snake_case__ , device=x.device , dtype=x.dtype ) SCREAMING_SNAKE_CASE = x_mean + diffusion * math.sqrt(-dt ) * noise return x, x_mean def __len__( self : Any ): """simple docstring""" return self.config.num_train_timesteps
718
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
673
0
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
719
import heapq import sys import numpy as np a_ : Optional[int] = tuple[int, int] class UpperCamelCase : def __init__( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() def UpperCamelCase ( self : List[Any] ): """simple docstring""" if not self.empty(): return self.elements[0][0] else: return float('inf' ) def UpperCamelCase ( self : List[str] ): """simple docstring""" return len(self.elements ) == 0 def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] ): """simple docstring""" if item not in self.set: heapq.heappush(self.elements , (priority, item) ) self.set.add(snake_case__ ) else: # update # print("update", item) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pri, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) temp.append((priority, item) ) for pro, xxx in temp: heapq.heappush(self.elements , (pro, xxx) ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" if item in self.set: self.set.remove(snake_case__ ) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pro, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) for prito, yyy in temp: heapq.heappush(self.elements , (prito, yyy) ) def UpperCamelCase ( self : str ): """simple docstring""" return self.elements[0][1] def UpperCamelCase ( self : Tuple ): """simple docstring""" ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) self.set.remove(snake_case__ ) return (priority, item) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) return np.linalg.norm(a - b ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Dict: '''simple docstring''' return consistent_heuristic(_UpperCamelCase , _UpperCamelCase ) // t def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[int]: '''simple docstring''' return abs(p[0] - goal[0] ) + abs(p[1] - goal[1] ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : int , _UpperCamelCase : TPos , _UpperCamelCase : dict[TPos, float] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = g_function[start] + Wa * heuristics[i](_UpperCamelCase , _UpperCamelCase ) return ans def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : int , _UpperCamelCase : Tuple ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = np.chararray((n, n) ) for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = '*' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): if (j, (n - 1) - i) in blocks: SCREAMING_SNAKE_CASE = '#' SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = x # print(x) SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[x] SCREAMING_SNAKE_CASE = '-' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): 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:-' ) SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: print(_UpperCamelCase , end=' ' ) SCREAMING_SNAKE_CASE = back_pointer[x] print(_UpperCamelCase ) sys.exit() def __lowerCAmelCase ( _UpperCamelCase : TPos ) -> Any: '''simple docstring''' 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 __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : Tuple , _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Optional[Any] , ) -> List[Any]: '''simple docstring''' for itera in range(_UpperCamelCase ): open_list[itera].remove_element(_UpperCamelCase ) # print("s", s) # print("j", j) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = s SCREAMING_SNAKE_CASE = (x - 1, y) SCREAMING_SNAKE_CASE = (x + 1, y) SCREAMING_SNAKE_CASE = (x, y + 1) SCREAMING_SNAKE_CASE = (x, y - 1) for neighbours in [left, right, up, down]: if neighbours not in blocks: if valid(_UpperCamelCase ) and neighbours not in visited: # print("neighbour", neighbours) visited.add(_UpperCamelCase ) SCREAMING_SNAKE_CASE = -1 SCREAMING_SNAKE_CASE = float('inf' ) if valid(_UpperCamelCase ) and g_function[neighbours] > g_function[s] + 1: SCREAMING_SNAKE_CASE = g_function[s] + 1 SCREAMING_SNAKE_CASE = s if neighbours not in close_list_anchor: open_list[0].put(_UpperCamelCase , key(_UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ) ) if neighbours not in close_list_inad: for var in range(1 , _UpperCamelCase ): if key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) <= Wa * key( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ): open_list[j].put( _UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = [] 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 a_ : str = {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a} a_ : List[str] = [ (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), ] a_ : Union[str, Any] = make_common_ground() a_ : Tuple = blocks_blk # hyper parameters a_ : Any = 1 a_ : List[str] = 1 a_ : Union[str, Any] = 20 a_ : Optional[Any] = 3 # one consistent and two other inconsistent # start and end destination a_ : int = (0, 0) a_ : Optional[int] = (n - 1, n - 1) a_ : Union[str, Any] = 1 def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos , _UpperCamelCase : int ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = {start: 0, goal: float('inf' )} SCREAMING_SNAKE_CASE = {start: -1, goal: -1} SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() for i in range(_UpperCamelCase ): open_list.append(PriorityQueue() ) open_list[i].put(_UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] while open_list[0].minkey() < float('inf' ): for i in range(1 , _UpperCamelCase ): # 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(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = open_list[i].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_inad.append(_UpperCamelCase ) else: if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float('inf' ): do_something(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE = open_list[0].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_anchor.append(_UpperCamelCase ) print('No path found to goal' ) print() for i in range(n - 1 , -1 , -1 ): for j in range(_UpperCamelCase ): 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)
673
0
import darl # noqa import gym import tqdm from diffusers.experimental import ValueGuidedRLPipeline a_ : Any = { "n_samples": 64, "horizon": 32, "num_inference_steps": 20, "n_guide_steps": 2, # can set to 0 for faster sampling, does not use value network "scale_grad_by_std": True, "scale": 0.1, "eta": 0.0, "t_grad_cutoff": 2, "device": "cpu", } if __name__ == "__main__": a_ : str = "hopper-medium-v2" a_ : Tuple = gym.make(env_name) a_ : str = ValueGuidedRLPipeline.from_pretrained( "bglick13/hopper-medium-v2-value-function-hor32", env=env, ) env.seed(0) a_ : int = env.reset() a_ : Dict = 0 a_ : Dict = 0 a_ : int = 1000 a_ : Union[str, Any] = [obs.copy()] try: for t in tqdm.tqdm(range(T)): # call the policy a_ : int = pipeline(obs, planning_horizon=32) # execute action in environment a_ : List[str] = env.step(denorm_actions) a_ : Optional[int] = env.get_normalized_score(total_reward) # update return total_reward += reward total_score += score print( F"""Step: {t}, Reward: {reward}, Total Reward: {total_reward}, Score: {score}, Total Score:""" F""" {total_score}""" ) # save observations for rendering rollout.append(next_observation.copy()) a_ : Dict = next_observation except KeyboardInterrupt: pass print(F"""Total reward: {total_reward}""")
720
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) a_ : Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name a_ : str = "\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to(\"cuda\")\n\n >>> prompt = \"A red cartoon frog, 4k\"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-decoder\", torch_dtype=torch.float16\n ... )\n >>> pipe.to(\"cuda\")\n\n >>> init_image = load_image(\n ... \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n ... \"/kandinsky/frog.png\"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save(\"red_frog.png\")\n ```\n" def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Any , _UpperCamelCase : Any=8 ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 SCREAMING_SNAKE_CASE = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : List[Any]=5_12 , _UpperCamelCase : Union[str, Any]=5_12 ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) SCREAMING_SNAKE_CASE = np.array(pil_image.convert('RGB' ) ) SCREAMING_SNAKE_CASE = arr.astype(np.floataa ) / 1_27.5 - 1 SCREAMING_SNAKE_CASE = np.transpose(_UpperCamelCase , [2, 0, 1] ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).unsqueeze(0 ) return image class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : int , snake_case__ : UNetaDConditionModel , snake_case__ : DDPMScheduler , snake_case__ : VQModel , ): """simple docstring""" super().__init__() self.register_modules( unet=snake_case__ , scheduler=snake_case__ , movq=snake_case__ , ) SCREAMING_SNAKE_CASE = 2 ** (len(self.movq.config.block_out_channels ) - 1) def UpperCamelCase ( self : Any , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = min(int(num_inference_steps * strength ) , snake_case__ ) SCREAMING_SNAKE_CASE = max(num_inference_steps - init_timestep , 0 ) SCREAMING_SNAKE_CASE = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self : List[str] , snake_case__ : Dict , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : str=None ): """simple docstring""" if not isinstance(snake_case__ , (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(snake_case__ )}""" ) SCREAMING_SNAKE_CASE = image.to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = batch_size * num_images_per_prompt if image.shape[1] == 4: SCREAMING_SNAKE_CASE = image else: if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) != batch_size: raise ValueError( F"""You have passed a list of generators of length {len(snake_case__ )}, but requested an effective batch""" F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) elif isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(snake_case__ ) ] SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) else: SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ ).latent_dist.sample(snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.config.scaling_factor * init_latents SCREAMING_SNAKE_CASE = torch.cat([init_latents] , dim=0 ) SCREAMING_SNAKE_CASE = init_latents.shape SCREAMING_SNAKE_CASE = randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ , dtype=snake_case__ ) # get latents SCREAMING_SNAKE_CASE = self.scheduler.add_noise(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = init_latents return latents def UpperCamelCase ( self : int , snake_case__ : List[str]=0 ): """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) SCREAMING_SNAKE_CASE = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int]=0 ): """simple docstring""" if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=snake_case__ ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) SCREAMING_SNAKE_CASE = None for cpu_offloaded_model in [self.unet, self.movq]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cpu_offload_with_hook(snake_case__ , snake_case__ , prev_module_hook=snake_case__ ) # We'll offload the last model manually. SCREAMING_SNAKE_CASE = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self : Dict ): """simple docstring""" if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(snake_case__ , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(snake_case__ ) def __call__( self : str , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]] , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_1_2 , snake_case__ : int = 1_0_0 , snake_case__ : float = 4.0 , snake_case__ : float = 0.3 , snake_case__ : int = 1 , snake_case__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , ): """simple docstring""" SCREAMING_SNAKE_CASE = self._execution_device SCREAMING_SNAKE_CASE = guidance_scale > 1.0 if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = image_embeds.shape[0] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) if do_classifier_free_guidance: SCREAMING_SNAKE_CASE = image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = negative_image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=snake_case__ ) if not isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [image] if not all(isinstance(snake_case__ , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( F"""Input is in incorrect format: {[type(snake_case__ ) for i in image]}. Currently, we only support PIL image and pytorch tensor""" ) SCREAMING_SNAKE_CASE = torch.cat([prepare_image(snake_case__ , snake_case__ , snake_case__ ) for i in image] , dim=0 ) SCREAMING_SNAKE_CASE = image.to(dtype=image_embeds.dtype , device=snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ )['latents'] SCREAMING_SNAKE_CASE = latents.repeat_interleave(snake_case__ , dim=0 ) self.scheduler.set_timesteps(snake_case__ , device=snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_timesteps(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = timesteps[:1].repeat(batch_size * num_images_per_prompt ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = downscale_height_and_width(snake_case__ , snake_case__ , self.movq_scale_factor ) SCREAMING_SNAKE_CASE = self.prepare_latents( snake_case__ , snake_case__ , snake_case__ , snake_case__ , image_embeds.dtype , snake_case__ , snake_case__ ) for i, t in enumerate(self.progress_bar(snake_case__ ) ): # expand the latents if we are doing classifier free guidance SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents SCREAMING_SNAKE_CASE = {'image_embeds': image_embeds} SCREAMING_SNAKE_CASE = self.unet( sample=snake_case__ , timestep=snake_case__ , encoder_hidden_states=snake_case__ , added_cond_kwargs=snake_case__ , return_dict=snake_case__ , )[0] if do_classifier_free_guidance: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.chunk(2 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = variance_pred.chunk(2 ) SCREAMING_SNAKE_CASE = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) SCREAMING_SNAKE_CASE = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 SCREAMING_SNAKE_CASE = self.scheduler.step( snake_case__ , snake_case__ , snake_case__ , generator=snake_case__ , )[0] # post-processing SCREAMING_SNAKE_CASE = self.movq.decode(snake_case__ , force_not_quantize=snake_case__ )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}""" ) if output_type in ["np", "pil"]: SCREAMING_SNAKE_CASE = image * 0.5 + 0.5 SCREAMING_SNAKE_CASE = image.clamp(0 , 1 ) SCREAMING_SNAKE_CASE = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": SCREAMING_SNAKE_CASE = self.numpy_to_pil(snake_case__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case__ )
673
0
def __lowerCAmelCase ( _UpperCamelCase : List[str] ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = sum(_UpperCamelCase ) SCREAMING_SNAKE_CASE = [[False for x in range(s + 1 )] for y in range(n + 1 )] for i in range(1 , n + 1 ): SCREAMING_SNAKE_CASE = True for i in range(1 , s + 1 ): SCREAMING_SNAKE_CASE = False for i in range(1 , n + 1 ): for j in range(1 , s + 1 ): SCREAMING_SNAKE_CASE = dp[i][j - 1] if arr[i - 1] <= j: SCREAMING_SNAKE_CASE = dp[i][j] or dp[i - 1][j - arr[i - 1]] for j in range(int(s / 2 ) , -1 , -1 ): if dp[n][j] is True: SCREAMING_SNAKE_CASE = s - 2 * j break return diff
721
import argparse import numpy as np import torch from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging logging.set_verbosity_info() a_ : List[Any] = logging.get_logger("transformers.models.speecht5") def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Tuple , _UpperCamelCase : Any ) -> Dict: '''simple docstring''' hf_model.apply_weight_norm() SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.bias'] for i in range(len(config.upsample_rates ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.bias"""] for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ): for j in range(len(config.resblock_dilation_sizes ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.bias'] hf_model.remove_weight_norm() @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : Dict , _UpperCamelCase : Tuple , _UpperCamelCase : Any=None , _UpperCamelCase : List[str]=None , ) -> Tuple: '''simple docstring''' if config_path is not None: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig.from_pretrained(_UpperCamelCase ) else: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig() SCREAMING_SNAKE_CASE = SpeechTaHifiGan(_UpperCamelCase ) SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase ) load_weights(orig_checkpoint['model']['generator'] , _UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = np.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = stats[0].reshape(-1 ) SCREAMING_SNAKE_CASE = stats[1].reshape(-1 ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() model.save_pretrained(_UpperCamelCase ) if repo_id: print('Pushing to the hub...' ) model.push_to_hub(_UpperCamelCase ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint") parser.add_argument("--stats_path", required=True, default=None, type=str, help="Path to stats.npy file") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model." ) parser.add_argument( "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub." ) a_ : Tuple = parser.parse_args() convert_hifigan_checkpoint( args.checkpoint_path, args.stats_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )
673
0
import gc import tempfile import unittest import numpy as np import torch from diffusers import VersatileDiffusionPipeline from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device a_ : int = False class UpperCamelCase ( unittest.TestCase ): pass @nightly @require_torch_gpu class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Dict ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' , torch_dtype=torch.floataa ) pipe.to(snake_case__ ) pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' ) SCREAMING_SNAKE_CASE = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = pipe.dual_guided( prompt='first prompt' , image=snake_case__ , text_to_image_strength=0.75 , generator=snake_case__ , guidance_scale=7.5 , num_inference_steps=2 , output_type='numpy' , ).images with tempfile.TemporaryDirectory() as tmpdirname: pipe.save_pretrained(snake_case__ ) SCREAMING_SNAKE_CASE = VersatileDiffusionPipeline.from_pretrained(snake_case__ , torch_dtype=torch.floataa ) pipe.to(snake_case__ ) pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = generator.manual_seed(0 ) SCREAMING_SNAKE_CASE = pipe.dual_guided( prompt='first prompt' , image=snake_case__ , text_to_image_strength=0.75 , generator=snake_case__ , guidance_scale=7.5 , num_inference_steps=2 , output_type='numpy' , ).images assert np.abs(image - new_image ).sum() < 1E-5, "Models don't have the same forward pass" def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' , torch_dtype=torch.floataa ) pipe.to(snake_case__ ) pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'cyberpunk 2077' SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' ) SCREAMING_SNAKE_CASE = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = pipe.dual_guided( prompt=snake_case__ , image=snake_case__ , text_to_image_strength=0.75 , generator=snake_case__ , guidance_scale=7.5 , num_inference_steps=5_0 , output_type='numpy' , ).images SCREAMING_SNAKE_CASE = image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1] assert image.shape == (1, 5_1_2, 5_1_2, 3) SCREAMING_SNAKE_CASE = np.array([0.1_448, 0.1_619, 0.1_741, 0.1_086, 0.1_147, 0.1_128, 0.1_199, 0.1_165, 0.1_001] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 SCREAMING_SNAKE_CASE = 'A painting of a squirrel eating a burger ' SCREAMING_SNAKE_CASE = torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = pipe.text_to_image( prompt=snake_case__ , generator=snake_case__ , guidance_scale=7.5 , num_inference_steps=5_0 , output_type='numpy' ).images SCREAMING_SNAKE_CASE = image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1] assert image.shape == (1, 5_1_2, 5_1_2, 3) SCREAMING_SNAKE_CASE = np.array([0.3_367, 0.3_169, 0.2_656, 0.3_870, 0.4_790, 0.3_796, 0.4_009, 0.4_878, 0.4_778] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1 SCREAMING_SNAKE_CASE = pipe.image_variation(snake_case__ , generator=snake_case__ , output_type='numpy' ).images SCREAMING_SNAKE_CASE = image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1] assert image.shape == (1, 5_1_2, 5_1_2, 3) SCREAMING_SNAKE_CASE = np.array([0.3_076, 0.3_123, 0.3_284, 0.3_782, 0.3_770, 0.3_894, 0.4_297, 0.4_331, 0.4_456] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-1
700
import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer a_ : Optional[int] = logging.get_logger(__name__) a_ : Union[str, Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json", }, "merges_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt", }, "tokenizer_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json", }, } a_ : List[Any] = { "allenai/led-base-16384": 1_6384, } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =LEDTokenizer __UpperCamelCase =["input_ids", "attention_mask"] def __init__( self : Tuple , snake_case__ : List[Any]=None , snake_case__ : List[str]=None , snake_case__ : List[str]=None , snake_case__ : Dict="replace" , snake_case__ : Tuple="<s>" , snake_case__ : Optional[Any]="</s>" , snake_case__ : int="</s>" , snake_case__ : Dict="<s>" , snake_case__ : Union[str, Any]="<unk>" , snake_case__ : Optional[int]="<pad>" , snake_case__ : List[str]="<mask>" , snake_case__ : List[Any]=False , snake_case__ : int=True , **snake_case__ : Dict , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , errors=snake_case__ , bos_token=snake_case__ , eos_token=snake_case__ , sep_token=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , add_prefix_space=snake_case__ , trim_offsets=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = getattr(snake_case__ , pre_tok_state.pop('type' ) ) SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = pre_tok_class(**snake_case__ ) SCREAMING_SNAKE_CASE = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` SCREAMING_SNAKE_CASE = 'post_processor' SCREAMING_SNAKE_CASE = getattr(self.backend_tokenizer , snake_case__ , snake_case__ ) if tokenizer_component_instance: SCREAMING_SNAKE_CASE = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: SCREAMING_SNAKE_CASE = tuple(state['sep'] ) if "cls" in state: SCREAMING_SNAKE_CASE = tuple(state['cls'] ) SCREAMING_SNAKE_CASE = False if state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = True if state.get('trim_offsets' , snake_case__ ) != trim_offsets: SCREAMING_SNAKE_CASE = trim_offsets SCREAMING_SNAKE_CASE = True if changes_to_apply: SCREAMING_SNAKE_CASE = getattr(snake_case__ , state.pop('type' ) ) SCREAMING_SNAKE_CASE = component_class(**snake_case__ ) setattr(self.backend_tokenizer , snake_case__ , snake_case__ ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" if self._mask_token is None: if self.verbose: logger.error('Using mask_token, but it is not set yet.' ) return None return str(self._mask_token ) @mask_token.setter def UpperCamelCase ( self : List[Any] , snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else value SCREAMING_SNAKE_CASE = value def UpperCamelCase ( self : Dict , *snake_case__ : Optional[Any] , **snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._batch_encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : List[str] , *snake_case__ : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : Tuple=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def UpperCamelCase ( self : Optional[int] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def UpperCamelCase ( self : Optional[Any] , snake_case__ : Union[Dict[str, EncodedInput], BatchEncoding] , snake_case__ : Optional[int] = None , snake_case__ : PaddingStrategy = PaddingStrategy.DO_NOT_PAD , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super()._pad( encoded_inputs=snake_case__ , max_length=snake_case__ , padding_strategy=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , ) # Load from model defaults if return_attention_mask is None: SCREAMING_SNAKE_CASE = 'attention_mask' in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: SCREAMING_SNAKE_CASE = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. SCREAMING_SNAKE_CASE = len(encoded_inputs['global_attention_mask'] ) != len(snake_case__ ) if needs_to_be_padded: SCREAMING_SNAKE_CASE = len(snake_case__ ) - len(encoded_inputs['global_attention_mask'] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` SCREAMING_SNAKE_CASE = ( encoded_inputs['global_attention_mask'] + [-1] * difference ) elif self.padding_side == "left": SCREAMING_SNAKE_CASE = [-1] * difference + encoded_inputs[ 'global_attention_mask' ] else: raise ValueError('Invalid padding strategy:' + str(self.padding_side ) ) return encoded_inputs
673
0
'''simple docstring''' import argparse import json from pathlib import Path import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel from transformers.utils import logging logging.set_verbosity_info() a_ : Any = logging.get_logger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Any , _UpperCamelCase : List[str]=False ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f"""blocks.{i}.norm1.weight""", f"""vit.encoder.layer.{i}.layernorm_before.weight""") ) rename_keys.append((f"""blocks.{i}.norm1.bias""", f"""vit.encoder.layer.{i}.layernorm_before.bias""") ) rename_keys.append((f"""blocks.{i}.attn.proj.weight""", f"""vit.encoder.layer.{i}.attention.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.attn.proj.bias""", f"""vit.encoder.layer.{i}.attention.output.dense.bias""") ) rename_keys.append((f"""blocks.{i}.norm2.weight""", f"""vit.encoder.layer.{i}.layernorm_after.weight""") ) rename_keys.append((f"""blocks.{i}.norm2.bias""", f"""vit.encoder.layer.{i}.layernorm_after.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.weight""", f"""vit.encoder.layer.{i}.intermediate.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.bias""", f"""vit.encoder.layer.{i}.intermediate.dense.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.weight""", f"""vit.encoder.layer.{i}.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.bias""", f"""vit.encoder.layer.{i}.output.dense.bias""") ) # projection layer + position embeddings rename_keys.extend( [ ('cls_token', 'vit.embeddings.cls_token'), ('patch_embed.proj.weight', 'vit.embeddings.patch_embeddings.projection.weight'), ('patch_embed.proj.bias', 'vit.embeddings.patch_embeddings.projection.bias'), ('pos_embed', 'vit.embeddings.position_embeddings'), ] ) if base_model: # layernorm + pooler rename_keys.extend( [ ('norm.weight', 'layernorm.weight'), ('norm.bias', 'layernorm.bias'), ('pre_logits.fc.weight', 'pooler.dense.weight'), ('pre_logits.fc.bias', 'pooler.dense.bias'), ] ) # if just the base model, we should remove "vit" from all keys that start with "vit" SCREAMING_SNAKE_CASE = [(pair[0], pair[1][4:]) if pair[1].startswith('vit' ) else pair for pair in rename_keys] else: # layernorm + classification head rename_keys.extend( [ ('norm.weight', 'vit.layernorm.weight'), ('norm.bias', 'vit.layernorm.bias'), ('head.weight', 'classifier.weight'), ('head.bias', 'classifier.bias'), ] ) return rename_keys def __lowerCAmelCase ( _UpperCamelCase : Any , _UpperCamelCase : Dict , _UpperCamelCase : str=False ) -> Optional[int]: '''simple docstring''' for i in range(config.num_hidden_layers ): if base_model: SCREAMING_SNAKE_CASE = '' else: SCREAMING_SNAKE_CASE = 'vit.' # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) SCREAMING_SNAKE_CASE = state_dict.pop(f"""blocks.{i}.attn.qkv.weight""" ) SCREAMING_SNAKE_CASE = state_dict.pop(f"""blocks.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE = in_proj_weight[ : config.hidden_size, : ] SCREAMING_SNAKE_CASE = in_proj_bias[: config.hidden_size] SCREAMING_SNAKE_CASE = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] SCREAMING_SNAKE_CASE = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] SCREAMING_SNAKE_CASE = in_proj_weight[ -config.hidden_size :, : ] SCREAMING_SNAKE_CASE = in_proj_bias[-config.hidden_size :] def __lowerCAmelCase ( _UpperCamelCase : Tuple ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = ['head.weight', 'head.bias'] for k in ignore_keys: state_dict.pop(_UpperCamelCase , _UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = dct.pop(_UpperCamelCase ) SCREAMING_SNAKE_CASE = val def __lowerCAmelCase ( ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = 'http://images.cocodataset.org/val2017/000000039769.jpg' SCREAMING_SNAKE_CASE = Image.open(requests.get(_UpperCamelCase , stream=_UpperCamelCase ).raw ) return im @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : Union[str, Any] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = ViTConfig() SCREAMING_SNAKE_CASE = False # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size if vit_name[-5:] == "in21k": SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = int(vit_name[-12:-10] ) SCREAMING_SNAKE_CASE = int(vit_name[-9:-6] ) else: SCREAMING_SNAKE_CASE = 10_00 SCREAMING_SNAKE_CASE = 'huggingface/label-files' SCREAMING_SNAKE_CASE = 'imagenet-1k-id2label.json' SCREAMING_SNAKE_CASE = json.load(open(hf_hub_download(_UpperCamelCase , _UpperCamelCase , repo_type='dataset' ) , 'r' ) ) SCREAMING_SNAKE_CASE = {int(_UpperCamelCase ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = idalabel SCREAMING_SNAKE_CASE = {v: k for k, v in idalabel.items()} SCREAMING_SNAKE_CASE = int(vit_name[-6:-4] ) SCREAMING_SNAKE_CASE = int(vit_name[-3:] ) # size of the architecture if "deit" in vit_name: if vit_name[9:].startswith('tiny' ): SCREAMING_SNAKE_CASE = 1_92 SCREAMING_SNAKE_CASE = 7_68 SCREAMING_SNAKE_CASE = 12 SCREAMING_SNAKE_CASE = 3 elif vit_name[9:].startswith('small' ): SCREAMING_SNAKE_CASE = 3_84 SCREAMING_SNAKE_CASE = 15_36 SCREAMING_SNAKE_CASE = 12 SCREAMING_SNAKE_CASE = 6 else: pass else: if vit_name[4:].startswith('small' ): SCREAMING_SNAKE_CASE = 7_68 SCREAMING_SNAKE_CASE = 23_04 SCREAMING_SNAKE_CASE = 8 SCREAMING_SNAKE_CASE = 8 elif vit_name[4:].startswith('base' ): pass elif vit_name[4:].startswith('large' ): SCREAMING_SNAKE_CASE = 10_24 SCREAMING_SNAKE_CASE = 40_96 SCREAMING_SNAKE_CASE = 24 SCREAMING_SNAKE_CASE = 16 elif vit_name[4:].startswith('huge' ): SCREAMING_SNAKE_CASE = 12_80 SCREAMING_SNAKE_CASE = 51_20 SCREAMING_SNAKE_CASE = 32 SCREAMING_SNAKE_CASE = 16 # load original model from timm SCREAMING_SNAKE_CASE = timm.create_model(_UpperCamelCase , pretrained=_UpperCamelCase ) timm_model.eval() # load state_dict of original model, remove and rename some keys SCREAMING_SNAKE_CASE = timm_model.state_dict() if base_model: remove_classification_head_(_UpperCamelCase ) SCREAMING_SNAKE_CASE = create_rename_keys(_UpperCamelCase , _UpperCamelCase ) for src, dest in rename_keys: rename_key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) read_in_q_k_v(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # load HuggingFace model if vit_name[-5:] == "in21k": SCREAMING_SNAKE_CASE = ViTModel(_UpperCamelCase ).eval() else: SCREAMING_SNAKE_CASE = ViTForImageClassification(_UpperCamelCase ).eval() model.load_state_dict(_UpperCamelCase ) # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor if "deit" in vit_name: SCREAMING_SNAKE_CASE = DeiTImageProcessor(size=config.image_size ) else: SCREAMING_SNAKE_CASE = ViTImageProcessor(size=config.image_size ) SCREAMING_SNAKE_CASE = image_processor(images=prepare_img() , return_tensors='pt' ) SCREAMING_SNAKE_CASE = encoding['pixel_values'] SCREAMING_SNAKE_CASE = model(_UpperCamelCase ) if base_model: SCREAMING_SNAKE_CASE = timm_model.forward_features(_UpperCamelCase ) assert timm_pooled_output.shape == outputs.pooler_output.shape assert torch.allclose(_UpperCamelCase , outputs.pooler_output , atol=1e-3 ) else: SCREAMING_SNAKE_CASE = timm_model(_UpperCamelCase ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(_UpperCamelCase , outputs.logits , atol=1e-3 ) Path(_UpperCamelCase ).mkdir(exist_ok=_UpperCamelCase ) print(f"""Saving model {vit_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(_UpperCamelCase ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( "--vit_name", default="vit_base_patch16_224", type=str, help="Name of the ViT timm model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory." ) a_ : Union[str, Any] = parser.parse_args() convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)
701
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def __lowerCAmelCase ( *_UpperCamelCase : Optional[Any] ) -> Optional[int]: '''simple docstring''' with open(_UpperCamelCase , 'r' ) as fh: fcntl.flock(_UpperCamelCase , fcntl.LOCK_EX ) try: print(*_UpperCamelCase ) finally: fcntl.flock(_UpperCamelCase , fcntl.LOCK_UN ) a_ : int = int(os.environ["LOCAL_RANK"]) torch.cuda.set_device(local_rank) a_ : str = torch.device("cuda", local_rank) a_ : Optional[int] = socket.gethostname() a_ : Union[str, Any] = F"""[{hostname}-{local_rank}]""" try: # test distributed dist.init_process_group("nccl") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank a_ : Dict = dist.get_rank() a_ : Any = dist.get_world_size() printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""") dist.barrier() if rank == 0: printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""") except Exception: printflock(F"""{gpu} is broken""") raise
673
0
from __future__ import annotations def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : List[Any] , _UpperCamelCase : Dict , _UpperCamelCase : str ) -> Union[str, Any]: # noqa: E741 '''simple docstring''' while r - l > 1: SCREAMING_SNAKE_CASE = (l + r) // 2 if v[m] >= key: SCREAMING_SNAKE_CASE = m else: SCREAMING_SNAKE_CASE = m # noqa: E741 return r def __lowerCAmelCase ( _UpperCamelCase : list[int] ) -> int: '''simple docstring''' if len(_UpperCamelCase ) == 0: return 0 SCREAMING_SNAKE_CASE = [0] * len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = v[0] for i in range(1 , len(_UpperCamelCase ) ): if v[i] < tail[0]: SCREAMING_SNAKE_CASE = v[i] elif v[i] > tail[length - 1]: SCREAMING_SNAKE_CASE = v[i] length += 1 else: SCREAMING_SNAKE_CASE = v[i] return length if __name__ == "__main__": import doctest doctest.testmod()
702
from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_herbert import HerbertTokenizer a_ : Optional[Any] = logging.get_logger(__name__) a_ : Optional[Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json" }, "merges_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt" }, } a_ : Union[str, Any] = {"allegro/herbert-base-cased": 514} a_ : List[Any] = {} class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_INIT_CONFIGURATION __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =HerbertTokenizer def __init__( self : Tuple , snake_case__ : Optional[Any]=None , snake_case__ : int=None , snake_case__ : Optional[int]=None , snake_case__ : str="<s>" , snake_case__ : Tuple="<unk>" , snake_case__ : List[str]="<pad>" , snake_case__ : Tuple="<mask>" , snake_case__ : Dict="</s>" , **snake_case__ : List[str] , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , sep_token=snake_case__ , **snake_case__ , ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.cls_token_id] SCREAMING_SNAKE_CASE = [self.sep_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 UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ): """simple docstring""" if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ ) if token_ids_a is None: return [1] + ([0] * len(snake_case__ )) + [1] return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1] def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def UpperCamelCase ( self : Tuple , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ )
673
0
import os def __lowerCAmelCase ( ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = os.path.dirname(os.path.realpath(_UpperCamelCase ) ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'triangle.txt' ) with open(_UpperCamelCase ) as f: SCREAMING_SNAKE_CASE = f.readlines() SCREAMING_SNAKE_CASE = [] for line in triangle: SCREAMING_SNAKE_CASE = [] for number in line.strip().split(' ' ): numbers_from_line.append(int(_UpperCamelCase ) ) a.append(_UpperCamelCase ) for i in range(1 , len(_UpperCamelCase ) ): for j in range(len(a[i] ) ): SCREAMING_SNAKE_CASE = a[i - 1][j] if j != len(a[i - 1] ) else 0 SCREAMING_SNAKE_CASE = a[i - 1][j - 1] if j > 0 else 0 a[i][j] += max(_UpperCamelCase , _UpperCamelCase ) return max(a[-1] ) if __name__ == "__main__": print(solution())
703
def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 while n > 0: res += n % 10 n //= 10 return res def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) return n if n < 10 else n % 10 + sum_of_digits(n // 10 ) def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' return sum(int(_UpperCamelCase ) for c in str(abs(_UpperCamelCase ) ) ) def __lowerCAmelCase ( ) -> None: '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(_UpperCamelCase : Callable , _UpperCamelCase : int ) -> None: SCREAMING_SNAKE_CASE = f"""{func.__name__}({value})""" SCREAMING_SNAKE_CASE = timeit(f"""__main__.{call}""" , setup='import __main__' ) print(f"""{call:56} = {func(_UpperCamelCase )} -- {timing:.4f} seconds""" ) for value in (26_21_44, 11_25_89_99_06_84_26_24, 1_26_76_50_60_02_28_22_94_01_49_67_03_20_53_76): for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact): benchmark_a_function(_UpperCamelCase , _UpperCamelCase ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
673
0
import json import logging import os import re import sys from dataclasses import dataclass, field from typing import Any, Dict, List, Optional, Union import datasets import numpy as np import torch import torchaudio from packaging import version from torch import nn import transformers from transformers import ( HfArgumentParser, Trainer, TrainingArguments, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaForCTC, WavaVecaProcessor, is_apex_available, set_seed, ) from transformers.trainer_utils import get_last_checkpoint, is_main_process if is_apex_available(): from apex import amp if version.parse(version.parse(torch.__version__).base_version) >= version.parse("1.6"): a_ : Tuple = True from torch.cuda.amp import autocast a_ : int = logging.getLogger(__name__) def __lowerCAmelCase ( _UpperCamelCase : Optional[Any]=None , _UpperCamelCase : int=None ) -> str: '''simple docstring''' return field(default_factory=lambda: default , metadata=_UpperCamelCase ) @dataclass class UpperCamelCase : __UpperCamelCase =field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Whether to freeze the feature extractor layers of the model."} ) __UpperCamelCase =field( default=0.1 , metadata={"help": "The dropout ratio for the attention probabilities."} ) __UpperCamelCase =field( default=0.1 , metadata={"help": "The dropout ratio for activations inside the fully connected layer."} ) __UpperCamelCase =field( default=0.1 , metadata={ "help": "The dropout probabilitiy for all fully connected layers in the embeddings, encoder, and pooler." } , ) __UpperCamelCase =field( default=0.1 , metadata={"help": "The dropout probabilitiy for all 1D convolutional layers in feature extractor."} , ) __UpperCamelCase =field( default=0.05 , metadata={ "help": ( "Propability of each feature vector along the time axis to be chosen as the start of the vector" "span to be masked. Approximately ``mask_time_prob * sequence_length // mask_time_length`` feature" "vectors will be masked along the time axis. This is only relevant if ``apply_spec_augment is True``." ) } , ) __UpperCamelCase =field(default=0.0 , metadata={"help": "The LayerDrop probability."} ) @dataclass class UpperCamelCase : __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} ) __UpperCamelCase =field( default="train+validation" , metadata={ "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'" } , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Overwrite the cached preprocessed datasets or not."} ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "The number of processes to use for the preprocessing."} , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of training examples to this " "value if set." ) } , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of validation examples to this " "value if set." ) } , ) __UpperCamelCase =list_field( default=[",", "?", ".", "!", "-", ";", ":", "\"\"", "%", "'", "\"", "�"] , metadata={"help": "A list of characters to remove from the transcripts."} , ) @dataclass class UpperCamelCase : __UpperCamelCase =42 __UpperCamelCase =True __UpperCamelCase =None __UpperCamelCase =None __UpperCamelCase =None __UpperCamelCase =None def __call__( self : Optional[Any] , snake_case__ : List[Dict[str, Union[List[int], torch.Tensor]]] ): """simple docstring""" SCREAMING_SNAKE_CASE = [{'input_values': feature['input_values']} for feature in features] SCREAMING_SNAKE_CASE = [{'input_ids': feature['labels']} for feature in features] SCREAMING_SNAKE_CASE = self.processor.pad( snake_case__ , padding=self.padding , max_length=self.max_length , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = self.processor.pad( labels=snake_case__ , padding=self.padding , max_length=self.max_length_labels , pad_to_multiple_of=self.pad_to_multiple_of_labels , return_tensors='pt' , ) # replace padding with -100 to ignore loss correctly SCREAMING_SNAKE_CASE = labels_batch['input_ids'].masked_fill(labels_batch.attention_mask.ne(1 ) , -1_0_0 ) SCREAMING_SNAKE_CASE = labels return batch class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def UpperCamelCase ( self : List[str] , snake_case__ : nn.Module , snake_case__ : Dict[str, Union[torch.Tensor, Any]] ): """simple docstring""" model.train() SCREAMING_SNAKE_CASE = self._prepare_inputs(snake_case__ ) if self.use_amp: with autocast(): SCREAMING_SNAKE_CASE = self.compute_loss(snake_case__ , snake_case__ ) else: SCREAMING_SNAKE_CASE = self.compute_loss(snake_case__ , snake_case__ ) if self.args.n_gpu > 1: if model.module.config.ctc_loss_reduction == "mean": SCREAMING_SNAKE_CASE = loss.mean() elif model.module.config.ctc_loss_reduction == "sum": SCREAMING_SNAKE_CASE = loss.sum() / (inputs['labels'] >= 0).sum() else: raise ValueError(F"""{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']""" ) if self.args.gradient_accumulation_steps > 1: SCREAMING_SNAKE_CASE = loss / self.args.gradient_accumulation_steps if self.use_amp: self.scaler.scale(snake_case__ ).backward() elif self.use_apex: with amp.scale_loss(snake_case__ , self.optimizer ) as scaled_loss: scaled_loss.backward() elif self.deepspeed: self.deepspeed.backward(snake_case__ ) else: loss.backward() return loss.detach() def __lowerCAmelCase ( ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('.json' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = parser.parse_args_into_dataclasses() # Detecting last checkpoint. SCREAMING_SNAKE_CASE = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: SCREAMING_SNAKE_CASE = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f"""Output directory ({training_args.output_dir}) already exists and is not empty. """ 'Use --overwrite_output_dir to overcome.' ) elif last_checkpoint is not None: logger.info( f"""Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change """ 'the `--output_dir` or add `--overwrite_output_dir` to train from scratch.' ) # Setup logging logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) logger.setLevel(logging.INFO if is_main_process(training_args.local_rank ) else logging.WARN ) # Log on each process the small summary: logger.warning( f"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}""" + f"""distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}""" ) # 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() logger.info('Training/evaluation parameters %s' , _UpperCamelCase ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: SCREAMING_SNAKE_CASE = datasets.load_dataset( 'common_voice' , data_args.dataset_config_name , split=data_args.train_split_name ) SCREAMING_SNAKE_CASE = datasets.load_dataset('common_voice' , data_args.dataset_config_name , split='test' ) # Create and save tokenizer SCREAMING_SNAKE_CASE = f"""[{''.join(data_args.chars_to_ignore )}]""" def remove_special_characters(_UpperCamelCase : Any ): SCREAMING_SNAKE_CASE = re.sub(_UpperCamelCase , '' , batch['sentence'] ).lower() + ' ' return batch SCREAMING_SNAKE_CASE = train_dataset.map(_UpperCamelCase , remove_columns=['sentence'] ) SCREAMING_SNAKE_CASE = eval_dataset.map(_UpperCamelCase , remove_columns=['sentence'] ) def extract_all_chars(_UpperCamelCase : List[Any] ): SCREAMING_SNAKE_CASE = ' '.join(batch['text'] ) SCREAMING_SNAKE_CASE = list(set(_UpperCamelCase ) ) return {"vocab": [vocab], "all_text": [all_text]} SCREAMING_SNAKE_CASE = train_dataset.map( _UpperCamelCase , batched=_UpperCamelCase , batch_size=-1 , keep_in_memory=_UpperCamelCase , remove_columns=train_dataset.column_names , ) SCREAMING_SNAKE_CASE = train_dataset.map( _UpperCamelCase , batched=_UpperCamelCase , batch_size=-1 , keep_in_memory=_UpperCamelCase , remove_columns=eval_dataset.column_names , ) SCREAMING_SNAKE_CASE = list(set(vocab_train['vocab'][0] ) | set(vocab_test['vocab'][0] ) ) SCREAMING_SNAKE_CASE = {v: k for k, v in enumerate(_UpperCamelCase )} SCREAMING_SNAKE_CASE = vocab_dict[' '] del vocab_dict[" "] SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) with open('vocab.json' , 'w' ) as vocab_file: json.dump(_UpperCamelCase , _UpperCamelCase ) # Load pretrained model and tokenizer # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. SCREAMING_SNAKE_CASE = WavaVecaCTCTokenizer( 'vocab.json' , unk_token='[UNK]' , pad_token='[PAD]' , word_delimiter_token='|' , ) SCREAMING_SNAKE_CASE = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=1_60_00 , padding_value=0.0 , do_normalize=_UpperCamelCase , return_attention_mask=_UpperCamelCase ) SCREAMING_SNAKE_CASE = WavaVecaProcessor(feature_extractor=_UpperCamelCase , tokenizer=_UpperCamelCase ) SCREAMING_SNAKE_CASE = WavaVecaForCTC.from_pretrained( model_args.model_name_or_path , cache_dir=model_args.cache_dir , activation_dropout=model_args.activation_dropout , attention_dropout=model_args.attention_dropout , hidden_dropout=model_args.hidden_dropout , feat_proj_dropout=model_args.feat_proj_dropout , mask_time_prob=model_args.mask_time_prob , gradient_checkpointing=training_args.gradient_checkpointing , layerdrop=model_args.layerdrop , ctc_loss_reduction='mean' , pad_token_id=processor.tokenizer.pad_token_id , vocab_size=len(processor.tokenizer ) , ) if data_args.max_train_samples is not None: SCREAMING_SNAKE_CASE = min(len(_UpperCamelCase ) , data_args.max_train_samples ) SCREAMING_SNAKE_CASE = train_dataset.select(range(_UpperCamelCase ) ) if data_args.max_val_samples is not None: SCREAMING_SNAKE_CASE = eval_dataset.select(range(data_args.max_val_samples ) ) SCREAMING_SNAKE_CASE = torchaudio.transforms.Resample(4_80_00 , 1_60_00 ) # Preprocessing the datasets. # We need to read the aduio files as arrays and tokenize the targets. def speech_file_to_array_fn(_UpperCamelCase : Union[str, Any] ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = torchaudio.load(batch['path'] ) SCREAMING_SNAKE_CASE = resampler(_UpperCamelCase ).squeeze().numpy() SCREAMING_SNAKE_CASE = 1_60_00 SCREAMING_SNAKE_CASE = batch['text'] return batch SCREAMING_SNAKE_CASE = train_dataset.map( _UpperCamelCase , remove_columns=train_dataset.column_names , num_proc=data_args.preprocessing_num_workers , ) SCREAMING_SNAKE_CASE = eval_dataset.map( _UpperCamelCase , remove_columns=eval_dataset.column_names , num_proc=data_args.preprocessing_num_workers , ) def prepare_dataset(_UpperCamelCase : Union[str, Any] ): # check that all files have the correct sampling rate assert ( len(set(batch['sampling_rate'] ) ) == 1 ), f"""Make sure all inputs have the same sampling rate of {processor.feature_extractor.sampling_rate}.""" SCREAMING_SNAKE_CASE = processor( audio=batch['speech'] , text=batch['target_text'] , sampling_rate=batch['sampling_rate'][0] ) batch.update(_UpperCamelCase ) return batch SCREAMING_SNAKE_CASE = train_dataset.map( _UpperCamelCase , remove_columns=train_dataset.column_names , batch_size=training_args.per_device_train_batch_size , batched=_UpperCamelCase , num_proc=data_args.preprocessing_num_workers , ) SCREAMING_SNAKE_CASE = eval_dataset.map( _UpperCamelCase , remove_columns=eval_dataset.column_names , batch_size=training_args.per_device_train_batch_size , batched=_UpperCamelCase , num_proc=data_args.preprocessing_num_workers , ) # Metric SCREAMING_SNAKE_CASE = datasets.load_metric('wer' ) def compute_metrics(_UpperCamelCase : Dict ): SCREAMING_SNAKE_CASE = pred.predictions SCREAMING_SNAKE_CASE = np.argmax(_UpperCamelCase , axis=-1 ) SCREAMING_SNAKE_CASE = processor.tokenizer.pad_token_id SCREAMING_SNAKE_CASE = processor.batch_decode(_UpperCamelCase ) # we do not want to group tokens when computing the metrics SCREAMING_SNAKE_CASE = processor.batch_decode(pred.label_ids , group_tokens=_UpperCamelCase ) SCREAMING_SNAKE_CASE = wer_metric.compute(predictions=_UpperCamelCase , references=_UpperCamelCase ) return {"wer": wer} if model_args.freeze_feature_extractor: model.freeze_feature_extractor() # Data collator SCREAMING_SNAKE_CASE = DataCollatorCTCWithPadding(processor=_UpperCamelCase , padding=_UpperCamelCase ) # Initialize our Trainer SCREAMING_SNAKE_CASE = CTCTrainer( model=_UpperCamelCase , data_collator=_UpperCamelCase , args=_UpperCamelCase , compute_metrics=_UpperCamelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , tokenizer=processor.feature_extractor , ) # Training if training_args.do_train: if last_checkpoint is not None: SCREAMING_SNAKE_CASE = last_checkpoint elif os.path.isdir(model_args.model_name_or_path ): SCREAMING_SNAKE_CASE = model_args.model_name_or_path else: SCREAMING_SNAKE_CASE = None # Save the feature_extractor and the tokenizer if is_main_process(training_args.local_rank ): processor.save_pretrained(training_args.output_dir ) SCREAMING_SNAKE_CASE = trainer.train(resume_from_checkpoint=_UpperCamelCase ) trainer.save_model() SCREAMING_SNAKE_CASE = train_result.metrics SCREAMING_SNAKE_CASE = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(_UpperCamelCase ) ) SCREAMING_SNAKE_CASE = min(_UpperCamelCase , len(_UpperCamelCase ) ) trainer.log_metrics('train' , _UpperCamelCase ) trainer.save_metrics('train' , _UpperCamelCase ) trainer.save_state() # Evaluation SCREAMING_SNAKE_CASE = {} if training_args.do_eval: logger.info('*** Evaluate ***' ) SCREAMING_SNAKE_CASE = trainer.evaluate() SCREAMING_SNAKE_CASE = data_args.max_val_samples if data_args.max_val_samples is not None else len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = min(_UpperCamelCase , len(_UpperCamelCase ) ) trainer.log_metrics('eval' , _UpperCamelCase ) trainer.save_metrics('eval' , _UpperCamelCase ) return results if __name__ == "__main__": main()
704
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
673
0
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
705
import gc import unittest import numpy as np import torch import torch.nn.functional as F from transformers import ( ClapTextConfig, ClapTextModelWithProjection, RobertaTokenizer, SpeechTaHifiGan, SpeechTaHifiGanConfig, ) from diffusers import ( AudioLDMPipeline, AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.utils import is_xformers_available, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =AudioLDMPipeline __UpperCamelCase =TEXT_TO_AUDIO_PARAMS __UpperCamelCase =TEXT_TO_AUDIO_BATCH_PARAMS __UpperCamelCase =frozenset( [ "num_inference_steps", "num_waveforms_per_prompt", "generator", "latents", "output_type", "return_dict", "callback", "callback_steps", ] ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=(3_2, 6_4) , class_embed_type='simple_projection' , projection_class_embeddings_input_dim=3_2 , class_embeddings_concat=snake_case__ , ) SCREAMING_SNAKE_CASE = DDIMScheduler( beta_start=0.00_085 , beta_end=0.012 , beta_schedule='scaled_linear' , clip_sample=snake_case__ , set_alpha_to_one=snake_case__ , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=1 , out_channels=1 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = ClapTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , projection_dim=3_2 , ) SCREAMING_SNAKE_CASE = ClapTextModelWithProjection(snake_case__ ) SCREAMING_SNAKE_CASE = RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta' , model_max_length=7_7 ) SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig( model_in_dim=8 , sampling_rate=1_6_0_0_0 , upsample_initial_channel=1_6 , upsample_rates=[2, 2] , upsample_kernel_sizes=[4, 4] , resblock_kernel_sizes=[3, 7] , resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]] , normalize_before=snake_case__ , ) SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ) SCREAMING_SNAKE_CASE = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'vocoder': vocoder, } return components def UpperCamelCase ( self : Optional[int] , snake_case__ : int , snake_case__ : int=0 ): """simple docstring""" if str(snake_case__ ).startswith('mps' ): SCREAMING_SNAKE_CASE = torch.manual_seed(snake_case__ ) else: SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, } return inputs def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = prompt_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) SCREAMING_SNAKE_CASE = prompt_embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * ['this is a negative prompt'] SCREAMING_SNAKE_CASE = negative_prompt SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = [] for p in [prompt, negative_prompt]: SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = text_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) embeds.append(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 'egg cracking' SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ , negative_prompt=snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A hammer hitting a wooden surface' # test num_waveforms_per_prompt=1 (default) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 ).audios assert audios.shape == (1, 2_5_6) # test num_waveforms_per_prompt=1 (default) for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe([prompt] * batch_size , num_inference_steps=2 ).audios assert audios.shape == (batch_size, 2_5_6) # test num_waveforms_per_prompt for single prompt SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (num_waveforms_per_prompt, 2_5_6) # test num_waveforms_per_prompt for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe( [prompt] * batch_size , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config.sampling_rate SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.016 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.016 SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.032 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.032 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = ['hey'] SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape assert audio_shape == (1, 2_5_6) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config config.model_in_dim *= 2 SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ).to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram assert audio_shape == (1, 2_5_6) def UpperCamelCase ( self : Tuple ): """simple docstring""" self._test_attention_slicing_forward_pass(test_mean_pixel_difference=snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" self._test_inference_batch_single_identical(test_mean_pixel_difference=snake_case__ ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def UpperCamelCase ( self : Dict ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case__ ) @slow class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : Tuple="cpu" , snake_case__ : List[str]=torch.floataa , snake_case__ : Optional[Any]=0 ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = np.random.RandomState(snake_case__ ).standard_normal((1, 8, 1_2_8, 1_6) ) SCREAMING_SNAKE_CASE = torch.from_numpy(snake_case__ ).to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'latents': latents, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 2.5, } return inputs def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 2_5 SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[7_7_2_3_0:7_7_2_4_0] SCREAMING_SNAKE_CASE = np.array( [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 1E-2 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[2_7_7_8_0:2_7_7_9_0] SCREAMING_SNAKE_CASE = np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 3E-2
673
0
import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import ( AutoProcessor, BertTokenizerFast, BlipImageProcessor, GPTaTokenizer, InstructBlipProcessor, PreTrainedTokenizerFast, ) @require_vision class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = tempfile.mkdtemp() SCREAMING_SNAKE_CASE = BlipImageProcessor() SCREAMING_SNAKE_CASE = GPTaTokenizer.from_pretrained('hf-internal-testing/tiny-random-GPT2Model' ) SCREAMING_SNAKE_CASE = BertTokenizerFast.from_pretrained('hf-internal-testing/tiny-random-bert' ) SCREAMING_SNAKE_CASE = InstructBlipProcessor(snake_case__ , snake_case__ , snake_case__ ) processor.save_pretrained(self.tmpdirname ) def UpperCamelCase ( self : Dict , **snake_case__ : Optional[Any] ): """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case__ ).tokenizer def UpperCamelCase ( self : Dict , **snake_case__ : int ): """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case__ ).image_processor def UpperCamelCase ( self : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case__ ).qformer_tokenizer def UpperCamelCase ( self : Optional[int] ): """simple docstring""" shutil.rmtree(self.tmpdirname ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] SCREAMING_SNAKE_CASE = [Image.fromarray(np.moveaxis(snake_case__ , 0 , -1 ) ) for x in image_inputs] return image_inputs def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() , qformer_tokenizer=self.get_qformer_tokenizer() , ) processor.save_pretrained(self.tmpdirname ) SCREAMING_SNAKE_CASE = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)' ) SCREAMING_SNAKE_CASE = self.get_image_processor(do_normalize=snake_case__ , padding_value=1.0 ) SCREAMING_SNAKE_CASE = InstructBlipProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=snake_case__ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , snake_case__ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , snake_case__ ) self.assertIsInstance(processor.qformer_tokenizer , snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_image_processor() SCREAMING_SNAKE_CASE = self.get_tokenizer() SCREAMING_SNAKE_CASE = self.get_qformer_tokenizer() SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=snake_case__ , image_processor=snake_case__ , qformer_tokenizer=snake_case__ ) SCREAMING_SNAKE_CASE = self.prepare_image_inputs() SCREAMING_SNAKE_CASE = image_processor(snake_case__ , return_tensors='np' ) SCREAMING_SNAKE_CASE = processor(images=snake_case__ , return_tensors='np' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_image_processor() SCREAMING_SNAKE_CASE = self.get_tokenizer() SCREAMING_SNAKE_CASE = self.get_qformer_tokenizer() SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=snake_case__ , image_processor=snake_case__ , qformer_tokenizer=snake_case__ ) SCREAMING_SNAKE_CASE = 'lower newer' SCREAMING_SNAKE_CASE = processor(text=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = qformer_tokenizer(snake_case__ , return_token_type_ids=snake_case__ ) 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 UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_image_processor() SCREAMING_SNAKE_CASE = self.get_tokenizer() SCREAMING_SNAKE_CASE = self.get_qformer_tokenizer() SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=snake_case__ , image_processor=snake_case__ , qformer_tokenizer=snake_case__ ) SCREAMING_SNAKE_CASE = 'lower newer' SCREAMING_SNAKE_CASE = self.prepare_image_inputs() SCREAMING_SNAKE_CASE = processor(text=snake_case__ , images=snake_case__ ) 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(snake_case__ ): processor() def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_image_processor() SCREAMING_SNAKE_CASE = self.get_tokenizer() SCREAMING_SNAKE_CASE = self.get_qformer_tokenizer() SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=snake_case__ , image_processor=snake_case__ , qformer_tokenizer=snake_case__ ) SCREAMING_SNAKE_CASE = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] SCREAMING_SNAKE_CASE = processor.batch_decode(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.batch_decode(snake_case__ ) self.assertListEqual(snake_case__ , snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_image_processor() SCREAMING_SNAKE_CASE = self.get_tokenizer() SCREAMING_SNAKE_CASE = self.get_qformer_tokenizer() SCREAMING_SNAKE_CASE = InstructBlipProcessor( tokenizer=snake_case__ , image_processor=snake_case__ , qformer_tokenizer=snake_case__ ) SCREAMING_SNAKE_CASE = 'lower newer' SCREAMING_SNAKE_CASE = self.prepare_image_inputs() SCREAMING_SNAKE_CASE = processor(text=snake_case__ , images=snake_case__ ) self.assertListEqual( list(inputs.keys() ) , ['input_ids', 'attention_mask', 'qformer_input_ids', 'qformer_attention_mask', 'pixel_values'] , )
706
import unittest from parameterized import parameterized from transformers import OpenLlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel class UpperCamelCase : def __init__( self : Dict , snake_case__ : str , snake_case__ : str=1_3 , snake_case__ : Tuple=7 , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : List[str]=False , snake_case__ : Any=True , snake_case__ : Union[str, Any]=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Optional[Any]=5 , snake_case__ : Optional[Any]=4 , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Tuple="gelu" , snake_case__ : Dict=0.1 , snake_case__ : Any=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Dict=1_6 , snake_case__ : str=2 , snake_case__ : Any=0.02 , snake_case__ : List[str]=3 , snake_case__ : int=4 , snake_case__ : List[str]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Dict ): """simple docstring""" return OpenLlamaConfig( 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=snake_case__ , initializer_range=self.initializer_range , use_stable_embedding=snake_case__ , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : int , snake_case__ : List[str] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : Tuple , ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : int , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() # first forward pass SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , use_cache=snake_case__ , ) SCREAMING_SNAKE_CASE = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([input_mask, next_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , past_key_values=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else () ) __UpperCamelCase =(OpenLlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": OpenLlamaModel, "text-classification": OpenLlamaForSequenceClassification, "text-generation": OpenLlamaForCausalLM, "zero-shot": OpenLlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'single_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test' ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" pass @parameterized.expand([('linear',), ('dynamic',)] ) def UpperCamelCase ( self : str , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = ids_tensor([1, 1_0] , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) original_model.to(snake_case__ ) original_model.eval() SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = {'type': scaling_type, 'factor': 10.0} SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) scaled_model.to(snake_case__ ) scaled_model.eval() SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) else: self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
673
0
import os import pickle import unittest from transformers import AutoTokenizer from transformers.models.bert.tokenization_bert import BertTokenizer from transformers.models.bert_japanese.tokenization_bert_japanese import ( VOCAB_FILES_NAMES, BertJapaneseTokenizer, CharacterTokenizer, JumanppTokenizer, MecabTokenizer, SudachiTokenizer, WordpieceTokenizer, ) from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi from ...test_tokenization_common import TokenizerTesterMixin @custom_tokenizers class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =BertJapaneseTokenizer __UpperCamelCase =False __UpperCamelCase =True def UpperCamelCase ( self : int ): """simple docstring""" super().setUp() SCREAMING_SNAKE_CASE = [ '[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは', '世界', '##世界', '、', '##、', '。', '##。', ] SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def UpperCamelCase ( self : List[str] , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'こんにちは、世界。 \nこんばんは、世界。' SCREAMING_SNAKE_CASE = 'こんにちは 、 世界 。 こんばんは 、 世界 。' return input_text, output_text def UpperCamelCase ( self : Optional[Any] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_input_output_texts(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.encode(snake_case__ , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.decode(snake_case__ , clean_up_tokenization_spaces=snake_case__ ) return text, ids def UpperCamelCase ( self : str ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : List[str] ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : Dict ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class(self.vocab_file ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('こんにちは、世界。\nこんばんは、世界。' ) self.assertListEqual(snake_case__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4] ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class(self.vocab_file , word_tokenizer_type='mecab' ) self.assertIsNotNone(snake_case__ ) SCREAMING_SNAKE_CASE = 'こんにちは、世界。\nこんばんは、世界。' SCREAMING_SNAKE_CASE = tokenizer.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4] ) SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(snake_case__ , 'wb' ) as handle: pickle.dump(snake_case__ , snake_case__ ) with open(snake_case__ , 'rb' ) as handle: SCREAMING_SNAKE_CASE = pickle.load(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer_new.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = MecabTokenizer(mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def UpperCamelCase ( self : List[str] ): """simple docstring""" try: SCREAMING_SNAKE_CASE = MecabTokenizer(mecab_dic='unidic_lite' ) except ModuleNotFoundError: return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" try: SCREAMING_SNAKE_CASE = MecabTokenizer(mecab_dic='unidic' ) except ModuleNotFoundError: return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = MecabTokenizer(do_lower_case=snake_case__ , mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iphone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" try: SCREAMING_SNAKE_CASE = MecabTokenizer( do_lower_case=snake_case__ , normalize_text=snake_case__ , mecab_option='-d /usr/local/lib/mecab/dic/jumandic' ) except RuntimeError: # if dict doesn't exist in the system, previous code raises this error. return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '\u3000', '。'] , ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = MecabTokenizer(normalize_text=snake_case__ , mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', ' ', '。'] , ) @require_sudachi def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class(self.vocab_file , word_tokenizer_type='sudachi' ) self.assertIsNotNone(snake_case__ ) SCREAMING_SNAKE_CASE = 'こんにちは、世界。\nこんばんは、世界。' SCREAMING_SNAKE_CASE = tokenizer.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4] ) SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(snake_case__ , 'wb' ) as handle: pickle.dump(snake_case__ , snake_case__ ) with open(snake_case__ , 'rb' ) as handle: SCREAMING_SNAKE_CASE = pickle.load(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer_new.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , snake_case__ ) @require_sudachi def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' '] , ) @require_sudachi def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='A' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国', '人', '参政', '権'] ) @require_sudachi def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='B' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国人', '参政権'] ) @require_sudachi def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='C' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国人参政権'] ) @require_sudachi def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(do_lower_case=snake_case__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iphone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' '] , ) @require_sudachi def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(normalize_text=snake_case__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', '\u3000', '。', ' ', ' '] , ) @require_sudachi def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = SudachiTokenizer(trim_whitespace=snake_case__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) @require_jumanpp def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class(self.vocab_file , word_tokenizer_type='jumanpp' ) self.assertIsNotNone(snake_case__ ) SCREAMING_SNAKE_CASE = 'こんにちは、世界。\nこんばんは、世界。' SCREAMING_SNAKE_CASE = tokenizer.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4] ) SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(snake_case__ , 'wb' ) as handle: pickle.dump(snake_case__ , snake_case__ ) with open(snake_case__ , 'rb' ) as handle: SCREAMING_SNAKE_CASE = pickle.load(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer_new.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , snake_case__ ) @require_jumanpp def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = JumanppTokenizer() self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = JumanppTokenizer(do_lower_case=snake_case__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iphone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = JumanppTokenizer(normalize_text=snake_case__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['ア', 'ッ', 'フ', '゚', 'ル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = JumanppTokenizer(trim_whitespace=snake_case__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '。'] , ) @require_jumanpp def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = JumanppTokenizer() self.assertListEqual( tokenizer.tokenize('ありがとうございますm(_ _)m見つけるのが大変です。' ) , ['ありがとう', 'ございます', 'm(_ _)m', '見つける', 'の', 'が', '大変です', '。'] , ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = ['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは'] SCREAMING_SNAKE_CASE = {} for i, token in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = i SCREAMING_SNAKE_CASE = WordpieceTokenizer(vocab=snake_case__ , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('こんにちは' ) , ['こんにちは'] ) self.assertListEqual(tokenizer.tokenize('こんばんは' ) , ['こん', '##ばんは'] ) self.assertListEqual(tokenizer.tokenize('こんばんは こんばんにちは こんにちは' ) , ['こん', '##ばんは', '[UNK]', 'こんにちは'] ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp' ) SCREAMING_SNAKE_CASE = tokenizer.subword_tokenizer SCREAMING_SNAKE_CASE = subword_tokenizer.tokenize('国境 の 長い トンネル を 抜ける と 雪国 であった 。' ) self.assertListEqual(snake_case__ , ['▁国境', '▁の', '▁長い', '▁トンネル', '▁を', '▁抜ける', '▁と', '▁雪', '国', '▁であった', '▁。'] ) SCREAMING_SNAKE_CASE = subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは' ) self.assertListEqual(snake_case__ , ['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは'] ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese' ) SCREAMING_SNAKE_CASE = tokenizer.encode('ありがとう。' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.encode('どういたしまして。' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ , snake_case__ ) # 2 is for "[CLS]", 3 is for "[SEP]" assert encoded_sentence == [2] + text + [3] assert encoded_pair == [2] + text + [3] + text_a + [3] @custom_tokenizers class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =BertJapaneseTokenizer __UpperCamelCase =False def UpperCamelCase ( self : Any ): """simple docstring""" super().setUp() SCREAMING_SNAKE_CASE = ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。'] SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def UpperCamelCase ( self : str , **snake_case__ : Union[str, Any] ): """simple docstring""" return BertJapaneseTokenizer.from_pretrained(self.tmpdirname , subword_tokenizer_type='character' , **snake_case__ ) def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'こんにちは、世界。 \nこんばんは、世界。' SCREAMING_SNAKE_CASE = 'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。' return input_text, output_text def UpperCamelCase ( self : List[str] ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : Dict ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : Dict ): """simple docstring""" pass # TODO add if relevant def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class(self.vocab_file , subword_tokenizer_type='character' ) SCREAMING_SNAKE_CASE = tokenizer.tokenize('こんにちは、世界。 \nこんばんは、世界。' ) self.assertListEqual( snake_case__ , ['こ', 'ん', 'に', 'ち', 'は', '、', '世', '界', '。', 'こ', 'ん', 'ば', 'ん', 'は', '、', '世', '界', '。'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(snake_case__ ) , [3, 4, 5, 6, 7, 1_1, 9, 1_0, 1_2, 3, 4, 8, 4, 7, 1_1, 9, 1_0, 1_2] ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。'] SCREAMING_SNAKE_CASE = {} for i, token in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = i SCREAMING_SNAKE_CASE = CharacterTokenizer(vocab=snake_case__ , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('こんにちは' ) , ['こ', 'ん', 'に', 'ち', 'は'] ) self.assertListEqual(tokenizer.tokenize('こんにちほ' ) , ['こ', 'ん', 'に', 'ち', '[UNK]'] ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char' ) SCREAMING_SNAKE_CASE = tokenizer.encode('ありがとう。' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.encode('どういたしまして。' , add_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.build_inputs_with_special_tokens(snake_case__ , snake_case__ ) # 2 is for "[CLS]", 3 is for "[SEP]" assert encoded_sentence == [2] + text + [3] assert encoded_pair == [2] + text + [3] + text_a + [3] @custom_tokenizers class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cl-tohoku/bert-base-japanese' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained(snake_case__ ) self.assertIsInstance(snake_case__ , snake_case__ ) class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cl-tohoku/bert-base-japanese' with self.assertLogs('transformers' , level='WARNING' ) as cm: BertTokenizer.from_pretrained(snake_case__ ) self.assertTrue( cm.records[0].message.startswith( 'The tokenizer class you load from this checkpoint is not the same type as the class this function' ' is called from.' ) ) SCREAMING_SNAKE_CASE = 'bert-base-cased' with self.assertLogs('transformers' , level='WARNING' ) as cm: BertJapaneseTokenizer.from_pretrained(snake_case__ ) self.assertTrue( cm.records[0].message.startswith( 'The tokenizer class you load from this checkpoint is not the same type as the class this function' ' is called from.' ) )
707
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="openai/whisper-base" __UpperCamelCase =( "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the " "transcribed text." ) __UpperCamelCase ="transcriber" __UpperCamelCase =WhisperProcessor __UpperCamelCase =WhisperForConditionalGeneration __UpperCamelCase =["audio"] __UpperCamelCase =["text"] def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.pre_processor(snake_case__ , return_tensors='pt' ).input_features def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" return self.model.generate(inputs=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : Union[str, Any] ): """simple docstring""" return self.pre_processor.batch_decode(snake_case__ , skip_special_tokens=snake_case__ )[0]
673
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available a_ : Any = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Any = ["YolosFeatureExtractor"] a_ : str = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Tuple = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys a_ : str = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
708
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
673
0
import re from filelock import FileLock try: import nltk a_ : List[str] = True except (ImportError, ModuleNotFoundError): a_ : Dict = False if NLTK_AVAILABLE: with FileLock(".lock") as lock: nltk.download("punkt", quiet=True) def __lowerCAmelCase ( _UpperCamelCase : str ) -> str: '''simple docstring''' re.sub('<n>' , '' , _UpperCamelCase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(_UpperCamelCase ) )
709
import numpy as np def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return 1 / (1 + np.exp(-vector )) def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return vector * sigmoid(_UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
673
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available a_ : int = { "configuration_biogpt": ["BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "BioGptConfig"], "tokenization_biogpt": ["BioGptTokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Any = [ "BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST", "BioGptForCausalLM", "BioGptForTokenClassification", "BioGptForSequenceClassification", "BioGptModel", "BioGptPreTrainedModel", ] if TYPE_CHECKING: from .configuration_biogpt import BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, BioGptConfig from .tokenization_biogpt import BioGptTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_biogpt import ( BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification, BioGptModel, BioGptPreTrainedModel, ) else: import sys a_ : List[str] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
710
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
673
0
import warnings from functools import wraps from typing import Callable def __lowerCAmelCase ( _UpperCamelCase : Callable ) -> Callable: '''simple docstring''' @wraps(_UpperCamelCase ) def _inner_fn(*_UpperCamelCase : List[str] , **_UpperCamelCase : List[str] ): warnings.warn( (f"""'{fn.__name__}' is experimental and might be subject to breaking changes in the future.""") , _UpperCamelCase , ) return fn(*_UpperCamelCase , **_UpperCamelCase ) return _inner_fn
711
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
673
0
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 ( SCREAMING_SNAKE_CASE ): def __init__( self : Union[str, Any] , snake_case__ : TransformeraDModel , snake_case__ : AutoencoderKL , snake_case__ : KarrasDiffusionSchedulers , snake_case__ : Optional[Dict[int, str]] = None , ): """simple docstring""" super().__init__() self.register_modules(transformer=snake_case__ , vae=snake_case__ , scheduler=snake_case__ ) # create a imagenet -> id dictionary for easier use SCREAMING_SNAKE_CASE = {} if idalabel is not None: for key, value in idalabel.items(): for label in value.split(',' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) SCREAMING_SNAKE_CASE = dict(sorted(self.labels.items() ) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, List[str]] ): """simple docstring""" if not isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = list(snake_case__ ) 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] , snake_case__ : List[int] , snake_case__ : float = 4.0 , snake_case__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case__ : int = 5_0 , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , ): """simple docstring""" SCREAMING_SNAKE_CASE = len(snake_case__ ) SCREAMING_SNAKE_CASE = self.transformer.config.sample_size SCREAMING_SNAKE_CASE = self.transformer.config.in_channels SCREAMING_SNAKE_CASE = randn_tensor( shape=(batch_size, latent_channels, latent_size, latent_size) , generator=snake_case__ , device=self.device , dtype=self.transformer.dtype , ) SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if guidance_scale > 1 else latents SCREAMING_SNAKE_CASE = torch.tensor(snake_case__ , device=self.device ).reshape(-1 ) SCREAMING_SNAKE_CASE = torch.tensor([1_0_0_0] * batch_size , device=self.device ) SCREAMING_SNAKE_CASE = torch.cat([class_labels, class_null] , 0 ) if guidance_scale > 1 else class_labels # set step values self.scheduler.set_timesteps(snake_case__ ) for t in self.progress_bar(self.scheduler.timesteps ): if guidance_scale > 1: SCREAMING_SNAKE_CASE = latent_model_input[: len(snake_case__ ) // 2] SCREAMING_SNAKE_CASE = torch.cat([half, half] , dim=0 ) SCREAMING_SNAKE_CASE = self.scheduler.scale_model_input(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = t if not torch.is_tensor(snake_case__ ): # 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+) SCREAMING_SNAKE_CASE = latent_model_input.device.type == 'mps' if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.floataa if is_mps else torch.floataa else: SCREAMING_SNAKE_CASE = torch.intaa if is_mps else torch.intaa SCREAMING_SNAKE_CASE = torch.tensor([timesteps] , dtype=snake_case__ , device=latent_model_input.device ) elif len(timesteps.shape ) == 0: SCREAMING_SNAKE_CASE = timesteps[None].to(latent_model_input.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML SCREAMING_SNAKE_CASE = timesteps.expand(latent_model_input.shape[0] ) # predict noise model_output SCREAMING_SNAKE_CASE = self.transformer( snake_case__ , timestep=snake_case__ , class_labels=snake_case__ ).sample # perform guidance if guidance_scale > 1: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred[:, :latent_channels], noise_pred[:, latent_channels:] SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = torch.split(snake_case__ , len(snake_case__ ) // 2 , dim=0 ) SCREAMING_SNAKE_CASE = uncond_eps + guidance_scale * (cond_eps - uncond_eps) SCREAMING_SNAKE_CASE = torch.cat([half_eps, half_eps] , dim=0 ) SCREAMING_SNAKE_CASE = torch.cat([eps, rest] , dim=1 ) # learned sigma if self.transformer.config.out_channels // 2 == latent_channels: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = torch.split(snake_case__ , snake_case__ , dim=1 ) else: SCREAMING_SNAKE_CASE = noise_pred # compute previous image: x_t -> x_t-1 SCREAMING_SNAKE_CASE = self.scheduler.step(snake_case__ , snake_case__ , snake_case__ ).prev_sample if guidance_scale > 1: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = latent_model_input.chunk(2 , dim=0 ) else: SCREAMING_SNAKE_CASE = latent_model_input SCREAMING_SNAKE_CASE = 1 / self.vae.config.scaling_factor * latents SCREAMING_SNAKE_CASE = self.vae.decode(snake_case__ ).sample SCREAMING_SNAKE_CASE = (samples / 2 + 0.5).clamp(0 , 1 ) # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16 SCREAMING_SNAKE_CASE = samples.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": SCREAMING_SNAKE_CASE = self.numpy_to_pil(snake_case__ ) if not return_dict: return (samples,) return ImagePipelineOutput(images=snake_case__ )
712
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : Dict = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Any , **snake_case__ : Optional[int] ): """simple docstring""" super().__init__(**snake_case__ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(snake_case__ ) def __call__( self : List[Any] , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(snake_case__ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {'image': image, 'candidate_labels': candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(snake_case__ , **snake_case__ ) return results def UpperCamelCase ( self : Union[str, Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs['threshold'] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs['top_k'] return {}, {}, postprocess_params def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs['candidate_labels'] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = self.tokenizer(snake_case__ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(snake_case__ , return_tensors=self.framework ) yield { "is_last": i == len(snake_case__ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**snake_case__ ) SCREAMING_SNAKE_CASE = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output['candidate_label'] SCREAMING_SNAKE_CASE = BaseModelOutput(snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=snake_case__ , threshold=snake_case__ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs['scores'][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {'score': score, 'label': label, 'box': box} results.append(snake_case__ ) SCREAMING_SNAKE_CASE = sorted(snake_case__ , key=lambda snake_case__ : x["score"] , reverse=snake_case__ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : List[Any] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
673
0
import copy import os from collections import OrderedDict from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union if TYPE_CHECKING: from ...processing_utils import ProcessorMixin from ...utils import TensorType from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging a_ : str = logging.get_logger(__name__) a_ : List[Any] = { "google/owlvit-base-patch32": "https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json", "google/owlvit-base-patch16": "https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json", "google/owlvit-large-patch14": "https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json", } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="owlvit_text_model" def __init__( self : int , snake_case__ : int=4_9_4_0_8 , snake_case__ : str=5_1_2 , snake_case__ : str=2_0_4_8 , snake_case__ : Optional[Any]=1_2 , snake_case__ : List[Any]=8 , snake_case__ : str=1_6 , snake_case__ : int="quick_gelu" , snake_case__ : int=1E-5 , snake_case__ : Union[str, Any]=0.0 , snake_case__ : List[Any]=0.02 , snake_case__ : Optional[Any]=1.0 , snake_case__ : Optional[int]=0 , snake_case__ : Any=4_9_4_0_6 , snake_case__ : str=4_9_4_0_7 , **snake_case__ : Any , ): """simple docstring""" super().__init__(pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , **snake_case__ ) SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = attention_dropout SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = initializer_factor @classmethod def UpperCamelCase ( cls : List[str] , snake_case__ : Union[str, os.PathLike] , **snake_case__ : str ): """simple docstring""" cls._set_token_in_kwargs(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cls.get_config_dict(snake_case__ , **snake_case__ ) # get the text config dict if we are loading from OwlViTConfig if config_dict.get('model_type' ) == "owlvit": SCREAMING_SNAKE_CASE = config_dict['text_config'] if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """ F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" ) return cls.from_dict(snake_case__ , **snake_case__ ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="owlvit_vision_model" def __init__( self : List[str] , snake_case__ : str=7_6_8 , snake_case__ : Any=3_0_7_2 , snake_case__ : str=1_2 , snake_case__ : Union[str, Any]=1_2 , snake_case__ : Dict=3 , snake_case__ : Dict=7_6_8 , snake_case__ : Dict=3_2 , snake_case__ : str="quick_gelu" , snake_case__ : Optional[int]=1E-5 , snake_case__ : Union[str, Any]=0.0 , snake_case__ : Any=0.02 , snake_case__ : Optional[int]=1.0 , **snake_case__ : int , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = patch_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = attention_dropout SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = initializer_factor @classmethod def UpperCamelCase ( cls : Any , snake_case__ : Union[str, os.PathLike] , **snake_case__ : Union[str, Any] ): """simple docstring""" cls._set_token_in_kwargs(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cls.get_config_dict(snake_case__ , **snake_case__ ) # get the vision config dict if we are loading from OwlViTConfig if config_dict.get('model_type' ) == "owlvit": SCREAMING_SNAKE_CASE = config_dict['vision_config'] if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """ F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" ) return cls.from_dict(snake_case__ , **snake_case__ ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="owlvit" __UpperCamelCase =True def __init__( self : Union[str, Any] , snake_case__ : int=None , snake_case__ : str=None , snake_case__ : Dict=5_1_2 , snake_case__ : int=2.6_592 , snake_case__ : Optional[Any]=True , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) if text_config is None: SCREAMING_SNAKE_CASE = {} logger.info('text_config is None. Initializing the OwlViTTextConfig with default values.' ) if vision_config is None: SCREAMING_SNAKE_CASE = {} logger.info('vision_config is None. initializing the OwlViTVisionConfig with default values.' ) SCREAMING_SNAKE_CASE = OwlViTTextConfig(**snake_case__ ) SCREAMING_SNAKE_CASE = OwlViTVisionConfig(**snake_case__ ) SCREAMING_SNAKE_CASE = projection_dim SCREAMING_SNAKE_CASE = logit_scale_init_value SCREAMING_SNAKE_CASE = return_dict SCREAMING_SNAKE_CASE = 1.0 @classmethod def UpperCamelCase ( cls : str , snake_case__ : Union[str, os.PathLike] , **snake_case__ : List[str] ): """simple docstring""" cls._set_token_in_kwargs(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cls.get_config_dict(snake_case__ , **snake_case__ ) if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """ F"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" ) return cls.from_dict(snake_case__ , **snake_case__ ) @classmethod def UpperCamelCase ( cls : str , snake_case__ : Dict , snake_case__ : Dict , **snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} SCREAMING_SNAKE_CASE = text_config SCREAMING_SNAKE_CASE = vision_config return cls.from_dict(snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = copy.deepcopy(self.__dict__ ) SCREAMING_SNAKE_CASE = self.text_config.to_dict() SCREAMING_SNAKE_CASE = self.vision_config.to_dict() SCREAMING_SNAKE_CASE = self.__class__.model_type return output class UpperCamelCase ( SCREAMING_SNAKE_CASE ): @property def UpperCamelCase ( self : Any ): """simple docstring""" return OrderedDict( [ ('input_ids', {0: 'batch', 1: 'sequence'}), ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ('attention_mask', {0: 'batch', 1: 'sequence'}), ] ) @property def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return OrderedDict( [ ('logits_per_image', {0: 'batch'}), ('logits_per_text', {0: 'batch'}), ('text_embeds', {0: 'batch'}), ('image_embeds', {0: 'batch'}), ] ) @property def UpperCamelCase ( self : List[str] ): """simple docstring""" return 1E-4 def UpperCamelCase ( self : int , snake_case__ : "ProcessorMixin" , snake_case__ : int = -1 , snake_case__ : int = -1 , snake_case__ : Optional["TensorType"] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super().generate_dummy_inputs( processor.tokenizer , batch_size=snake_case__ , seq_length=snake_case__ , framework=snake_case__ ) SCREAMING_SNAKE_CASE = super().generate_dummy_inputs( processor.image_processor , batch_size=snake_case__ , framework=snake_case__ ) return {**text_input_dict, **image_input_dict} @property def UpperCamelCase ( self : Any ): """simple docstring""" return 1_4
713
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
673
0
import math def __lowerCAmelCase ( _UpperCamelCase : int ) -> bool: '''simple docstring''' return math.sqrt(_UpperCamelCase ) * math.sqrt(_UpperCamelCase ) == num def __lowerCAmelCase ( _UpperCamelCase : int ) -> bool: '''simple docstring''' SCREAMING_SNAKE_CASE = 0 SCREAMING_SNAKE_CASE = n while left <= right: SCREAMING_SNAKE_CASE = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: SCREAMING_SNAKE_CASE = mid - 1 else: SCREAMING_SNAKE_CASE = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
714
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
673
0
import math import unittest from transformers import BioGptConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification, BioGptModel, BioGptTokenizer, ) from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[Any]=1_3 , snake_case__ : Optional[int]=7 , snake_case__ : Optional[Any]=True , snake_case__ : Any=True , snake_case__ : str=False , snake_case__ : int=True , snake_case__ : List[str]=9_9 , snake_case__ : List[str]=3_2 , snake_case__ : int=5 , snake_case__ : Dict=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Union[str, Any]=0.1 , snake_case__ : Optional[Any]=0.1 , snake_case__ : List[str]=5_1_2 , snake_case__ : str=1_6 , snake_case__ : Any=2 , snake_case__ : Tuple=0.02 , snake_case__ : Dict=3 , snake_case__ : Dict=4 , snake_case__ : Union[str, Any]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Any ): """simple docstring""" return BioGptConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Any , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Any , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Dict , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : int , snake_case__ : Optional[int] , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Any , snake_case__ : Dict , *snake_case__ : str ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() # create attention mask SCREAMING_SNAKE_CASE = torch.ones(input_ids.shape , dtype=torch.long , device=snake_case__ ) SCREAMING_SNAKE_CASE = self.seq_length // 2 SCREAMING_SNAKE_CASE = 0 # first forward pass SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ).to_tuple() # create hypothetical next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 1) , config.vocab_size ) # change a random masked slice from input_ids SCREAMING_SNAKE_CASE = ids_tensor((1,) , snake_case__ ).item() + 1 SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 1) , config.vocab_size ).squeeze(-1 ) SCREAMING_SNAKE_CASE = random_other_next_tokens # append to next input_ids and attn_mask SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat( [attn_mask, torch.ones((attn_mask.shape[0], 1) , dtype=torch.long , device=snake_case__ )] , dim=1 , ) # get two different outputs SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ )['last_hidden_state'] SCREAMING_SNAKE_CASE = model(snake_case__ , past_key_values=snake_case__ , attention_mask=snake_case__ )['last_hidden_state'] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -1, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : Tuple , snake_case__ : List[str] , *snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptModel(config=snake_case__ ).to(snake_case__ ).eval() SCREAMING_SNAKE_CASE = torch.ones(input_ids.shape , dtype=torch.long , device=snake_case__ ) # first forward pass SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , use_cache=snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = outputs.to_tuple() # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , 2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([attention_mask, next_attn_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ )['last_hidden_state'] SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , past_key_values=snake_case__ )[ 'last_hidden_state' ] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any , snake_case__ : int , snake_case__ : List[str] , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : int , *snake_case__ : Optional[int] , snake_case__ : Optional[int]=False ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptForCausalLM(snake_case__ ) model.to(snake_case__ ) if gradient_checkpointing: model.gradient_checkpointing_enable() SCREAMING_SNAKE_CASE = model(snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) result.loss.backward() def UpperCamelCase ( self : List[str] , snake_case__ : Dict , *snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptModel(snake_case__ ) SCREAMING_SNAKE_CASE = model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers ) for key in model.state_dict().keys(): if "c_proj" in key and "weight" in key: self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key] ) - model_std ) , 0.001 ) self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key] ) - 0.0 ) , 0.01 ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : Tuple , *snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = BioGptForTokenClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification) if is_torch_available() else () ) __UpperCamelCase =(BioGptForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": BioGptModel, "text-classification": BioGptForSequenceClassification, "text-generation": BioGptForCausalLM, "token-classification": BioGptForTokenClassification, "zero-shot": BioGptForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_model_attention_mask_past(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_forward_and_backwards(*snake_case__ , gradient_checkpointing=snake_case__ ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_model_past_large_inputs(*snake_case__ ) def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_weight_initialization(*snake_case__ ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_biogpt_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptForCausalLM.from_pretrained('microsoft/biogpt' ) model.to(snake_case__ ) SCREAMING_SNAKE_CASE = BioGptTokenizer.from_pretrained('microsoft/biogpt' ) SCREAMING_SNAKE_CASE = 'left' # Define PAD Token = EOS Token = 50256 SCREAMING_SNAKE_CASE = tokenizer.eos_token SCREAMING_SNAKE_CASE = model.config.eos_token_id # use different length sentences to test batching SCREAMING_SNAKE_CASE = [ 'Hello, my dog is a little', 'Today, I', ] SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' , padding=snake_case__ ) SCREAMING_SNAKE_CASE = inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = model.generate( input_ids=snake_case__ , attention_mask=inputs['attention_mask'].to(snake_case__ ) , ) SCREAMING_SNAKE_CASE = tokenizer(sentences[0] , return_tensors='pt' ).input_ids.to(snake_case__ ) SCREAMING_SNAKE_CASE = model.generate(input_ids=snake_case__ ) SCREAMING_SNAKE_CASE = inputs_non_padded.shape[-1] - inputs['attention_mask'][-1].long().sum().cpu().item() SCREAMING_SNAKE_CASE = tokenizer(sentences[1] , return_tensors='pt' ).input_ids.to(snake_case__ ) SCREAMING_SNAKE_CASE = model.generate(input_ids=snake_case__ , max_length=model.config.max_length - num_paddings ) SCREAMING_SNAKE_CASE = tokenizer.batch_decode(snake_case__ , skip_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.decode(output_non_padded[0] , skip_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = tokenizer.decode(output_padded[0] , skip_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = [ 'Hello, my dog is a little bit bigger than a little bit.', 'Today, I have a good idea of how to use the information', ] self.assertListEqual(snake_case__ , snake_case__ ) self.assertListEqual(snake_case__ , [non_padded_sentence, padded_sentence] ) @slow def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = BioGptModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = BioGptForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = BioGptForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptForCausalLM.from_pretrained('microsoft/biogpt' ) SCREAMING_SNAKE_CASE = torch.tensor([[2, 4_8_0_5, 9, 6_5_6, 2_1]] ) SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = 4_2_3_8_4 SCREAMING_SNAKE_CASE = torch.Size((1, 5, vocab_size) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-9.5_236, -9.8_918, 10.4_557], [-11.0_469, -9.6_423, 8.1_022], [-8.8_664, -7.8_826, 5.5_325]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = BioGptTokenizer.from_pretrained('microsoft/biogpt' ) SCREAMING_SNAKE_CASE = BioGptForCausalLM.from_pretrained('microsoft/biogpt' ) model.to(snake_case__ ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = tokenizer('COVID-19 is' , return_tensors='pt' ).to(snake_case__ ) SCREAMING_SNAKE_CASE = model.generate( **snake_case__ , min_length=1_0_0 , max_length=1_0_2_4 , num_beams=5 , early_stopping=snake_case__ , ) SCREAMING_SNAKE_CASE = tokenizer.decode(output_ids[0] , skip_special_tokens=snake_case__ ) SCREAMING_SNAKE_CASE = ( 'COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the' ' causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and' ' territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),' ' and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and' ' more than 800,000 deaths.' ) self.assertEqual(snake_case__ , snake_case__ )
715
# Note: if you intend to run this script make sure you look under scripts/fsmt/ # to locate the appropriate script to do the work correctly. There is a set of scripts to: # - download and prepare data and run the conversion script # - perform eval to get the best hparam into the config # - generate model_cards - useful if you have multiple models from the same paper import argparse import json import os import re from collections import OrderedDict from os.path import basename, dirname import fairseq import torch from fairseq import hub_utils from fairseq.data.dictionary import Dictionary from transformers import FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() a_ : str = 2 # based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping` # values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults: # # * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users) # * `early_stopping`: `False` consistently scored better # * `length_penalty` varied, so will assign the best one depending on the model a_ : int = { # fairseq: "wmt19-ru-en": {"length_penalty": 1.1}, "wmt19-en-ru": {"length_penalty": 1.1_5}, "wmt19-en-de": {"length_penalty": 1.0}, "wmt19-de-en": {"length_penalty": 1.1}, # allenai: "wmt16-en-de-dist-12-1": {"length_penalty": 0.6}, "wmt16-en-de-dist-6-1": {"length_penalty": 0.6}, "wmt16-en-de-12-1": {"length_penalty": 0.8}, "wmt19-de-en-6-6-base": {"length_penalty": 0.6}, "wmt19-de-en-6-6-big": {"length_penalty": 0.6}, } # this remaps the different models to their organization names a_ : str = {} for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: a_ : List[Any] = "facebook" for m in [ "wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1", "wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big", ]: a_ : Any = "allenai" def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = dict((re.sub(R'@@$' , '' , _UpperCamelCase ), v) if k.endswith('@@' ) else (re.sub(R'$' , '</w>' , _UpperCamelCase ), v) for k, v in d.items() ) SCREAMING_SNAKE_CASE = '<s> <pad> </s> <unk>'.split() # restore the special tokens for k in keep_keys: del da[f"""{k}</w>"""] SCREAMING_SNAKE_CASE = d[k] # restore return da def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[str] ) -> Dict: '''simple docstring''' assert os.path.exists(_UpperCamelCase ) os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) print(f"""Writing results to {pytorch_dump_folder_path}""" ) # handle various types of models SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel SCREAMING_SNAKE_CASE = cls.hub_models() SCREAMING_SNAKE_CASE = {'bpe': 'fastbpe', 'tokenizer': 'moses'} SCREAMING_SNAKE_CASE = '.' # note: since the model dump is old, fairseq has upgraded its model some # time later, and it does a whole lot of rewrites and splits on the saved # weights, therefore we can't use torch.load() directly on the model file. # see: upgrade_state_dict(state_dict) in fairseq_model.py print(f"""using checkpoint {checkpoint_file}""" ) SCREAMING_SNAKE_CASE = hub_utils.from_pretrained( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , archive_map=_UpperCamelCase , **_UpperCamelCase ) SCREAMING_SNAKE_CASE = vars(chkpt['args']['model'] ) SCREAMING_SNAKE_CASE = args['source_lang'] SCREAMING_SNAKE_CASE = args['target_lang'] SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) # dicts SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{src_lang}.txt""" ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{tgt_lang}.txt""" ) SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(src_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-src.json' ) print(f"""Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # detect whether this is a do_lower_case situation, which can be derived by checking whether we # have at least one uppercase letter in the source vocab SCREAMING_SNAKE_CASE = True for k in src_vocab.keys(): if not k.islower(): SCREAMING_SNAKE_CASE = False break SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(tgt_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-tgt.json' ) print(f"""Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # merges_file (bpecodes) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , VOCAB_FILES_NAMES['merges_file'] ) for fn in ["bpecodes", "code"]: # older fairseq called the merges file "code" SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) if os.path.exists(_UpperCamelCase ): break with open(_UpperCamelCase , encoding='utf-8' ) as fin: SCREAMING_SNAKE_CASE = fin.read() SCREAMING_SNAKE_CASE = re.sub(R' \d+$' , '' , _UpperCamelCase , 0 , re.M ) # remove frequency number print(f"""Generating {merges_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as fout: fout.write(_UpperCamelCase ) # model config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'config.json' ) # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe - # may have to modify the tokenizer if a different type is used by a future model assert args["bpe"] == "fastbpe", f"""need to extend tokenizer to support bpe={args['bpe']}""" assert args["tokenizer"] == "moses", f"""need to extend tokenizer to support bpe={args['tokenizer']}""" SCREAMING_SNAKE_CASE = { 'architectures': ['FSMTForConditionalGeneration'], 'model_type': 'fsmt', 'activation_dropout': args['activation_dropout'], 'activation_function': 'relu', 'attention_dropout': args['attention_dropout'], 'd_model': args['decoder_embed_dim'], 'dropout': args['dropout'], 'init_std': 0.02, 'max_position_embeddings': args['max_source_positions'], 'num_hidden_layers': args['encoder_layers'], 'src_vocab_size': src_vocab_size, 'tgt_vocab_size': tgt_vocab_size, 'langs': [src_lang, tgt_lang], 'encoder_attention_heads': args['encoder_attention_heads'], 'encoder_ffn_dim': args['encoder_ffn_embed_dim'], 'encoder_layerdrop': args['encoder_layerdrop'], 'encoder_layers': args['encoder_layers'], 'decoder_attention_heads': args['decoder_attention_heads'], 'decoder_ffn_dim': args['decoder_ffn_embed_dim'], 'decoder_layerdrop': args['decoder_layerdrop'], 'decoder_layers': args['decoder_layers'], 'bos_token_id': 0, 'pad_token_id': 1, 'eos_token_id': 2, 'is_encoder_decoder': True, 'scale_embedding': not args['no_scale_embedding'], 'tie_word_embeddings': args['share_all_embeddings'], } # good hparam defaults to start with SCREAMING_SNAKE_CASE = 5 SCREAMING_SNAKE_CASE = False if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]: SCREAMING_SNAKE_CASE = best_score_hparams[model_dir]['length_penalty'] else: SCREAMING_SNAKE_CASE = 1.0 print(f"""Generating {fsmt_model_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # tokenizer config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = { 'langs': [src_lang, tgt_lang], 'model_max_length': 10_24, 'do_lower_case': do_lower_case, } print(f"""Generating {fsmt_tokenizer_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # model SCREAMING_SNAKE_CASE = chkpt['models'][0] SCREAMING_SNAKE_CASE = model.state_dict() # rename keys to start with 'model.' SCREAMING_SNAKE_CASE = OrderedDict(('model.' + k, v) for k, v in model_state_dict.items() ) # remove unneeded keys SCREAMING_SNAKE_CASE = [ 'model.model', 'model.encoder.version', 'model.decoder.version', 'model.encoder_embed_tokens.weight', 'model.decoder_embed_tokens.weight', 'model.encoder.embed_positions._float_tensor', 'model.decoder.embed_positions._float_tensor', ] for k in ignore_keys: model_state_dict.pop(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTForConditionalGeneration(_UpperCamelCase ) # check that it loads ok model_new.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) # save SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) print(f"""Generating {pytorch_weights_dump_path}""" ) torch.save(_UpperCamelCase , _UpperCamelCase ) print('Conversion is done!' ) print('\nLast step is to upload the files to s3' ) print(f"""cd {data_root}""" ) print(f"""transformers-cli upload {model_dir}""" ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--fsmt_checkpoint_path", default=None, type=str, required=True, help=( "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts," " bpecodes, etc." ), ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) a_ : int = parser.parse_args() convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
673
0
from collections import OrderedDict from typing import Any, List, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast, PatchingSpec from ...utils import logging a_ : str = logging.get_logger(__name__) a_ : Tuple = { "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json", # See all GPT-J models at https://huggingface.co/models?filter=gpt_j } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="gptj" __UpperCamelCase ={ "max_position_embeddings": "n_positions", "hidden_size": "n_embd", "num_attention_heads": "n_head", "num_hidden_layers": "n_layer", } def __init__( self : Optional[Any] , snake_case__ : List[Any]=5_0_4_0_0 , snake_case__ : List[Any]=2_0_4_8 , snake_case__ : str=4_0_9_6 , snake_case__ : Dict=2_8 , snake_case__ : int=1_6 , snake_case__ : Tuple=6_4 , snake_case__ : Union[str, Any]=None , snake_case__ : Any="gelu_new" , snake_case__ : List[Any]=0.0 , snake_case__ : str=0.0 , snake_case__ : Tuple=0.0 , snake_case__ : Any=1E-5 , snake_case__ : Tuple=0.02 , snake_case__ : List[str]=True , snake_case__ : Tuple=5_0_2_5_6 , snake_case__ : Union[str, Any]=5_0_2_5_6 , snake_case__ : Optional[Any]=False , **snake_case__ : Optional[int] , ): """simple docstring""" SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = n_positions SCREAMING_SNAKE_CASE = n_embd SCREAMING_SNAKE_CASE = n_layer SCREAMING_SNAKE_CASE = n_head SCREAMING_SNAKE_CASE = n_inner SCREAMING_SNAKE_CASE = rotary_dim SCREAMING_SNAKE_CASE = activation_function SCREAMING_SNAKE_CASE = resid_pdrop SCREAMING_SNAKE_CASE = embd_pdrop SCREAMING_SNAKE_CASE = attn_pdrop SCREAMING_SNAKE_CASE = layer_norm_epsilon SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = use_cache SCREAMING_SNAKE_CASE = bos_token_id SCREAMING_SNAKE_CASE = eos_token_id super().__init__( bos_token_id=snake_case__ , eos_token_id=snake_case__ , tie_word_embeddings=snake_case__ , **snake_case__ ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Optional[Any] , snake_case__ : PretrainedConfig , snake_case__ : str = "default" , snake_case__ : List[PatchingSpec] = None , snake_case__ : bool = False , ): """simple docstring""" super().__init__(snake_case__ , task=snake_case__ , patching_specs=snake_case__ , use_past=snake_case__ ) if not getattr(self._config , 'pad_token_id' , snake_case__ ): # TODO: how to do that better? SCREAMING_SNAKE_CASE = 0 @property def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}} ) if self.use_past: self.fill_with_past_key_values_(snake_case__ , direction='inputs' ) SCREAMING_SNAKE_CASE = {0: 'batch', 1: 'past_sequence + sequence'} else: SCREAMING_SNAKE_CASE = {0: 'batch', 1: 'sequence'} return common_inputs @property def UpperCamelCase ( self : List[Any] ): """simple docstring""" return self._config.n_layer @property def UpperCamelCase ( self : int ): """simple docstring""" return self._config.n_head def UpperCamelCase ( self : Optional[Any] , snake_case__ : PreTrainedTokenizer , snake_case__ : int = -1 , snake_case__ : int = -1 , snake_case__ : bool = False , snake_case__ : Optional[TensorType] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super(snake_case__ , self ).generate_dummy_inputs( snake_case__ , batch_size=snake_case__ , seq_length=snake_case__ , is_pair=snake_case__ , framework=snake_case__ ) # We need to order the input in the way they appears in the forward() SCREAMING_SNAKE_CASE = OrderedDict({'input_ids': common_inputs['input_ids']} ) # Need to add the past_keys if self.use_past: if not is_torch_available(): raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' ) else: import torch SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = common_inputs['input_ids'].shape # Not using the same length for past_key_values SCREAMING_SNAKE_CASE = seqlen + 2 SCREAMING_SNAKE_CASE = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) SCREAMING_SNAKE_CASE = [ (torch.zeros(snake_case__ ), torch.zeros(snake_case__ )) for _ in range(self.num_layers ) ] SCREAMING_SNAKE_CASE = common_inputs['attention_mask'] if self.use_past: SCREAMING_SNAKE_CASE = ordered_inputs['attention_mask'].dtype SCREAMING_SNAKE_CASE = torch.cat( [ordered_inputs['attention_mask'], torch.ones(snake_case__ , snake_case__ , dtype=snake_case__ )] , dim=1 ) return ordered_inputs @property def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return 1_3
716
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
673
0
import unittest import torch from diffusers import DDIMScheduler, DDPMScheduler, UNetaDModel from diffusers.training_utils import set_seed from diffusers.utils.testing_utils import slow a_ : Dict = False class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : int , snake_case__ : List[Any]=3_2 ): """simple docstring""" set_seed(0 ) SCREAMING_SNAKE_CASE = UNetaDModel(sample_size=snake_case__ , in_channels=3 , out_channels=3 ) SCREAMING_SNAKE_CASE = torch.optim.SGD(model.parameters() , lr=0.0_001 ) return model, optimizer @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure full determinism without setting the CUBLAS_WORKSPACE_CONFIG env variable SCREAMING_SNAKE_CASE = DDPMScheduler( num_train_timesteps=1_0_0_0 , beta_start=0.0_001 , beta_end=0.02 , beta_schedule='linear' , clip_sample=snake_case__ , ) SCREAMING_SNAKE_CASE = DDIMScheduler( num_train_timesteps=1_0_0_0 , beta_start=0.0_001 , beta_end=0.02 , beta_schedule='linear' , clip_sample=snake_case__ , ) assert ddpm_scheduler.config.num_train_timesteps == ddim_scheduler.config.num_train_timesteps # shared batches for DDPM and DDIM set_seed(0 ) SCREAMING_SNAKE_CASE = [torch.randn((4, 3, 3_2, 3_2) ).clip(-1 , 1 ).to(snake_case__ ) for _ in range(4 )] SCREAMING_SNAKE_CASE = [torch.randn((4, 3, 3_2, 3_2) ).to(snake_case__ ) for _ in range(4 )] SCREAMING_SNAKE_CASE = [torch.randint(0 , 1_0_0_0 , (4,) ).long().to(snake_case__ ) for _ in range(4 )] # train with a DDPM scheduler SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_model_optimizer(resolution=3_2 ) model.train().to(snake_case__ ) for i in range(4 ): optimizer.zero_grad() SCREAMING_SNAKE_CASE = ddpm_scheduler.add_noise(clean_images[i] , noise[i] , timesteps[i] ) SCREAMING_SNAKE_CASE = model(snake_case__ , timesteps[i] ).sample SCREAMING_SNAKE_CASE = torch.nn.functional.mse_loss(snake_case__ , noise[i] ) loss.backward() optimizer.step() del model, optimizer # recreate the model and optimizer, and retry with DDIM SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_model_optimizer(resolution=3_2 ) model.train().to(snake_case__ ) for i in range(4 ): optimizer.zero_grad() SCREAMING_SNAKE_CASE = ddim_scheduler.add_noise(clean_images[i] , noise[i] , timesteps[i] ) SCREAMING_SNAKE_CASE = model(snake_case__ , timesteps[i] ).sample SCREAMING_SNAKE_CASE = torch.nn.functional.mse_loss(snake_case__ , noise[i] ) loss.backward() optimizer.step() del model, optimizer self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
717
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
673
0
import json import os import unittest from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer from ...test_tokenization_common import TokenizerTesterMixin class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =CTRLTokenizer __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt SCREAMING_SNAKE_CASE = ['adapt', 're@@', 'a@@', 'apt', 'c@@', 't', '<unk>'] SCREAMING_SNAKE_CASE = dict(zip(snake_case__ , range(len(snake_case__ ) ) ) ) SCREAMING_SNAKE_CASE = ['#version: 0.2', 'a p', 'ap t</w>', 'r e', 'a d', 'ad apt</w>', ''] SCREAMING_SNAKE_CASE = {'unk_token': '<unk>'} SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) SCREAMING_SNAKE_CASE = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['merges_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as fp: fp.write(json.dumps(snake_case__ ) + '\n' ) with open(self.merges_file , 'w' , encoding='utf-8' ) as fp: fp.write('\n'.join(snake_case__ ) ) def UpperCamelCase ( self : List[str] , **snake_case__ : Any ): """simple docstring""" kwargs.update(self.special_tokens_map ) return CTRLTokenizer.from_pretrained(self.tmpdirname , **snake_case__ ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = 'adapt react readapt apt' SCREAMING_SNAKE_CASE = 'adapt react readapt apt' return input_text, output_text def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = CTRLTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map ) SCREAMING_SNAKE_CASE = 'adapt react readapt apt' SCREAMING_SNAKE_CASE = 'adapt re@@ a@@ c@@ t re@@ adapt apt'.split() SCREAMING_SNAKE_CASE = tokenizer.tokenize(snake_case__ ) self.assertListEqual(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = tokens + [tokenizer.unk_token] SCREAMING_SNAKE_CASE = [0, 1, 2, 4, 5, 1, 0, 3, 6] self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__ ) , snake_case__ )
718
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
673
0
import copy from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto import CONFIG_MAPPING a_ : int = logging.get_logger(__name__) a_ : List[Any] = { "microsoft/conditional-detr-resnet-50": ( "https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="conditional_detr" __UpperCamelCase =["past_key_values"] __UpperCamelCase ={ "hidden_size": "d_model", "num_attention_heads": "encoder_attention_heads", } def __init__( self : int , snake_case__ : Optional[Any]=True , snake_case__ : Optional[int]=None , snake_case__ : Any=3 , snake_case__ : Any=3_0_0 , snake_case__ : Union[str, Any]=6 , snake_case__ : int=2_0_4_8 , snake_case__ : Tuple=8 , snake_case__ : List[Any]=6 , snake_case__ : Union[str, Any]=2_0_4_8 , snake_case__ : str=8 , snake_case__ : List[Any]=0.0 , snake_case__ : Union[str, Any]=0.0 , snake_case__ : int=True , snake_case__ : Tuple="relu" , snake_case__ : List[str]=2_5_6 , snake_case__ : Optional[int]=0.1 , snake_case__ : Tuple=0.0 , snake_case__ : Any=0.0 , snake_case__ : Any=0.02 , snake_case__ : List[str]=1.0 , snake_case__ : int=False , snake_case__ : str="sine" , snake_case__ : Dict="resnet50" , snake_case__ : Tuple=True , snake_case__ : List[Any]=False , snake_case__ : Union[str, Any]=2 , snake_case__ : Union[str, Any]=5 , snake_case__ : Optional[Any]=2 , snake_case__ : Dict=1 , snake_case__ : str=1 , snake_case__ : str=2 , snake_case__ : Any=5 , snake_case__ : Optional[int]=2 , snake_case__ : List[Any]=0.25 , **snake_case__ : List[str] , ): """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.' ) if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.' ) SCREAMING_SNAKE_CASE = CONFIG_MAPPING['resnet'](out_features=['stage4'] ) elif isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = backbone_config.get('model_type' ) SCREAMING_SNAKE_CASE = CONFIG_MAPPING[backbone_model_type] SCREAMING_SNAKE_CASE = config_class.from_dict(snake_case__ ) SCREAMING_SNAKE_CASE = use_timm_backbone SCREAMING_SNAKE_CASE = backbone_config SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = num_queries SCREAMING_SNAKE_CASE = d_model SCREAMING_SNAKE_CASE = encoder_ffn_dim SCREAMING_SNAKE_CASE = encoder_layers SCREAMING_SNAKE_CASE = encoder_attention_heads SCREAMING_SNAKE_CASE = decoder_ffn_dim SCREAMING_SNAKE_CASE = decoder_layers SCREAMING_SNAKE_CASE = decoder_attention_heads SCREAMING_SNAKE_CASE = dropout SCREAMING_SNAKE_CASE = attention_dropout SCREAMING_SNAKE_CASE = activation_dropout SCREAMING_SNAKE_CASE = activation_function SCREAMING_SNAKE_CASE = init_std SCREAMING_SNAKE_CASE = init_xavier_std SCREAMING_SNAKE_CASE = encoder_layerdrop SCREAMING_SNAKE_CASE = decoder_layerdrop SCREAMING_SNAKE_CASE = encoder_layers SCREAMING_SNAKE_CASE = auxiliary_loss SCREAMING_SNAKE_CASE = position_embedding_type SCREAMING_SNAKE_CASE = backbone SCREAMING_SNAKE_CASE = use_pretrained_backbone SCREAMING_SNAKE_CASE = dilation # Hungarian matcher SCREAMING_SNAKE_CASE = class_cost SCREAMING_SNAKE_CASE = bbox_cost SCREAMING_SNAKE_CASE = giou_cost # Loss coefficients SCREAMING_SNAKE_CASE = mask_loss_coefficient SCREAMING_SNAKE_CASE = dice_loss_coefficient SCREAMING_SNAKE_CASE = cls_loss_coefficient SCREAMING_SNAKE_CASE = bbox_loss_coefficient SCREAMING_SNAKE_CASE = giou_loss_coefficient SCREAMING_SNAKE_CASE = focal_alpha super().__init__(is_encoder_decoder=snake_case__ , **snake_case__ ) @property def UpperCamelCase ( self : Tuple ): """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self : Tuple ): """simple docstring""" return self.d_model def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = copy.deepcopy(self.__dict__ ) if self.backbone_config is not None: SCREAMING_SNAKE_CASE = self.backbone_config.to_dict() SCREAMING_SNAKE_CASE = self.__class__.model_type return output class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =version.parse("1.11" ) @property def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ('pixel_mask', {0: 'batch'}), ] ) @property def UpperCamelCase ( self : Dict ): """simple docstring""" return 1E-5 @property def UpperCamelCase ( self : Any ): """simple docstring""" return 1_2
719
import heapq import sys import numpy as np a_ : Optional[int] = tuple[int, int] class UpperCamelCase : def __init__( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() def UpperCamelCase ( self : List[Any] ): """simple docstring""" if not self.empty(): return self.elements[0][0] else: return float('inf' ) def UpperCamelCase ( self : List[str] ): """simple docstring""" return len(self.elements ) == 0 def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] ): """simple docstring""" if item not in self.set: heapq.heappush(self.elements , (priority, item) ) self.set.add(snake_case__ ) else: # update # print("update", item) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pri, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) temp.append((priority, item) ) for pro, xxx in temp: heapq.heappush(self.elements , (pro, xxx) ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" if item in self.set: self.set.remove(snake_case__ ) SCREAMING_SNAKE_CASE = [] ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) while x != item: temp.append((pro, x) ) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) for prito, yyy in temp: heapq.heappush(self.elements , (prito, yyy) ) def UpperCamelCase ( self : str ): """simple docstring""" return self.elements[0][1] def UpperCamelCase ( self : Tuple ): """simple docstring""" ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = heapq.heappop(self.elements ) self.set.remove(snake_case__ ) return (priority, item) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) SCREAMING_SNAKE_CASE = np.array(_UpperCamelCase ) return np.linalg.norm(a - b ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Dict: '''simple docstring''' return consistent_heuristic(_UpperCamelCase , _UpperCamelCase ) // t def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos ) -> Optional[int]: '''simple docstring''' return abs(p[0] - goal[0] ) + abs(p[1] - goal[1] ) def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : int , _UpperCamelCase : TPos , _UpperCamelCase : dict[TPos, float] ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = g_function[start] + Wa * heuristics[i](_UpperCamelCase , _UpperCamelCase ) return ans def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : int , _UpperCamelCase : Tuple ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = np.chararray((n, n) ) for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): SCREAMING_SNAKE_CASE = '*' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): if (j, (n - 1) - i) in blocks: SCREAMING_SNAKE_CASE = '#' SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = x # print(x) SCREAMING_SNAKE_CASE = '-' SCREAMING_SNAKE_CASE = back_pointer[x] SCREAMING_SNAKE_CASE = '-' for i in range(_UpperCamelCase ): for j in range(_UpperCamelCase ): 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:-' ) SCREAMING_SNAKE_CASE = back_pointer[goal] while x != start: print(_UpperCamelCase , end=' ' ) SCREAMING_SNAKE_CASE = back_pointer[x] print(_UpperCamelCase ) sys.exit() def __lowerCAmelCase ( _UpperCamelCase : TPos ) -> Any: '''simple docstring''' 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 __lowerCAmelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : Tuple , _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Optional[Any] , ) -> List[Any]: '''simple docstring''' for itera in range(_UpperCamelCase ): open_list[itera].remove_element(_UpperCamelCase ) # print("s", s) # print("j", j) ((SCREAMING_SNAKE_CASE) , (SCREAMING_SNAKE_CASE)) = s SCREAMING_SNAKE_CASE = (x - 1, y) SCREAMING_SNAKE_CASE = (x + 1, y) SCREAMING_SNAKE_CASE = (x, y + 1) SCREAMING_SNAKE_CASE = (x, y - 1) for neighbours in [left, right, up, down]: if neighbours not in blocks: if valid(_UpperCamelCase ) and neighbours not in visited: # print("neighbour", neighbours) visited.add(_UpperCamelCase ) SCREAMING_SNAKE_CASE = -1 SCREAMING_SNAKE_CASE = float('inf' ) if valid(_UpperCamelCase ) and g_function[neighbours] > g_function[s] + 1: SCREAMING_SNAKE_CASE = g_function[s] + 1 SCREAMING_SNAKE_CASE = s if neighbours not in close_list_anchor: open_list[0].put(_UpperCamelCase , key(_UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ) ) if neighbours not in close_list_inad: for var in range(1 , _UpperCamelCase ): if key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) <= Wa * key( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase ): open_list[j].put( _UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) def __lowerCAmelCase ( ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE = [] 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 a_ : str = {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a} a_ : List[str] = [ (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), ] a_ : Union[str, Any] = make_common_ground() a_ : Tuple = blocks_blk # hyper parameters a_ : Any = 1 a_ : List[str] = 1 a_ : Union[str, Any] = 20 a_ : Optional[Any] = 3 # one consistent and two other inconsistent # start and end destination a_ : int = (0, 0) a_ : Optional[int] = (n - 1, n - 1) a_ : Union[str, Any] = 1 def __lowerCAmelCase ( _UpperCamelCase : TPos , _UpperCamelCase : TPos , _UpperCamelCase : int ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = {start: 0, goal: float('inf' )} SCREAMING_SNAKE_CASE = {start: -1, goal: -1} SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = set() for i in range(_UpperCamelCase ): open_list.append(PriorityQueue() ) open_list[i].put(_UpperCamelCase , key(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ) SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] while open_list[0].minkey() < float('inf' ): for i in range(1 , _UpperCamelCase ): # 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(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = open_list[i].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_inad.append(_UpperCamelCase ) else: if g_function[goal] <= open_list[0].minkey(): if g_function[goal] < float('inf' ): do_something(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) else: SCREAMING_SNAKE_CASE = open_list[0].top_show() visited.add(_UpperCamelCase ) expand_state( _UpperCamelCase , 0 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) close_list_anchor.append(_UpperCamelCase ) print('No path found to goal' ) print() for i in range(n - 1 , -1 , -1 ): for j in range(_UpperCamelCase ): 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)
673
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a_ : Any = { "configuration_bigbird_pegasus": [ "BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP", "BigBirdPegasusConfig", "BigBirdPegasusOnnxConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a_ : Tuple = [ "BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST", "BigBirdPegasusForCausalLM", "BigBirdPegasusForConditionalGeneration", "BigBirdPegasusForQuestionAnswering", "BigBirdPegasusForSequenceClassification", "BigBirdPegasusModel", "BigBirdPegasusPreTrainedModel", ] if TYPE_CHECKING: from .configuration_bigbird_pegasus import ( BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdPegasusConfig, BigBirdPegasusOnnxConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bigbird_pegasus import ( BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST, BigBirdPegasusForCausalLM, BigBirdPegasusForConditionalGeneration, BigBirdPegasusForQuestionAnswering, BigBirdPegasusForSequenceClassification, BigBirdPegasusModel, BigBirdPegasusPreTrainedModel, ) else: import sys a_ : List[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
720
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) a_ : Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name a_ : str = "\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to(\"cuda\")\n\n >>> prompt = \"A red cartoon frog, 4k\"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... \"kandinsky-community/kandinsky-2-2-decoder\", torch_dtype=torch.float16\n ... )\n >>> pipe.to(\"cuda\")\n\n >>> init_image = load_image(\n ... \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n ... \"/kandinsky/frog.png\"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save(\"red_frog.png\")\n ```\n" def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Any , _UpperCamelCase : Any=8 ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 SCREAMING_SNAKE_CASE = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : List[Any]=5_12 , _UpperCamelCase : Union[str, Any]=5_12 ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) SCREAMING_SNAKE_CASE = np.array(pil_image.convert('RGB' ) ) SCREAMING_SNAKE_CASE = arr.astype(np.floataa ) / 1_27.5 - 1 SCREAMING_SNAKE_CASE = np.transpose(_UpperCamelCase , [2, 0, 1] ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).unsqueeze(0 ) return image class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : int , snake_case__ : UNetaDConditionModel , snake_case__ : DDPMScheduler , snake_case__ : VQModel , ): """simple docstring""" super().__init__() self.register_modules( unet=snake_case__ , scheduler=snake_case__ , movq=snake_case__ , ) SCREAMING_SNAKE_CASE = 2 ** (len(self.movq.config.block_out_channels ) - 1) def UpperCamelCase ( self : Any , snake_case__ : int , snake_case__ : List[Any] , snake_case__ : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = min(int(num_inference_steps * strength ) , snake_case__ ) SCREAMING_SNAKE_CASE = max(num_inference_steps - init_timestep , 0 ) SCREAMING_SNAKE_CASE = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self : List[str] , snake_case__ : Dict , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : str=None ): """simple docstring""" if not isinstance(snake_case__ , (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(snake_case__ )}""" ) SCREAMING_SNAKE_CASE = image.to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = batch_size * num_images_per_prompt if image.shape[1] == 4: SCREAMING_SNAKE_CASE = image else: if isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) != batch_size: raise ValueError( F"""You have passed a list of generators of length {len(snake_case__ )}, but requested an effective batch""" F""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) elif isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(snake_case__ ) ] SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) else: SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ ).latent_dist.sample(snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.config.scaling_factor * init_latents SCREAMING_SNAKE_CASE = torch.cat([init_latents] , dim=0 ) SCREAMING_SNAKE_CASE = init_latents.shape SCREAMING_SNAKE_CASE = randn_tensor(snake_case__ , generator=snake_case__ , device=snake_case__ , dtype=snake_case__ ) # get latents SCREAMING_SNAKE_CASE = self.scheduler.add_noise(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = init_latents return latents def UpperCamelCase ( self : int , snake_case__ : List[str]=0 ): """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) SCREAMING_SNAKE_CASE = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int]=0 ): """simple docstring""" if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) SCREAMING_SNAKE_CASE = torch.device(F"""cuda:{gpu_id}""" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=snake_case__ ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) SCREAMING_SNAKE_CASE = None for cpu_offloaded_model in [self.unet, self.movq]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = cpu_offload_with_hook(snake_case__ , snake_case__ , prev_module_hook=snake_case__ ) # We'll offload the last model manually. SCREAMING_SNAKE_CASE = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self : Dict ): """simple docstring""" if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(snake_case__ , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(snake_case__ ) def __call__( self : str , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]] , snake_case__ : Union[torch.FloatTensor, List[torch.FloatTensor]] , snake_case__ : int = 5_1_2 , snake_case__ : int = 5_1_2 , snake_case__ : int = 1_0_0 , snake_case__ : float = 4.0 , snake_case__ : float = 0.3 , snake_case__ : int = 1 , snake_case__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case__ : Optional[str] = "pil" , snake_case__ : bool = True , ): """simple docstring""" SCREAMING_SNAKE_CASE = self._execution_device SCREAMING_SNAKE_CASE = guidance_scale > 1.0 if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = image_embeds.shape[0] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = torch.cat(snake_case__ , dim=0 ) if do_classifier_free_guidance: SCREAMING_SNAKE_CASE = image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = negative_image_embeds.repeat_interleave(snake_case__ , dim=0 ) SCREAMING_SNAKE_CASE = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=snake_case__ ) if not isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = [image] if not all(isinstance(snake_case__ , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( F"""Input is in incorrect format: {[type(snake_case__ ) for i in image]}. Currently, we only support PIL image and pytorch tensor""" ) SCREAMING_SNAKE_CASE = torch.cat([prepare_image(snake_case__ , snake_case__ , snake_case__ ) for i in image] , dim=0 ) SCREAMING_SNAKE_CASE = image.to(dtype=image_embeds.dtype , device=snake_case__ ) SCREAMING_SNAKE_CASE = self.movq.encode(snake_case__ )['latents'] SCREAMING_SNAKE_CASE = latents.repeat_interleave(snake_case__ , dim=0 ) self.scheduler.set_timesteps(snake_case__ , device=snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.get_timesteps(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = timesteps[:1].repeat(batch_size * num_images_per_prompt ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = downscale_height_and_width(snake_case__ , snake_case__ , self.movq_scale_factor ) SCREAMING_SNAKE_CASE = self.prepare_latents( snake_case__ , snake_case__ , snake_case__ , snake_case__ , image_embeds.dtype , snake_case__ , snake_case__ ) for i, t in enumerate(self.progress_bar(snake_case__ ) ): # expand the latents if we are doing classifier free guidance SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents SCREAMING_SNAKE_CASE = {'image_embeds': image_embeds} SCREAMING_SNAKE_CASE = self.unet( sample=snake_case__ , timestep=snake_case__ , encoder_hidden_states=snake_case__ , added_cond_kwargs=snake_case__ , return_dict=snake_case__ , )[0] if do_classifier_free_guidance: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.chunk(2 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = variance_pred.chunk(2 ) SCREAMING_SNAKE_CASE = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) SCREAMING_SNAKE_CASE = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 SCREAMING_SNAKE_CASE = self.scheduler.step( snake_case__ , snake_case__ , snake_case__ , generator=snake_case__ , )[0] # post-processing SCREAMING_SNAKE_CASE = self.movq.decode(snake_case__ , force_not_quantize=snake_case__ )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}""" ) if output_type in ["np", "pil"]: SCREAMING_SNAKE_CASE = image * 0.5 + 0.5 SCREAMING_SNAKE_CASE = image.clamp(0 , 1 ) SCREAMING_SNAKE_CASE = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": SCREAMING_SNAKE_CASE = self.numpy_to_pil(snake_case__ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case__ )
673
0
def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : Any , _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : Any , _UpperCamelCase : Union[str, Any] ) -> Any: '''simple docstring''' if index == r: for j in range(_UpperCamelCase ): print(data[j] , end=' ' ) print(' ' ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location SCREAMING_SNAKE_CASE = arr[i] combination_util(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , index + 1 , _UpperCamelCase , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : List[Any] , _UpperCamelCase : List[str] ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = [0] * r # Print all combination using temporary array 'data[]' combination_util(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , 0 , _UpperCamelCase , 0 ) if __name__ == "__main__": # Driver code to check the function above a_ : Union[str, Any] = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
721
import argparse import numpy as np import torch from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging logging.set_verbosity_info() a_ : List[Any] = logging.get_logger("transformers.models.speecht5") def __lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Tuple , _UpperCamelCase : Any ) -> Dict: '''simple docstring''' hf_model.apply_weight_norm() SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['input_conv.bias'] for i in range(len(config.upsample_rates ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""upsamples.{i}.1.bias"""] for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ): for j in range(len(config.resblock_dilation_sizes ) ): SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs1.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_g"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.weight_v"""] SCREAMING_SNAKE_CASE = checkpoint[f"""blocks.{i}.convs2.{j}.1.bias"""] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_g'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.weight_v'] SCREAMING_SNAKE_CASE = checkpoint['output_conv.1.bias'] hf_model.remove_weight_norm() @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Optional[int] , _UpperCamelCase : Dict , _UpperCamelCase : Tuple , _UpperCamelCase : Any=None , _UpperCamelCase : List[str]=None , ) -> Tuple: '''simple docstring''' if config_path is not None: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig.from_pretrained(_UpperCamelCase ) else: SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig() SCREAMING_SNAKE_CASE = SpeechTaHifiGan(_UpperCamelCase ) SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase ) load_weights(orig_checkpoint['model']['generator'] , _UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = np.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = stats[0].reshape(-1 ) SCREAMING_SNAKE_CASE = stats[1].reshape(-1 ) SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() SCREAMING_SNAKE_CASE = torch.from_numpy(_UpperCamelCase ).float() model.save_pretrained(_UpperCamelCase ) if repo_id: print('Pushing to the hub...' ) model.push_to_hub(_UpperCamelCase ) if __name__ == "__main__": a_ : Dict = argparse.ArgumentParser() parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint") parser.add_argument("--stats_path", required=True, default=None, type=str, help="Path to stats.npy file") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model." ) parser.add_argument( "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub." ) a_ : Tuple = parser.parse_args() convert_hifigan_checkpoint( args.checkpoint_path, args.stats_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )
673
0
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
700
import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer a_ : Optional[int] = logging.get_logger(__name__) a_ : Union[str, Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json", }, "merges_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt", }, "tokenizer_file": { "allenai/led-base-16384": "https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json", }, } a_ : List[Any] = { "allenai/led-base-16384": 1_6384, } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =LEDTokenizer __UpperCamelCase =["input_ids", "attention_mask"] def __init__( self : Tuple , snake_case__ : List[Any]=None , snake_case__ : List[str]=None , snake_case__ : List[str]=None , snake_case__ : Dict="replace" , snake_case__ : Tuple="<s>" , snake_case__ : Optional[Any]="</s>" , snake_case__ : int="</s>" , snake_case__ : Dict="<s>" , snake_case__ : Union[str, Any]="<unk>" , snake_case__ : Optional[int]="<pad>" , snake_case__ : List[str]="<mask>" , snake_case__ : List[Any]=False , snake_case__ : int=True , **snake_case__ : Dict , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , errors=snake_case__ , bos_token=snake_case__ , eos_token=snake_case__ , sep_token=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , add_prefix_space=snake_case__ , trim_offsets=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = getattr(snake_case__ , pre_tok_state.pop('type' ) ) SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = pre_tok_class(**snake_case__ ) SCREAMING_SNAKE_CASE = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` SCREAMING_SNAKE_CASE = 'post_processor' SCREAMING_SNAKE_CASE = getattr(self.backend_tokenizer , snake_case__ , snake_case__ ) if tokenizer_component_instance: SCREAMING_SNAKE_CASE = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: SCREAMING_SNAKE_CASE = tuple(state['sep'] ) if "cls" in state: SCREAMING_SNAKE_CASE = tuple(state['cls'] ) SCREAMING_SNAKE_CASE = False if state.get('add_prefix_space' , snake_case__ ) != add_prefix_space: SCREAMING_SNAKE_CASE = add_prefix_space SCREAMING_SNAKE_CASE = True if state.get('trim_offsets' , snake_case__ ) != trim_offsets: SCREAMING_SNAKE_CASE = trim_offsets SCREAMING_SNAKE_CASE = True if changes_to_apply: SCREAMING_SNAKE_CASE = getattr(snake_case__ , state.pop('type' ) ) SCREAMING_SNAKE_CASE = component_class(**snake_case__ ) setattr(self.backend_tokenizer , snake_case__ , snake_case__ ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" if self._mask_token is None: if self.verbose: logger.error('Using mask_token, but it is not set yet.' ) return None return str(self._mask_token ) @mask_token.setter def UpperCamelCase ( self : List[Any] , snake_case__ : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = AddedToken(snake_case__ , lstrip=snake_case__ , rstrip=snake_case__ ) if isinstance(snake_case__ , snake_case__ ) else value SCREAMING_SNAKE_CASE = value def UpperCamelCase ( self : Dict , *snake_case__ : Optional[Any] , **snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._batch_encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : List[str] , *snake_case__ : List[Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = kwargs.get('is_split_into_words' , snake_case__ ) if is_split_into_words and not self.add_prefix_space: raise ValueError( F"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._encode_plus(*snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : Tuple=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def UpperCamelCase ( self : Optional[int] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def UpperCamelCase ( self : Optional[Any] , snake_case__ : Union[Dict[str, EncodedInput], BatchEncoding] , snake_case__ : Optional[int] = None , snake_case__ : PaddingStrategy = PaddingStrategy.DO_NOT_PAD , snake_case__ : Optional[int] = None , snake_case__ : Optional[bool] = None , ): """simple docstring""" SCREAMING_SNAKE_CASE = super()._pad( encoded_inputs=snake_case__ , max_length=snake_case__ , padding_strategy=snake_case__ , pad_to_multiple_of=snake_case__ , return_attention_mask=snake_case__ , ) # Load from model defaults if return_attention_mask is None: SCREAMING_SNAKE_CASE = 'attention_mask' in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: SCREAMING_SNAKE_CASE = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. SCREAMING_SNAKE_CASE = len(encoded_inputs['global_attention_mask'] ) != len(snake_case__ ) if needs_to_be_padded: SCREAMING_SNAKE_CASE = len(snake_case__ ) - len(encoded_inputs['global_attention_mask'] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` SCREAMING_SNAKE_CASE = ( encoded_inputs['global_attention_mask'] + [-1] * difference ) elif self.padding_side == "left": SCREAMING_SNAKE_CASE = [-1] * difference + encoded_inputs[ 'global_attention_mask' ] else: raise ValueError('Invalid padding strategy:' + str(self.padding_side ) ) return encoded_inputs
673
0
'''simple docstring''' import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
701
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def __lowerCAmelCase ( *_UpperCamelCase : Optional[Any] ) -> Optional[int]: '''simple docstring''' with open(_UpperCamelCase , 'r' ) as fh: fcntl.flock(_UpperCamelCase , fcntl.LOCK_EX ) try: print(*_UpperCamelCase ) finally: fcntl.flock(_UpperCamelCase , fcntl.LOCK_UN ) a_ : int = int(os.environ["LOCAL_RANK"]) torch.cuda.set_device(local_rank) a_ : str = torch.device("cuda", local_rank) a_ : Optional[int] = socket.gethostname() a_ : Union[str, Any] = F"""[{hostname}-{local_rank}]""" try: # test distributed dist.init_process_group("nccl") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank a_ : Dict = dist.get_rank() a_ : Any = dist.get_world_size() printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""") dist.barrier() if rank == 0: printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""") except Exception: printflock(F"""{gpu} is broken""") raise
673
0
import argparse import json import os from collections import OrderedDict import torch from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer from transformers.tokenization_utils_base import AddedToken @torch.no_grad() def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : int , _UpperCamelCase : List[Any] , _UpperCamelCase : str , _UpperCamelCase : str ) -> Union[str, Any]: '''simple docstring''' with open(_UpperCamelCase ) as metadata_file: SCREAMING_SNAKE_CASE = json.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = LukeConfig(use_entity_aware_attention=_UpperCamelCase , **metadata['model_config'] ) # Load in the weights from the checkpoint_path SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase , map_location='cpu' )['module'] # Load the entity vocab file SCREAMING_SNAKE_CASE = load_original_entity_vocab(_UpperCamelCase ) # add an entry for [MASK2] SCREAMING_SNAKE_CASE = max(entity_vocab.values() ) + 1 config.entity_vocab_size += 1 SCREAMING_SNAKE_CASE = XLMRobertaTokenizer.from_pretrained(metadata['model_config']['bert_model_name'] ) # Add special tokens to the token vocabulary for downstream tasks SCREAMING_SNAKE_CASE = AddedToken('<ent>' , lstrip=_UpperCamelCase , rstrip=_UpperCamelCase ) SCREAMING_SNAKE_CASE = AddedToken('<ent2>' , lstrip=_UpperCamelCase , rstrip=_UpperCamelCase ) tokenizer.add_special_tokens({'additional_special_tokens': [entity_token_a, entity_token_a]} ) config.vocab_size += 2 print(f"""Saving tokenizer to {pytorch_dump_folder_path}""" ) tokenizer.save_pretrained(_UpperCamelCase ) with open(os.path.join(_UpperCamelCase , 'tokenizer_config.json' ) , 'r' ) as f: SCREAMING_SNAKE_CASE = json.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 'MLukeTokenizer' with open(os.path.join(_UpperCamelCase , 'tokenizer_config.json' ) , 'w' ) as f: json.dump(_UpperCamelCase , _UpperCamelCase ) with open(os.path.join(_UpperCamelCase , MLukeTokenizer.vocab_files_names['entity_vocab_file'] ) , 'w' ) as f: json.dump(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase ) # Initialize the embeddings of the special tokens SCREAMING_SNAKE_CASE = tokenizer.convert_tokens_to_ids(['@'] )[0] SCREAMING_SNAKE_CASE = tokenizer.convert_tokens_to_ids(['#'] )[0] SCREAMING_SNAKE_CASE = state_dict['embeddings.word_embeddings.weight'] SCREAMING_SNAKE_CASE = word_emb[ent_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = word_emb[enta_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([word_emb, ent_emb, enta_emb] ) # add special tokens for 'entity_predictions.bias' for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]: SCREAMING_SNAKE_CASE = state_dict[bias_name] SCREAMING_SNAKE_CASE = decoder_bias[ent_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = decoder_bias[enta_init_index].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([decoder_bias, ent_decoder_bias, enta_decoder_bias] ) # Initialize the query layers of the entity-aware self-attention mechanism for layer_index in range(config.num_hidden_layers ): for matrix_name in ["query.weight", "query.bias"]: SCREAMING_SNAKE_CASE = f"""encoder.layer.{layer_index}.attention.self.""" SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] SCREAMING_SNAKE_CASE = state_dict[prefix + matrix_name] # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks SCREAMING_SNAKE_CASE = state_dict['entity_embeddings.entity_embeddings.weight'] SCREAMING_SNAKE_CASE = entity_emb[entity_vocab['[MASK]']].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([entity_emb, entity_mask_emb] ) # add [MASK2] for 'entity_predictions.bias' SCREAMING_SNAKE_CASE = state_dict['entity_predictions.bias'] SCREAMING_SNAKE_CASE = entity_prediction_bias[entity_vocab['[MASK]']].unsqueeze(0 ) SCREAMING_SNAKE_CASE = torch.cat([entity_prediction_bias, entity_mask_bias] ) SCREAMING_SNAKE_CASE = LukeForMaskedLM(config=_UpperCamelCase ).eval() state_dict.pop('entity_predictions.decoder.weight' ) state_dict.pop('lm_head.decoder.weight' ) state_dict.pop('lm_head.decoder.bias' ) SCREAMING_SNAKE_CASE = OrderedDict() for key, value in state_dict.items(): if not (key.startswith('lm_head' ) or key.startswith('entity_predictions' )): SCREAMING_SNAKE_CASE = state_dict[key] else: SCREAMING_SNAKE_CASE = state_dict[key] SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = model.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) if set(_UpperCamelCase ) != {"luke.embeddings.position_ids"}: raise ValueError(f"""Unexpected unexpected_keys: {unexpected_keys}""" ) if set(_UpperCamelCase ) != { "lm_head.decoder.weight", "lm_head.decoder.bias", "entity_predictions.decoder.weight", }: raise ValueError(f"""Unexpected missing_keys: {missing_keys}""" ) model.tie_weights() assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all() assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all() # Check outputs SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase , task='entity_classification' ) SCREAMING_SNAKE_CASE = 'ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan).' SCREAMING_SNAKE_CASE = (0, 9) SCREAMING_SNAKE_CASE = tokenizer(_UpperCamelCase , entity_spans=[span] , return_tensors='pt' ) SCREAMING_SNAKE_CASE = model(**_UpperCamelCase ) # Verify word hidden states if model_size == "large": raise NotImplementedError else: # base SCREAMING_SNAKE_CASE = torch.Size((1, 33, 7_68) ) SCREAMING_SNAKE_CASE = torch.tensor([[0.08_92, 0.05_96, -0.28_19], [0.01_34, 0.11_99, 0.05_73], [-0.01_69, 0.09_27, 0.06_44]] ) if not (outputs.last_hidden_state.shape == expected_shape): raise ValueError( f"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}""" ) if not torch.allclose(outputs.last_hidden_state[0, :3, :3] , _UpperCamelCase , atol=1e-4 ): raise ValueError # Verify entity hidden states if model_size == "large": raise NotImplementedError else: # base SCREAMING_SNAKE_CASE = torch.Size((1, 1, 7_68) ) SCREAMING_SNAKE_CASE = torch.tensor([[-0.14_82, 0.06_09, 0.03_22]] ) if not (outputs.entity_last_hidden_state.shape == expected_shape): raise ValueError( f"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is""" f""" {expected_shape}""" ) if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3] , _UpperCamelCase , atol=1e-4 ): raise ValueError # Verify masked word/entity prediction SCREAMING_SNAKE_CASE = MLukeTokenizer.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 'Tokyo is the capital of <mask>.' SCREAMING_SNAKE_CASE = (24, 30) SCREAMING_SNAKE_CASE = tokenizer(_UpperCamelCase , entity_spans=[span] , return_tensors='pt' ) SCREAMING_SNAKE_CASE = model(**_UpperCamelCase ) SCREAMING_SNAKE_CASE = encoding['input_ids'][0].tolist() SCREAMING_SNAKE_CASE = input_ids.index(tokenizer.convert_tokens_to_ids('<mask>' ) ) SCREAMING_SNAKE_CASE = outputs.logits[0][mask_position_id].argmax(dim=-1 ) assert "Japan" == tokenizer.decode(_UpperCamelCase ) SCREAMING_SNAKE_CASE = outputs.entity_logits[0][0].argmax().item() SCREAMING_SNAKE_CASE = [ entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id ] assert [e for e in multilingual_predicted_entities if e.startswith('en:' )][0] == "en:Japan" # Finally, save our PyTorch model and tokenizer print('Saving PyTorch model to {}'.format(_UpperCamelCase ) ) model.save_pretrained(_UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Optional[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = ['[MASK]', '[PAD]', '[UNK]'] SCREAMING_SNAKE_CASE = [json.loads(_UpperCamelCase ) for line in open(_UpperCamelCase )] SCREAMING_SNAKE_CASE = {} for entry in data: SCREAMING_SNAKE_CASE = entry['id'] for entity_name, language in entry["entities"]: if entity_name in SPECIAL_TOKENS: SCREAMING_SNAKE_CASE = entity_id break SCREAMING_SNAKE_CASE = f"""{language}:{entity_name}""" SCREAMING_SNAKE_CASE = entity_id return new_mapping if __name__ == "__main__": a_ : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.") parser.add_argument( "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration." ) parser.add_argument( "--entity_vocab_path", default=None, type=str, help="Path to an entity_vocab.tsv file, containing the entity vocabulary.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model." ) parser.add_argument( "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted." ) a_ : List[str] = parser.parse_args() convert_luke_checkpoint( args.checkpoint_path, args.metadata_path, args.entity_vocab_path, args.pytorch_dump_folder_path, args.model_size, )
702
from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_herbert import HerbertTokenizer a_ : Optional[Any] = logging.get_logger(__name__) a_ : Optional[Any] = {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"} a_ : Any = { "vocab_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json" }, "merges_file": { "allegro/herbert-base-cased": "https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt" }, } a_ : Union[str, Any] = {"allegro/herbert-base-cased": 514} a_ : List[Any] = {} class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =VOCAB_FILES_NAMES __UpperCamelCase =PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase =PRETRAINED_INIT_CONFIGURATION __UpperCamelCase =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase =HerbertTokenizer def __init__( self : Tuple , snake_case__ : Optional[Any]=None , snake_case__ : int=None , snake_case__ : Optional[int]=None , snake_case__ : str="<s>" , snake_case__ : Tuple="<unk>" , snake_case__ : List[str]="<pad>" , snake_case__ : Tuple="<mask>" , snake_case__ : Dict="</s>" , **snake_case__ : List[str] , ): """simple docstring""" super().__init__( snake_case__ , snake_case__ , tokenizer_file=snake_case__ , cls_token=snake_case__ , unk_token=snake_case__ , pad_token=snake_case__ , mask_token=snake_case__ , sep_token=snake_case__ , **snake_case__ , ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.cls_token_id] SCREAMING_SNAKE_CASE = [self.sep_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 UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None , snake_case__ : bool = False ): """simple docstring""" if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case__ , token_ids_a=snake_case__ , already_has_special_tokens=snake_case__ ) if token_ids_a is None: return [1] + ([0] * len(snake_case__ )) + [1] return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1] def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[int] , snake_case__ : Optional[List[int]] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = [self.sep_token_id] SCREAMING_SNAKE_CASE = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def UpperCamelCase ( self : Tuple , snake_case__ : str , snake_case__ : Optional[str] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = self._tokenizer.model.save(snake_case__ , name=snake_case__ ) return tuple(snake_case__ )
673
0
from typing import Any, Dict, Optional import torch import torch.nn.functional as F from torch import nn from ..utils import maybe_allow_in_graph from .activations import get_activation from .attention_processor import Attention from .embeddings import CombinedTimestepLabelEmbeddings @maybe_allow_in_graph class UpperCamelCase ( nn.Module ): def __init__( self : Optional[int] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : Optional[int]=0.0 , snake_case__ : Optional[int] = None , snake_case__ : str = "geglu" , snake_case__ : Optional[int] = None , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = False , snake_case__ : bool = True , snake_case__ : str = "layer_norm" , snake_case__ : bool = False , ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = only_cross_attention SCREAMING_SNAKE_CASE = (num_embeds_ada_norm is not None) and norm_type == 'ada_norm_zero' SCREAMING_SNAKE_CASE = (num_embeds_ada_norm is not None) and norm_type == 'ada_norm' if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None: raise ValueError( F"""`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to""" F""" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.""" ) # Define 3 blocks. Each block has its own normalization layer. # 1. Self-Attn if self.use_ada_layer_norm: SCREAMING_SNAKE_CASE = AdaLayerNorm(snake_case__ , snake_case__ ) elif self.use_ada_layer_norm_zero: SCREAMING_SNAKE_CASE = AdaLayerNormZero(snake_case__ , snake_case__ ) else: SCREAMING_SNAKE_CASE = nn.LayerNorm(snake_case__ , elementwise_affine=snake_case__ ) SCREAMING_SNAKE_CASE = Attention( query_dim=snake_case__ , heads=snake_case__ , dim_head=snake_case__ , dropout=snake_case__ , bias=snake_case__ , cross_attention_dim=cross_attention_dim if only_cross_attention else None , upcast_attention=snake_case__ , ) # 2. Cross-Attn if cross_attention_dim is not None or double_self_attention: # We currently only use AdaLayerNormZero for self attention where there will only be one attention block. # I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during # the second cross attention block. SCREAMING_SNAKE_CASE = ( AdaLayerNorm(snake_case__ , snake_case__ ) if self.use_ada_layer_norm else nn.LayerNorm(snake_case__ , elementwise_affine=snake_case__ ) ) SCREAMING_SNAKE_CASE = Attention( query_dim=snake_case__ , cross_attention_dim=cross_attention_dim if not double_self_attention else None , heads=snake_case__ , dim_head=snake_case__ , dropout=snake_case__ , bias=snake_case__ , upcast_attention=snake_case__ , ) # is self-attn if encoder_hidden_states is none else: SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None # 3. Feed-forward SCREAMING_SNAKE_CASE = nn.LayerNorm(snake_case__ , elementwise_affine=snake_case__ ) SCREAMING_SNAKE_CASE = FeedForward(snake_case__ , dropout=snake_case__ , activation_fn=snake_case__ , final_dropout=snake_case__ ) # let chunk size default to None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = 0 def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = chunk_size SCREAMING_SNAKE_CASE = dim def UpperCamelCase ( self : Tuple , snake_case__ : torch.FloatTensor , snake_case__ : Optional[torch.FloatTensor] = None , snake_case__ : Optional[torch.FloatTensor] = None , snake_case__ : Optional[torch.FloatTensor] = None , snake_case__ : Optional[torch.LongTensor] = None , snake_case__ : Dict[str, Any] = None , snake_case__ : Optional[torch.LongTensor] = None , ): """simple docstring""" if self.use_ada_layer_norm: SCREAMING_SNAKE_CASE = self.norma(snake_case__ , snake_case__ ) elif self.use_ada_layer_norm_zero: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.norma( snake_case__ , snake_case__ , snake_case__ , hidden_dtype=hidden_states.dtype ) else: SCREAMING_SNAKE_CASE = self.norma(snake_case__ ) SCREAMING_SNAKE_CASE = cross_attention_kwargs if cross_attention_kwargs is not None else {} SCREAMING_SNAKE_CASE = self.attna( snake_case__ , encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None , attention_mask=snake_case__ , **snake_case__ , ) if self.use_ada_layer_norm_zero: SCREAMING_SNAKE_CASE = gate_msa.unsqueeze(1 ) * attn_output SCREAMING_SNAKE_CASE = attn_output + hidden_states # 2. Cross-Attention if self.attna is not None: SCREAMING_SNAKE_CASE = ( self.norma(snake_case__ , snake_case__ ) if self.use_ada_layer_norm else self.norma(snake_case__ ) ) SCREAMING_SNAKE_CASE = self.attna( snake_case__ , encoder_hidden_states=snake_case__ , attention_mask=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = attn_output + hidden_states # 3. Feed-forward SCREAMING_SNAKE_CASE = self.norma(snake_case__ ) if self.use_ada_layer_norm_zero: SCREAMING_SNAKE_CASE = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] if self._chunk_size is not None: # "feed_forward_chunk_size" can be used to save memory if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0: raise ValueError( F"""`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.""" ) SCREAMING_SNAKE_CASE = norm_hidden_states.shape[self._chunk_dim] // self._chunk_size SCREAMING_SNAKE_CASE = torch.cat( [self.ff(snake_case__ ) for hid_slice in norm_hidden_states.chunk(snake_case__ , dim=self._chunk_dim )] , dim=self._chunk_dim , ) else: SCREAMING_SNAKE_CASE = self.ff(snake_case__ ) if self.use_ada_layer_norm_zero: SCREAMING_SNAKE_CASE = gate_mlp.unsqueeze(1 ) * ff_output SCREAMING_SNAKE_CASE = ff_output + hidden_states return hidden_states class UpperCamelCase ( nn.Module ): def __init__( self : Union[str, Any] , snake_case__ : int , snake_case__ : Optional[int] = None , snake_case__ : int = 4 , snake_case__ : float = 0.0 , snake_case__ : str = "geglu" , snake_case__ : bool = False , ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = int(dim * mult ) SCREAMING_SNAKE_CASE = dim_out if dim_out is not None else dim if activation_fn == "gelu": SCREAMING_SNAKE_CASE = GELU(snake_case__ , snake_case__ ) if activation_fn == "gelu-approximate": SCREAMING_SNAKE_CASE = GELU(snake_case__ , snake_case__ , approximate='tanh' ) elif activation_fn == "geglu": SCREAMING_SNAKE_CASE = GEGLU(snake_case__ , snake_case__ ) elif activation_fn == "geglu-approximate": SCREAMING_SNAKE_CASE = ApproximateGELU(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = nn.ModuleList([] ) # project in self.net.append(snake_case__ ) # project dropout self.net.append(nn.Dropout(snake_case__ ) ) # project out self.net.append(nn.Linear(snake_case__ , snake_case__ ) ) # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout if final_dropout: self.net.append(nn.Dropout(snake_case__ ) ) def UpperCamelCase ( self : List[str] , snake_case__ : int ): """simple docstring""" for module in self.net: SCREAMING_SNAKE_CASE = module(snake_case__ ) return hidden_states class UpperCamelCase ( nn.Module ): def __init__( self : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : str = "none" ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = approximate def UpperCamelCase ( self : str , snake_case__ : Any ): """simple docstring""" if gate.device.type != "mps": return F.gelu(snake_case__ , approximate=self.approximate ) # mps: gelu is not implemented for float16 return F.gelu(gate.to(dtype=torch.floataa ) , approximate=self.approximate ).to(dtype=gate.dtype ) def UpperCamelCase ( self : List[str] , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.proj(snake_case__ ) SCREAMING_SNAKE_CASE = self.gelu(snake_case__ ) return hidden_states class UpperCamelCase ( nn.Module ): def __init__( self : Optional[int] , snake_case__ : int , snake_case__ : int ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , dim_out * 2 ) def UpperCamelCase ( self : int , snake_case__ : List[str] ): """simple docstring""" if gate.device.type != "mps": return F.gelu(snake_case__ ) # mps: gelu is not implemented for float16 return F.gelu(gate.to(dtype=torch.floataa ) ).to(dtype=gate.dtype ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.proj(snake_case__ ).chunk(2 , dim=-1 ) return hidden_states * self.gelu(snake_case__ ) class UpperCamelCase ( nn.Module ): def __init__( self : List[str] , snake_case__ : int , snake_case__ : int ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , snake_case__ ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.proj(snake_case__ ) return x * torch.sigmoid(1.702 * x ) class UpperCamelCase ( nn.Module ): def __init__( self : Any , snake_case__ : Optional[Any] , snake_case__ : Any ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = nn.Embedding(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = nn.SiLU() SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , embedding_dim * 2 ) SCREAMING_SNAKE_CASE = nn.LayerNorm(snake_case__ , elementwise_affine=snake_case__ ) def UpperCamelCase ( self : List[Any] , snake_case__ : Dict , snake_case__ : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.linear(self.silu(self.emb(snake_case__ ) ) ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = torch.chunk(snake_case__ , 2 ) SCREAMING_SNAKE_CASE = self.norm(snake_case__ ) * (1 + scale) + shift return x class UpperCamelCase ( nn.Module ): def __init__( self : Optional[int] , snake_case__ : int , snake_case__ : Optional[int] ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = CombinedTimestepLabelEmbeddings(snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = nn.SiLU() SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , 6 * embedding_dim , bias=snake_case__ ) SCREAMING_SNAKE_CASE = nn.LayerNorm(snake_case__ , elementwise_affine=snake_case__ , eps=1E-6 ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : Tuple , snake_case__ : int , snake_case__ : Dict , snake_case__ : Any=None ): """simple docstring""" SCREAMING_SNAKE_CASE = self.linear(self.silu(self.emb(snake_case__ , snake_case__ , hidden_dtype=snake_case__ ) ) ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = emb.chunk(6 , dim=1 ) SCREAMING_SNAKE_CASE = self.norm(snake_case__ ) * (1 + scale_msa[:, None]) + shift_msa[:, None] return x, gate_msa, shift_mlp, scale_mlp, gate_mlp class UpperCamelCase ( nn.Module ): def __init__( self : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : Optional[str] = None , snake_case__ : float = 1E-5 ): """simple docstring""" super().__init__() SCREAMING_SNAKE_CASE = num_groups SCREAMING_SNAKE_CASE = eps if act_fn is None: SCREAMING_SNAKE_CASE = None else: SCREAMING_SNAKE_CASE = get_activation(snake_case__ ) SCREAMING_SNAKE_CASE = nn.Linear(snake_case__ , out_dim * 2 ) def UpperCamelCase ( self : Dict , snake_case__ : int , snake_case__ : List[str] ): """simple docstring""" if self.act: SCREAMING_SNAKE_CASE = self.act(snake_case__ ) SCREAMING_SNAKE_CASE = self.linear(snake_case__ ) SCREAMING_SNAKE_CASE = emb[:, :, None, None] SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = emb.chunk(2 , dim=1 ) SCREAMING_SNAKE_CASE = F.group_norm(snake_case__ , self.num_groups , eps=self.eps ) SCREAMING_SNAKE_CASE = x * (1 + scale) + shift return x
703
def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 while n > 0: res += n % 10 n //= 10 return res def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = abs(_UpperCamelCase ) return n if n < 10 else n % 10 + sum_of_digits(n // 10 ) def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' return sum(int(_UpperCamelCase ) for c in str(abs(_UpperCamelCase ) ) ) def __lowerCAmelCase ( ) -> None: '''simple docstring''' from collections.abc import Callable from timeit import timeit def benchmark_a_function(_UpperCamelCase : Callable , _UpperCamelCase : int ) -> None: SCREAMING_SNAKE_CASE = f"""{func.__name__}({value})""" SCREAMING_SNAKE_CASE = timeit(f"""__main__.{call}""" , setup='import __main__' ) print(f"""{call:56} = {func(_UpperCamelCase )} -- {timing:.4f} seconds""" ) for value in (26_21_44, 11_25_89_99_06_84_26_24, 1_26_76_50_60_02_28_22_94_01_49_67_03_20_53_76): for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact): benchmark_a_function(_UpperCamelCase , _UpperCamelCase ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
673
0
import unittest from transformers import LiltConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( LiltForQuestionAnswering, LiltForSequenceClassification, LiltForTokenClassification, LiltModel, ) from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : int , snake_case__ : List[Any] , snake_case__ : str=1_3 , snake_case__ : Optional[Any]=7 , snake_case__ : str=True , snake_case__ : Optional[int]=True , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : Tuple=9_9 , snake_case__ : List[str]=2_4 , snake_case__ : Union[str, Any]=2 , snake_case__ : Union[str, Any]=6 , snake_case__ : List[str]=3_7 , snake_case__ : List[str]="gelu" , snake_case__ : List[str]=0.1 , snake_case__ : str=0.1 , snake_case__ : Any=5_1_2 , snake_case__ : Tuple=1_6 , snake_case__ : Any=2 , snake_case__ : List[Any]=0.02 , snake_case__ : Dict=3 , snake_case__ : Dict=None , snake_case__ : Optional[int]=1_0_0_0 , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = scope SCREAMING_SNAKE_CASE = range_bbox def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length, 4] , self.range_bbox ) # Ensure that bbox is legal for i in range(bbox.shape[0] ): for j in range(bbox.shape[1] ): if bbox[i, j, 3] < bbox[i, j, 1]: SCREAMING_SNAKE_CASE = bbox[i, j, 3] SCREAMING_SNAKE_CASE = bbox[i, j, 1] SCREAMING_SNAKE_CASE = t if bbox[i, j, 2] < bbox[i, j, 0]: SCREAMING_SNAKE_CASE = bbox[i, j, 2] SCREAMING_SNAKE_CASE = bbox[i, j, 0] SCREAMING_SNAKE_CASE = t SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels def UpperCamelCase ( self : Tuple ): """simple docstring""" return LiltConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Dict , snake_case__ : Any , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = LiltModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , bbox=snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , bbox=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , bbox=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def UpperCamelCase ( self : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = LiltForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , bbox=snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : Dict , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Tuple , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = LiltForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , bbox=snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = { 'input_ids': input_ids, 'bbox': bbox, 'token_type_ids': token_type_ids, 'attention_mask': input_mask, } return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( LiltModel, LiltForSequenceClassification, LiltForTokenClassification, LiltForQuestionAnswering, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": LiltModel, "question-answering": LiltForQuestionAnswering, "text-classification": LiltForSequenceClassification, "token-classification": LiltForTokenClassification, "zero-shot": LiltForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : Optional[Any] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" return True def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = LiltModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : str ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) @slow def UpperCamelCase ( self : List[Any] ): """simple docstring""" for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = LiltModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch @slow class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base' ).to(snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([[1, 2]] , device=snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]] , device=snake_case__ ) # forward pass with torch.no_grad(): SCREAMING_SNAKE_CASE = model(input_ids=snake_case__ , bbox=snake_case__ ) SCREAMING_SNAKE_CASE = torch.Size([1, 2, 7_6_8] ) SCREAMING_SNAKE_CASE = torch.tensor( [[-0.0_653, 0.0_950, -0.0_061], [-0.0_545, 0.0_926, -0.0_324]] , device=snake_case__ , ) self.assertTrue(outputs.last_hidden_state.shape , snake_case__ ) self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3] , snake_case__ , atol=1E-3 ) )
704
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
673
0
import logging import sys from dataclasses import dataclass, field from typing import Any, Dict, List, Optional, Union import librosa import torch from datasets import DatasetDict, load_dataset from packaging import version from torch import nn from transformers import ( HfArgumentParser, Trainer, TrainingArguments, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaForPreTraining, is_apex_available, trainer_utils, ) from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices if is_apex_available(): from apex import amp if version.parse(version.parse(torch.__version__).base_version) >= version.parse("1.6"): a_ : Optional[Any] = True from torch.cuda.amp import autocast a_ : str = logging.getLogger(__name__) @dataclass class UpperCamelCase : __UpperCamelCase =field( metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Whether to freeze the feature extractor layers of the model."} ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Whether to log verbose messages or not."} , ) __UpperCamelCase =field( default=2.0 , metadata={"help": "Maximum temperature for gumbel softmax."} ) __UpperCamelCase =field( default=0.5 , metadata={"help": "Minimum temperature for gumbel softmax."} ) __UpperCamelCase =field( default=0.999995 , metadata={"help": "Decay of gumbel temperature during training."} ) def __lowerCAmelCase ( _UpperCamelCase : ModelArguments , _UpperCamelCase : TrainingArguments ) -> Any: '''simple docstring''' logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) SCREAMING_SNAKE_CASE = logging.WARNING if model_args.verbose_logging: SCREAMING_SNAKE_CASE = logging.DEBUG elif trainer_utils.is_main_process(training_args.local_rank ): SCREAMING_SNAKE_CASE = logging.INFO logger.setLevel(_UpperCamelCase ) @dataclass class UpperCamelCase : __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "The name of the dataset to use (via the datasets library)."} ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} ) __UpperCamelCase =field( default="train" , metadata={ "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'" } , ) __UpperCamelCase =field( default="validation" , metadata={ "help": ( "The name of the validation data set split to use (via the datasets library). Defaults to 'validation'" ) } , ) __UpperCamelCase =field( default="file" , metadata={"help": "Column in the dataset that contains speech file path. Defaults to 'file'"} , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "Overwrite the cached preprocessed datasets or not."} ) __UpperCamelCase =field( default=1 , metadata={ "help": "The percentage of the train set used as validation set in case there's no validation split" } , ) __UpperCamelCase =field( default=SCREAMING_SNAKE_CASE , metadata={"help": "The number of processes to use for the preprocessing."} , ) __UpperCamelCase =field( default=20.0 , metadata={"help": "Filter audio files that are longer than `max_duration_in_seconds` seconds"} ) @dataclass class UpperCamelCase : __UpperCamelCase =42 __UpperCamelCase =42 __UpperCamelCase ="longest" __UpperCamelCase =None __UpperCamelCase =None def __call__( self : Tuple , snake_case__ : List[Dict[str, Union[List[int], torch.Tensor]]] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.feature_extractor.pad( snake_case__ , max_length=self.max_length , padding=self.padding , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = self.model._get_feat_extract_output_lengths(batch['input_values'].shape[-1] ) SCREAMING_SNAKE_CASE = batch['input_values'].shape[0] # make sure that no loss is computed on padded inputs if batch["attention_mask"] is not None: # compute real output lengths according to convolution formula SCREAMING_SNAKE_CASE = self.model._get_feat_extract_output_lengths(batch['attention_mask'].sum(-1 ) ).to( torch.long ) SCREAMING_SNAKE_CASE = torch.zeros( (batch_size, mask_indices_seq_length) , dtype=torch.long , device=batch['input_values'].device ) # these two operations makes sure that all values # before the output lengths indices are attended to SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = attention_mask.flip([-1] ).cumsum(-1 ).flip([-1] ).bool() # sample randomly masked indices SCREAMING_SNAKE_CASE = _compute_mask_indices( (batch_size, mask_indices_seq_length) , self.model.config.mask_time_prob , self.model.config.mask_time_length , attention_mask=snake_case__ , min_masks=2 , ) return batch class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Union[str, Any] , *snake_case__ : List[Any] , snake_case__ : Union[str, Any]=1 , snake_case__ : Any=0 , snake_case__ : Any=1.0 , **snake_case__ : Dict ): """simple docstring""" super().__init__(*snake_case__ , **snake_case__ ) SCREAMING_SNAKE_CASE = 0 SCREAMING_SNAKE_CASE = max_gumbel_temp SCREAMING_SNAKE_CASE = min_gumbel_temp SCREAMING_SNAKE_CASE = gumbel_temp_decay def UpperCamelCase ( self : Tuple , snake_case__ : nn.Module , snake_case__ : Dict[str, Union[torch.Tensor, Any]] ): """simple docstring""" model.train() SCREAMING_SNAKE_CASE = self._prepare_inputs(snake_case__ ) if self.use_amp: with autocast(): SCREAMING_SNAKE_CASE = self.compute_loss(snake_case__ , snake_case__ ) else: SCREAMING_SNAKE_CASE = self.compute_loss(snake_case__ , snake_case__ ) if self.args.n_gpu > 1 or self.deepspeed: if model.module.config.ctc_loss_reduction == "mean": SCREAMING_SNAKE_CASE = loss.mean() elif model.module.config.ctc_loss_reduction == "sum": SCREAMING_SNAKE_CASE = loss.sum() / (inputs['mask_time_indices']).sum() else: raise ValueError(F"""{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']""" ) if self.args.gradient_accumulation_steps > 1: SCREAMING_SNAKE_CASE = loss / self.args.gradient_accumulation_steps if self.use_amp: self.scaler.scale(snake_case__ ).backward() elif self.use_apex: with amp.scale_loss(snake_case__ , self.optimizer ) as scaled_loss: scaled_loss.backward() elif self.deepspeed: self.deepspeed.backward(snake_case__ ) else: loss.backward() self.num_update_step += 1 # make sure gumbel softmax temperature is decayed if self.args.n_gpu > 1 or self.deepspeed: model.module.set_gumbel_temperature( max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) ) else: model.set_gumbel_temperature( max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) ) return loss.detach() def __lowerCAmelCase ( ) -> str: '''simple docstring''' SCREAMING_SNAKE_CASE = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = parser.parse_args_into_dataclasses() configure_logger(_UpperCamelCase , _UpperCamelCase ) # Downloading and loading a dataset from the hub. SCREAMING_SNAKE_CASE = load_dataset(data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) if "validation" not in datasets.keys(): # make sure only "validation" and "train" keys remain" SCREAMING_SNAKE_CASE = DatasetDict() SCREAMING_SNAKE_CASE = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=f"""{data_args.train_split_name}[:{data_args.validation_split_percentage}%]""" , cache_dir=model_args.cache_dir , ) SCREAMING_SNAKE_CASE = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=f"""{data_args.train_split_name}[{data_args.validation_split_percentage}%:]""" , cache_dir=model_args.cache_dir , ) else: # make sure only "validation" and "train" keys remain" SCREAMING_SNAKE_CASE = DatasetDict() SCREAMING_SNAKE_CASE = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split='validation' , cache_dir=model_args.cache_dir , ) SCREAMING_SNAKE_CASE = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=f"""{data_args.train_split_name}""" , cache_dir=model_args.cache_dir , ) # only normalized-inputs-training is supported SCREAMING_SNAKE_CASE = WavaVecaFeatureExtractor.from_pretrained( model_args.model_name_or_path , cache_dir=model_args.cache_dir , do_normalize=_UpperCamelCase ) def prepare_dataset(_UpperCamelCase : str ): # check that all files have the correct sampling rate SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = librosa.load(batch[data_args.speech_file_column] , sr=feature_extractor.sampling_rate ) return batch # load audio files into numpy arrays SCREAMING_SNAKE_CASE = datasets.map( _UpperCamelCase , num_proc=data_args.preprocessing_num_workers , remove_columns=datasets['train'].column_names ) # filter audio files that are too long SCREAMING_SNAKE_CASE = vectorized_datasets.filter( lambda _UpperCamelCase : len(data['speech'] ) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate ) ) def normalize(_UpperCamelCase : Tuple ): return feature_extractor(batch['speech'] , sampling_rate=feature_extractor.sampling_rate ) # normalize and transform to `BatchFeatures` SCREAMING_SNAKE_CASE = vectorized_datasets.map( _UpperCamelCase , batched=_UpperCamelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , remove_columns=vectorized_datasets['train'].column_names , ) # pretraining is only supported for "newer" stable layer norm architecture # apply_spec_augment has to be True, mask_feature_prob has to be 0.0 SCREAMING_SNAKE_CASE = WavaVecaConfig.from_pretrained( model_args.model_name_or_path , cache_dir=model_args.cache_dir , gradient_checkpointing=training_args.gradient_checkpointing , ) if not config.do_stable_layer_norm or config.feat_extract_norm != "layer": raise ValueError( 'PreTraining is only supported for ``config.do_stable_layer_norm=True`` and' ' ``config.feat_extract_norm=\'layer\'' ) SCREAMING_SNAKE_CASE = WavaVecaForPreTraining(_UpperCamelCase ) SCREAMING_SNAKE_CASE = DataCollatorForWavaVecaPretraining(model=_UpperCamelCase , feature_extractor=_UpperCamelCase ) SCREAMING_SNAKE_CASE = WavaVecaPreTrainer( model=_UpperCamelCase , data_collator=_UpperCamelCase , args=_UpperCamelCase , train_dataset=vectorized_datasets['train'] , eval_dataset=vectorized_datasets['validation'] , tokenizer=_UpperCamelCase , max_gumbel_temp=model_args.max_gumbel_temperature , min_gumbel_temp=model_args.min_gumbel_temperature , gumbel_temp_decay=model_args.gumbel_temperature_decay , ) trainer.train() if __name__ == "__main__": main()
705
import gc import unittest import numpy as np import torch import torch.nn.functional as F from transformers import ( ClapTextConfig, ClapTextModelWithProjection, RobertaTokenizer, SpeechTaHifiGan, SpeechTaHifiGanConfig, ) from diffusers import ( AudioLDMPipeline, AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.utils import is_xformers_available, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =AudioLDMPipeline __UpperCamelCase =TEXT_TO_AUDIO_PARAMS __UpperCamelCase =TEXT_TO_AUDIO_BATCH_PARAMS __UpperCamelCase =frozenset( [ "num_inference_steps", "num_waveforms_per_prompt", "generator", "latents", "output_type", "return_dict", "callback", "callback_steps", ] ) def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=(3_2, 6_4) , class_embed_type='simple_projection' , projection_class_embeddings_input_dim=3_2 , class_embeddings_concat=snake_case__ , ) SCREAMING_SNAKE_CASE = DDIMScheduler( beta_start=0.00_085 , beta_end=0.012 , beta_schedule='scaled_linear' , clip_sample=snake_case__ , set_alpha_to_one=snake_case__ , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=1 , out_channels=1 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE = ClapTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , projection_dim=3_2 , ) SCREAMING_SNAKE_CASE = ClapTextModelWithProjection(snake_case__ ) SCREAMING_SNAKE_CASE = RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta' , model_max_length=7_7 ) SCREAMING_SNAKE_CASE = SpeechTaHifiGanConfig( model_in_dim=8 , sampling_rate=1_6_0_0_0 , upsample_initial_channel=1_6 , upsample_rates=[2, 2] , upsample_kernel_sizes=[4, 4] , resblock_kernel_sizes=[3, 7] , resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]] , normalize_before=snake_case__ , ) SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ) SCREAMING_SNAKE_CASE = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'vocoder': vocoder, } return components def UpperCamelCase ( self : Optional[int] , snake_case__ : int , snake_case__ : int=0 ): """simple docstring""" if str(snake_case__ ).startswith('mps' ): SCREAMING_SNAKE_CASE = torch.manual_seed(snake_case__ ) else: SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, } return inputs def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = prompt_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) SCREAMING_SNAKE_CASE = prompt_embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * ['this is a negative prompt'] SCREAMING_SNAKE_CASE = negative_prompt SCREAMING_SNAKE_CASE = 3 * [inputs['prompt']] # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 3 * [inputs.pop('prompt' )] SCREAMING_SNAKE_CASE = [] for p in [prompt, negative_prompt]: SCREAMING_SNAKE_CASE = audioldm_pipe.tokenizer( snake_case__ , padding='max_length' , max_length=audioldm_pipe.tokenizer.model_max_length , truncation=snake_case__ , return_tensors='pt' , ) SCREAMING_SNAKE_CASE = text_inputs['input_ids'].to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.text_encoder( snake_case__ , ) SCREAMING_SNAKE_CASE = text_embeds.text_embeds # additional L_2 normalization over each hidden-state SCREAMING_SNAKE_CASE = F.normalize(snake_case__ , dim=-1 ) embeds.append(snake_case__ ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = embeds # forward SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert np.abs(audio_a - audio_a ).max() < 1E-2 def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 'egg cracking' SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ , negative_prompt=snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 2_5_6 SCREAMING_SNAKE_CASE = audio[:1_0] SCREAMING_SNAKE_CASE = np.array( [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032] ) assert np.abs(audio_slice - expected_slice ).max() < 1E-2 def UpperCamelCase ( self : str ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = PNDMScheduler(skip_prk_steps=snake_case__ ) SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A hammer hitting a wooden surface' # test num_waveforms_per_prompt=1 (default) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 ).audios assert audios.shape == (1, 2_5_6) # test num_waveforms_per_prompt=1 (default) for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe([prompt] * batch_size , num_inference_steps=2 ).audios assert audios.shape == (batch_size, 2_5_6) # test num_waveforms_per_prompt for single prompt SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (num_waveforms_per_prompt, 2_5_6) # test num_waveforms_per_prompt for batch of prompts SCREAMING_SNAKE_CASE = 2 SCREAMING_SNAKE_CASE = audioldm_pipe( [prompt] * batch_size , num_inference_steps=2 , num_waveforms_per_prompt=snake_case__ ).audios assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = 'cpu' # ensure determinism for the device-dependent torch.Generator SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config.sampling_rate SCREAMING_SNAKE_CASE = self.get_dummy_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.016 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.016 SCREAMING_SNAKE_CASE = audioldm_pipe(audio_length_in_s=0.032 , **snake_case__ ) SCREAMING_SNAKE_CASE = output.audios[0] assert audio.ndim == 1 assert len(snake_case__ ) / vocoder_sampling_rate == 0.032 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.get_dummy_components() SCREAMING_SNAKE_CASE = AudioLDMPipeline(**snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = ['hey'] SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape assert audio_shape == (1, 2_5_6) SCREAMING_SNAKE_CASE = audioldm_pipe.vocoder.config config.model_in_dim *= 2 SCREAMING_SNAKE_CASE = SpeechTaHifiGan(snake_case__ ).to(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(snake_case__ , num_inference_steps=1 ) SCREAMING_SNAKE_CASE = output.audios.shape # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram assert audio_shape == (1, 2_5_6) def UpperCamelCase ( self : Tuple ): """simple docstring""" self._test_attention_slicing_forward_pass(test_mean_pixel_difference=snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" self._test_inference_batch_single_identical(test_mean_pixel_difference=snake_case__ ) @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def UpperCamelCase ( self : Dict ): """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=snake_case__ ) @slow class UpperCamelCase ( unittest.TestCase ): def UpperCamelCase ( self : Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self : int , snake_case__ : int , snake_case__ : Tuple="cpu" , snake_case__ : List[str]=torch.floataa , snake_case__ : Optional[Any]=0 ): """simple docstring""" SCREAMING_SNAKE_CASE = torch.Generator(device=snake_case__ ).manual_seed(snake_case__ ) SCREAMING_SNAKE_CASE = np.random.RandomState(snake_case__ ).standard_normal((1, 8, 1_2_8, 1_6) ) SCREAMING_SNAKE_CASE = torch.from_numpy(snake_case__ ).to(device=snake_case__ , dtype=snake_case__ ) SCREAMING_SNAKE_CASE = { 'prompt': 'A hammer hitting a wooden surface', 'latents': latents, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 2.5, } return inputs def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = 2_5 SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[7_7_2_3_0:7_7_2_4_0] SCREAMING_SNAKE_CASE = np.array( [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 1E-2 def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = AudioLDMPipeline.from_pretrained('cvssp/audioldm' ) SCREAMING_SNAKE_CASE = LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config ) SCREAMING_SNAKE_CASE = audioldm_pipe.to(snake_case__ ) audioldm_pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = self.get_inputs(snake_case__ ) SCREAMING_SNAKE_CASE = audioldm_pipe(**snake_case__ ).audios[0] assert audio.ndim == 1 assert len(snake_case__ ) == 8_1_9_2_0 SCREAMING_SNAKE_CASE = audio[2_7_7_8_0:2_7_7_9_0] SCREAMING_SNAKE_CASE = np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212] ) SCREAMING_SNAKE_CASE = np.abs(expected_slice - audio_slice ).max() assert max_diff < 3E-2
673
0
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging a_ : Tuple = logging.get_logger(__name__) a_ : Tuple = { "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 ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="roberta" def __init__( self : Any , snake_case__ : List[Any]=5_0_2_6_5 , snake_case__ : Tuple=7_6_8 , snake_case__ : Any=1_2 , snake_case__ : List[str]=1_2 , snake_case__ : Dict=3_0_7_2 , snake_case__ : Dict="gelu" , snake_case__ : int=0.1 , snake_case__ : Optional[Any]=0.1 , snake_case__ : Dict=5_1_2 , snake_case__ : int=2 , snake_case__ : List[Any]=0.02 , snake_case__ : List[Any]=1E-12 , snake_case__ : Union[str, Any]=1 , snake_case__ : int=0 , snake_case__ : str=2 , snake_case__ : List[Any]="absolute" , snake_case__ : Tuple=True , snake_case__ : List[Any]=None , **snake_case__ : str , ): """simple docstring""" super().__init__(pad_token_id=snake_case__ , bos_token_id=snake_case__ , eos_token_id=snake_case__ , **snake_case__ ) SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = position_embedding_type SCREAMING_SNAKE_CASE = use_cache SCREAMING_SNAKE_CASE = classifier_dropout class UpperCamelCase ( SCREAMING_SNAKE_CASE ): @property def UpperCamelCase ( self : Any ): """simple docstring""" if self.task == "multiple-choice": SCREAMING_SNAKE_CASE = {0: 'batch', 1: 'choice', 2: 'sequence'} else: SCREAMING_SNAKE_CASE = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
706
import unittest from parameterized import parameterized from transformers import OpenLlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel class UpperCamelCase : def __init__( self : Dict , snake_case__ : str , snake_case__ : str=1_3 , snake_case__ : Tuple=7 , snake_case__ : Tuple=True , snake_case__ : Tuple=True , snake_case__ : List[str]=False , snake_case__ : Any=True , snake_case__ : Union[str, Any]=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Optional[Any]=5 , snake_case__ : Optional[Any]=4 , snake_case__ : Union[str, Any]=3_7 , snake_case__ : Tuple="gelu" , snake_case__ : Dict=0.1 , snake_case__ : Any=0.1 , snake_case__ : int=5_1_2 , snake_case__ : Dict=1_6 , snake_case__ : str=2 , snake_case__ : Any=0.02 , snake_case__ : List[str]=3 , snake_case__ : int=4 , snake_case__ : List[str]=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Dict ): """simple docstring""" return OpenLlamaConfig( 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=snake_case__ , initializer_range=self.initializer_range , use_stable_embedding=snake_case__ , ) def UpperCamelCase ( self : int , snake_case__ : Tuple , snake_case__ : str , snake_case__ : Optional[Any] , snake_case__ : Union[str, Any] , snake_case__ : List[str] , snake_case__ : Any , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Dict , snake_case__ : List[Any] , snake_case__ : str , snake_case__ : str , snake_case__ : int , snake_case__ : Union[str, Any] , snake_case__ : Optional[int] , snake_case__ : List[Any] , snake_case__ : str , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : Dict , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : int , snake_case__ : List[str] , snake_case__ : Optional[Any] , snake_case__ : Optional[Any] , snake_case__ : Optional[int] , snake_case__ : Optional[int] , snake_case__ : Tuple , ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Optional[int] , snake_case__ : Union[str, Any] , snake_case__ : List[Any] , snake_case__ : Any , snake_case__ : int , snake_case__ : Any , snake_case__ : Union[str, Any] , snake_case__ : int , snake_case__ : str , snake_case__ : Union[str, Any] , ): """simple docstring""" SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = OpenLlamaForCausalLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() # first forward pass SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , use_cache=snake_case__ , ) SCREAMING_SNAKE_CASE = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and SCREAMING_SNAKE_CASE = torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE = torch.cat([input_mask, next_mask] , dim=-1 ) SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , encoder_hidden_states=snake_case__ , encoder_attention_mask=snake_case__ , past_key_values=snake_case__ , output_hidden_states=snake_case__ , )['hidden_states'][0] # select random slice SCREAMING_SNAKE_CASE = ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE = output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-3 ) ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else () ) __UpperCamelCase =(OpenLlamaForCausalLM,) if is_torch_available() else () __UpperCamelCase =( { "feature-extraction": OpenLlamaModel, "text-classification": OpenLlamaForSequenceClassification, "text-generation": OpenLlamaForCausalLM, "zero-shot": OpenLlamaForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = OpenLlamaModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'single_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = 3 SCREAMING_SNAKE_CASE = 'multi_label_classification' SCREAMING_SNAKE_CASE = input_dict['input_ids'] SCREAMING_SNAKE_CASE = input_ids.ne(1 ).to(snake_case__ ) SCREAMING_SNAKE_CASE = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) SCREAMING_SNAKE_CASE = OpenLlamaForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , labels=snake_case__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test' ) def UpperCamelCase ( self : Optional[int] ): """simple docstring""" pass @parameterized.expand([('linear',), ('dynamic',)] ) def UpperCamelCase ( self : str , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE = ids_tensor([1, 1_0] , config.vocab_size ) SCREAMING_SNAKE_CASE = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) original_model.to(snake_case__ ) original_model.eval() SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = original_model(snake_case__ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights SCREAMING_SNAKE_CASE = {'type': scaling_type, 'factor': 10.0} SCREAMING_SNAKE_CASE = OpenLlamaModel(snake_case__ ) scaled_model.to(snake_case__ ) scaled_model.eval() SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state SCREAMING_SNAKE_CASE = scaled_model(snake_case__ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) else: self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case__ , snake_case__ , atol=1E-5 ) )
673
0
import unittest import numpy as np from diffusers import LMSDiscreteScheduler, OnnxStableDiffusionInpaintPipeline 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 ( SCREAMING_SNAKE_CASE , unittest.TestCase ): # FIXME: add fast tests pass @nightly @require_onnxruntime @require_torch_gpu class UpperCamelCase ( unittest.TestCase ): @property def UpperCamelCase ( self : Optional[int] ): """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = ort.SessionOptions() SCREAMING_SNAKE_CASE = False return options def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/in_paint/overture-creations-5sI6fQgYIuo.png' ) SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/in_paint/overture-creations-5sI6fQgYIuo_mask.png' ) SCREAMING_SNAKE_CASE = OnnxStableDiffusionInpaintPipeline.from_pretrained( 'runwayml/stable-diffusion-inpainting' , revision='onnx' , safety_checker=snake_case__ , feature_extractor=snake_case__ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A red cat sitting on a park bench' SCREAMING_SNAKE_CASE = np.random.RandomState(0 ) SCREAMING_SNAKE_CASE = pipe( prompt=snake_case__ , image=snake_case__ , mask_image=snake_case__ , guidance_scale=7.5 , num_inference_steps=1_0 , generator=snake_case__ , output_type='np' , ) SCREAMING_SNAKE_CASE = output.images SCREAMING_SNAKE_CASE = images[0, 2_5_5:2_5_8, 2_5_5:2_5_8, -1] assert images.shape == (1, 5_1_2, 5_1_2, 3) SCREAMING_SNAKE_CASE = np.array([0.2_514, 0.3_007, 0.3_517, 0.1_790, 0.2_382, 0.3_167, 0.1_944, 0.2_273, 0.2_464] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/in_paint/overture-creations-5sI6fQgYIuo.png' ) SCREAMING_SNAKE_CASE = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/in_paint/overture-creations-5sI6fQgYIuo_mask.png' ) SCREAMING_SNAKE_CASE = LMSDiscreteScheduler.from_pretrained( 'runwayml/stable-diffusion-inpainting' , subfolder='scheduler' , revision='onnx' ) SCREAMING_SNAKE_CASE = OnnxStableDiffusionInpaintPipeline.from_pretrained( 'runwayml/stable-diffusion-inpainting' , revision='onnx' , scheduler=snake_case__ , safety_checker=snake_case__ , feature_extractor=snake_case__ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=snake_case__ ) SCREAMING_SNAKE_CASE = 'A red cat sitting on a park bench' SCREAMING_SNAKE_CASE = np.random.RandomState(0 ) SCREAMING_SNAKE_CASE = pipe( prompt=snake_case__ , image=snake_case__ , mask_image=snake_case__ , guidance_scale=7.5 , num_inference_steps=2_0 , generator=snake_case__ , output_type='np' , ) SCREAMING_SNAKE_CASE = output.images SCREAMING_SNAKE_CASE = images[0, 2_5_5:2_5_8, 2_5_5:2_5_8, -1] assert images.shape == (1, 5_1_2, 5_1_2, 3) SCREAMING_SNAKE_CASE = np.array([0.0_086, 0.0_077, 0.0_083, 0.0_093, 0.0_107, 0.0_139, 0.0_094, 0.0_097, 0.0_125] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3
707
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="openai/whisper-base" __UpperCamelCase =( "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the " "transcribed text." ) __UpperCamelCase ="transcriber" __UpperCamelCase =WhisperProcessor __UpperCamelCase =WhisperForConditionalGeneration __UpperCamelCase =["audio"] __UpperCamelCase =["text"] def UpperCamelCase ( self : Dict , snake_case__ : Tuple ): """simple docstring""" return self.pre_processor(snake_case__ , return_tensors='pt' ).input_features def UpperCamelCase ( self : Optional[int] , snake_case__ : Tuple ): """simple docstring""" return self.model.generate(inputs=snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : Union[str, Any] ): """simple docstring""" return self.pre_processor.batch_decode(snake_case__ , skip_special_tokens=snake_case__ )[0]
673
0
from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( OPENAI_CLIP_MEAN, OPENAI_CLIP_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL a_ : int = logging.get_logger(__name__) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =["pixel_values"] def __init__( self : Union[str, Any] , snake_case__ : bool = True , snake_case__ : Dict[str, int] = None , snake_case__ : PILImageResampling = PILImageResampling.BICUBIC , snake_case__ : bool = True , snake_case__ : Union[int, float] = 1 / 2_5_5 , snake_case__ : bool = True , snake_case__ : Optional[Union[float, List[float]]] = None , snake_case__ : Optional[Union[float, List[float]]] = None , snake_case__ : bool = True , **snake_case__ : Union[str, Any] , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = size if size is not None else {'height': 3_8_4, 'width': 3_8_4} SCREAMING_SNAKE_CASE = get_size_dict(snake_case__ , default_to_square=snake_case__ ) SCREAMING_SNAKE_CASE = do_resize SCREAMING_SNAKE_CASE = size SCREAMING_SNAKE_CASE = resample SCREAMING_SNAKE_CASE = do_rescale SCREAMING_SNAKE_CASE = rescale_factor SCREAMING_SNAKE_CASE = do_normalize SCREAMING_SNAKE_CASE = image_mean if image_mean is not None else OPENAI_CLIP_MEAN SCREAMING_SNAKE_CASE = image_std if image_std is not None else OPENAI_CLIP_STD SCREAMING_SNAKE_CASE = do_convert_rgb def UpperCamelCase ( self : Dict , snake_case__ : np.ndarray , snake_case__ : Dict[str, int] , snake_case__ : PILImageResampling = PILImageResampling.BICUBIC , snake_case__ : Optional[Union[str, ChannelDimension]] = None , **snake_case__ : Dict , ): """simple docstring""" SCREAMING_SNAKE_CASE = get_size_dict(snake_case__ , default_to_square=snake_case__ ) if "height" not in size or "width" not in size: raise ValueError(F"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}""" ) SCREAMING_SNAKE_CASE = (size['height'], size['width']) return resize(snake_case__ , size=snake_case__ , resample=snake_case__ , data_format=snake_case__ , **snake_case__ ) def UpperCamelCase ( self : str , snake_case__ : np.ndarray , snake_case__ : Union[int, float] , snake_case__ : Optional[Union[str, ChannelDimension]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" return rescale(snake_case__ , scale=snake_case__ , data_format=snake_case__ , **snake_case__ ) def UpperCamelCase ( self : Tuple , snake_case__ : np.ndarray , snake_case__ : Union[float, List[float]] , snake_case__ : Union[float, List[float]] , snake_case__ : Optional[Union[str, ChannelDimension]] = None , **snake_case__ : int , ): """simple docstring""" return normalize(snake_case__ , mean=snake_case__ , std=snake_case__ , data_format=snake_case__ , **snake_case__ ) def UpperCamelCase ( self : List[Any] , snake_case__ : ImageInput , snake_case__ : Optional[bool] = None , snake_case__ : Optional[Dict[str, int]] = None , snake_case__ : PILImageResampling = None , snake_case__ : Optional[bool] = None , snake_case__ : Optional[float] = None , snake_case__ : Optional[bool] = None , snake_case__ : Optional[Union[float, List[float]]] = None , snake_case__ : Optional[Union[float, List[float]]] = None , snake_case__ : Optional[Union[str, TensorType]] = None , snake_case__ : bool = None , snake_case__ : ChannelDimension = ChannelDimension.FIRST , **snake_case__ : Any , ): """simple docstring""" SCREAMING_SNAKE_CASE = do_resize if do_resize is not None else self.do_resize SCREAMING_SNAKE_CASE = resample if resample is not None else self.resample SCREAMING_SNAKE_CASE = do_rescale if do_rescale is not None else self.do_rescale SCREAMING_SNAKE_CASE = rescale_factor if rescale_factor is not None else self.rescale_factor SCREAMING_SNAKE_CASE = do_normalize if do_normalize is not None else self.do_normalize SCREAMING_SNAKE_CASE = image_mean if image_mean is not None else self.image_mean SCREAMING_SNAKE_CASE = image_std if image_std is not None else self.image_std SCREAMING_SNAKE_CASE = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb SCREAMING_SNAKE_CASE = size if size is not None else self.size SCREAMING_SNAKE_CASE = get_size_dict(snake_case__ , default_to_square=snake_case__ ) SCREAMING_SNAKE_CASE = make_list_of_images(snake_case__ ) if not valid_images(snake_case__ ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) if do_resize and size is None or resample is None: raise ValueError('Size and resample must be specified if do_resize is True.' ) if do_rescale and rescale_factor is None: raise ValueError('Rescale factor must be specified if do_rescale is True.' ) if do_normalize and (image_mean is None or image_std is None): raise ValueError('Image mean and std must be specified if do_normalize is True.' ) # PIL RGBA images are converted to RGB if do_convert_rgb: SCREAMING_SNAKE_CASE = [convert_to_rgb(snake_case__ ) for image in images] # All transformations expect numpy arrays. SCREAMING_SNAKE_CASE = [to_numpy_array(snake_case__ ) for image in images] if do_resize: SCREAMING_SNAKE_CASE = [self.resize(image=snake_case__ , size=snake_case__ , resample=snake_case__ ) for image in images] if do_rescale: SCREAMING_SNAKE_CASE = [self.rescale(image=snake_case__ , scale=snake_case__ ) for image in images] if do_normalize: SCREAMING_SNAKE_CASE = [self.normalize(image=snake_case__ , mean=snake_case__ , std=snake_case__ ) for image in images] SCREAMING_SNAKE_CASE = [to_channel_dimension_format(snake_case__ , snake_case__ ) for image in images] SCREAMING_SNAKE_CASE = BatchFeature(data={'pixel_values': images} , tensor_type=snake_case__ ) return encoded_outputs
708
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version a_ : List[str] = version.parse(importlib_metadata.version("nltk")) if NLTK_VERSION >= version.Version("3.6.4"): from nltk import word_tokenize a_ : Dict = "\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n" a_ : str = "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n" a_ : int = "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n 'meteor': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric('meteor')\n >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results[\"meteor\"], 4))\n 0.6944\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCamelCase ( datasets.Metric ): def UpperCamelCase ( self : str ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def UpperCamelCase ( self : Dict , snake_case__ : int ): """simple docstring""" import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : str , snake_case__ : List[Any] , snake_case__ : List[Any]=0.9 , snake_case__ : Optional[Any]=3 , snake_case__ : Any=0.5 ): """simple docstring""" if NLTK_VERSION >= version.Version('3.6.5' ): SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score( word_tokenize(snake_case__ ) , word_tokenize(snake_case__ ) , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] else: SCREAMING_SNAKE_CASE = [ meteor_score.single_meteor_score(snake_case__ , snake_case__ , alpha=snake_case__ , beta=snake_case__ , gamma=snake_case__ ) for ref, pred in zip(snake_case__ , snake_case__ ) ] return {"meteor": np.mean(snake_case__ )}
673
0
import copy from typing import Any, Dict, List, Optional, Union import numpy as np import torch from ...audio_utils import mel_filter_bank, spectrogram, window_function from ...feature_extraction_sequence_utils import SequenceFeatureExtractor from ...feature_extraction_utils import BatchFeature from ...utils import TensorType, logging a_ : str = logging.get_logger(__name__) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =["input_features", "is_longer"] def __init__( self : int , snake_case__ : List[Any]=6_4 , snake_case__ : Any=4_8_0_0_0 , snake_case__ : Tuple=4_8_0 , snake_case__ : Union[str, Any]=1_0 , snake_case__ : Dict=1_0_2_4 , snake_case__ : str=0.0 , snake_case__ : Any=False , snake_case__ : float = 0 , snake_case__ : float = 1_4_0_0_0 , snake_case__ : int = None , snake_case__ : str = "fusion" , snake_case__ : str = "repeatpad" , **snake_case__ : List[Any] , ): """simple docstring""" super().__init__( feature_size=snake_case__ , sampling_rate=snake_case__ , padding_value=snake_case__ , return_attention_mask=snake_case__ , **snake_case__ , ) SCREAMING_SNAKE_CASE = top_db SCREAMING_SNAKE_CASE = truncation SCREAMING_SNAKE_CASE = padding SCREAMING_SNAKE_CASE = fft_window_size SCREAMING_SNAKE_CASE = (fft_window_size >> 1) + 1 SCREAMING_SNAKE_CASE = hop_length SCREAMING_SNAKE_CASE = max_length_s SCREAMING_SNAKE_CASE = max_length_s * sampling_rate SCREAMING_SNAKE_CASE = sampling_rate SCREAMING_SNAKE_CASE = frequency_min SCREAMING_SNAKE_CASE = frequency_max SCREAMING_SNAKE_CASE = mel_filter_bank( num_frequency_bins=self.nb_frequency_bins , num_mel_filters=snake_case__ , min_frequency=snake_case__ , max_frequency=snake_case__ , sampling_rate=snake_case__ , norm=snake_case__ , mel_scale='htk' , ) SCREAMING_SNAKE_CASE = mel_filter_bank( num_frequency_bins=self.nb_frequency_bins , num_mel_filters=snake_case__ , min_frequency=snake_case__ , max_frequency=snake_case__ , sampling_rate=snake_case__ , norm='slaney' , mel_scale='slaney' , ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = copy.deepcopy(self.__dict__ ) SCREAMING_SNAKE_CASE = self.__class__.__name__ if "mel_filters" in output: del output["mel_filters"] if "mel_filters_slaney" in output: del output["mel_filters_slaney"] return output def UpperCamelCase ( self : str , snake_case__ : np.array , snake_case__ : Optional[np.array] = None ): """simple docstring""" SCREAMING_SNAKE_CASE = spectrogram( snake_case__ , window_function(self.fft_window_size , 'hann' ) , frame_length=self.fft_window_size , hop_length=self.hop_length , power=2.0 , mel_filters=snake_case__ , log_mel='dB' , ) return log_mel_spectrogram.T def UpperCamelCase ( self : str , snake_case__ : Any , snake_case__ : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = np.array_split(list(range(0 , total_frames - chunk_frames + 1 ) ) , 3 ) if len(ranges[1] ) == 0: # if the audio is too short, we just use the first chunk SCREAMING_SNAKE_CASE = [0] if len(ranges[2] ) == 0: # if the audio is too short, we just use the first chunk SCREAMING_SNAKE_CASE = [0] # randomly choose index for each part SCREAMING_SNAKE_CASE = np.random.choice(ranges[0] ) SCREAMING_SNAKE_CASE = np.random.choice(ranges[1] ) SCREAMING_SNAKE_CASE = np.random.choice(ranges[2] ) SCREAMING_SNAKE_CASE = mel[idx_front : idx_front + chunk_frames, :] SCREAMING_SNAKE_CASE = mel[idx_middle : idx_middle + chunk_frames, :] SCREAMING_SNAKE_CASE = mel[idx_back : idx_back + chunk_frames, :] SCREAMING_SNAKE_CASE = torch.tensor(mel[None, None, :] ) SCREAMING_SNAKE_CASE = torch.nn.functional.interpolate( snake_case__ , size=[chunk_frames, 6_4] , mode='bilinear' , align_corners=snake_case__ ) SCREAMING_SNAKE_CASE = mel_shrink[0][0].numpy() SCREAMING_SNAKE_CASE = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] , axis=0 ) return mel_fusion def UpperCamelCase ( self : Tuple , snake_case__ : np.array , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : str ): """simple docstring""" if waveform.shape[0] > max_length: if truncation == "rand_trunc": SCREAMING_SNAKE_CASE = True # random crop to max_length (for compatibility) -> this should be handled by self.pad SCREAMING_SNAKE_CASE = len(snake_case__ ) - max_length SCREAMING_SNAKE_CASE = np.random.randint(0 , overflow + 1 ) SCREAMING_SNAKE_CASE = waveform[idx : idx + max_length] SCREAMING_SNAKE_CASE = self._np_extract_fbank_features(snake_case__ , self.mel_filters_slaney )[None, :] elif truncation == "fusion": SCREAMING_SNAKE_CASE = self._np_extract_fbank_features(snake_case__ , self.mel_filters ) SCREAMING_SNAKE_CASE = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed SCREAMING_SNAKE_CASE = mel.shape[0] if chunk_frames == total_frames: # there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length. # In this case, we just use the whole audio. SCREAMING_SNAKE_CASE = np.stack([mel, mel, mel, mel] , axis=0 ) SCREAMING_SNAKE_CASE = False else: SCREAMING_SNAKE_CASE = self._random_mel_fusion(snake_case__ , snake_case__ , snake_case__ ) SCREAMING_SNAKE_CASE = True else: raise NotImplementedError(F"""data_truncating {truncation} not implemented""" ) else: SCREAMING_SNAKE_CASE = False # only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding if waveform.shape[0] < max_length: if padding == "repeat": SCREAMING_SNAKE_CASE = int(max_length / len(snake_case__ ) ) SCREAMING_SNAKE_CASE = np.stack(np.tile(snake_case__ , n_repeat + 1 ) )[:max_length] if padding == "repeatpad": SCREAMING_SNAKE_CASE = int(max_length / len(snake_case__ ) ) SCREAMING_SNAKE_CASE = np.stack(np.tile(snake_case__ , snake_case__ ) ) SCREAMING_SNAKE_CASE = np.pad(snake_case__ , (0, max_length - waveform.shape[0]) , mode='constant' , constant_values=0 ) if truncation == "fusion": SCREAMING_SNAKE_CASE = self._np_extract_fbank_features(snake_case__ , self.mel_filters ) SCREAMING_SNAKE_CASE = np.stack([input_mel, input_mel, input_mel, input_mel] , axis=0 ) else: SCREAMING_SNAKE_CASE = self._np_extract_fbank_features(snake_case__ , self.mel_filters_slaney )[None, :] return input_mel, longer def __call__( self : Optional[int] , snake_case__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] , snake_case__ : str = None , snake_case__ : Optional[str] = None , snake_case__ : Optional[int] = None , snake_case__ : Optional[int] = None , snake_case__ : Optional[Union[str, TensorType]] = None , **snake_case__ : List[str] , ): """simple docstring""" SCREAMING_SNAKE_CASE = truncation if truncation is not None else self.truncation SCREAMING_SNAKE_CASE = padding if padding else self.padding if sampling_rate is not None: if sampling_rate != self.sampling_rate: raise ValueError( F"""The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a""" F""" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input""" F""" was sampled with {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.' ) SCREAMING_SNAKE_CASE = isinstance(snake_case__ , 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}""" ) SCREAMING_SNAKE_CASE = is_batched_numpy or ( isinstance(snake_case__ , (list, tuple) ) and (isinstance(raw_speech[0] , (np.ndarray, tuple, list) )) ) if is_batched: SCREAMING_SNAKE_CASE = [np.asarray(snake_case__ , dtype=np.floataa ) for speech in raw_speech] elif not is_batched and not isinstance(snake_case__ , np.ndarray ): SCREAMING_SNAKE_CASE = np.asarray(snake_case__ , dtype=np.floataa ) elif isinstance(snake_case__ , np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ): SCREAMING_SNAKE_CASE = raw_speech.astype(np.floataa ) # always return batch if not is_batched: SCREAMING_SNAKE_CASE = [np.asarray(snake_case__ )] # convert to mel spectrogram, truncate and pad if needed. SCREAMING_SNAKE_CASE = [ self._get_input_mel(snake_case__ , max_length if max_length else self.nb_max_samples , snake_case__ , snake_case__ ) for waveform in raw_speech ] SCREAMING_SNAKE_CASE = [] SCREAMING_SNAKE_CASE = [] for mel, longer in padded_inputs: input_mel.append(snake_case__ ) is_longer.append(snake_case__ ) if truncation == "fusion" and sum(snake_case__ ) == 0: # if no audio is longer than 10s, then randomly select one audio to be longer SCREAMING_SNAKE_CASE = np.random.randint(0 , len(snake_case__ ) ) SCREAMING_SNAKE_CASE = True if isinstance(input_mel[0] , snake_case__ ): SCREAMING_SNAKE_CASE = [np.asarray(snake_case__ , dtype=np.floataa ) for feature in input_mel] # is_longer is a list of bool SCREAMING_SNAKE_CASE = [[longer] for longer in is_longer] SCREAMING_SNAKE_CASE = {'input_features': input_mel, 'is_longer': is_longer} SCREAMING_SNAKE_CASE = BatchFeature(snake_case__ ) if return_tensors is not None: SCREAMING_SNAKE_CASE = input_features.convert_to_tensors(snake_case__ ) return input_features
709
import numpy as np def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return 1 / (1 + np.exp(-vector )) def __lowerCAmelCase ( _UpperCamelCase : np.ndarray ) -> np.ndarray: '''simple docstring''' return vector * sigmoid(_UpperCamelCase ) if __name__ == "__main__": import doctest doctest.testmod()
673
0
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
710
from ....configuration_utils import PretrainedConfig from ....utils import logging a_ : Any = logging.get_logger(__name__) a_ : Dict = { "Visual-Attention-Network/van-base": ( "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json" ), } class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="van" def __init__( self : Optional[Any] , snake_case__ : Tuple=2_2_4 , snake_case__ : Dict=3 , snake_case__ : Union[str, Any]=[7, 3, 3, 3] , snake_case__ : str=[4, 2, 2, 2] , snake_case__ : Optional[Any]=[6_4, 1_2_8, 3_2_0, 5_1_2] , snake_case__ : Optional[Any]=[3, 3, 1_2, 3] , snake_case__ : Tuple=[8, 8, 4, 4] , snake_case__ : Any="gelu" , snake_case__ : Dict=0.02 , snake_case__ : List[str]=1E-6 , snake_case__ : int=1E-2 , snake_case__ : Any=0.0 , snake_case__ : Tuple=0.0 , **snake_case__ : Any , ): """simple docstring""" super().__init__(**snake_case__ ) SCREAMING_SNAKE_CASE = image_size SCREAMING_SNAKE_CASE = num_channels SCREAMING_SNAKE_CASE = patch_sizes SCREAMING_SNAKE_CASE = strides SCREAMING_SNAKE_CASE = hidden_sizes SCREAMING_SNAKE_CASE = depths SCREAMING_SNAKE_CASE = mlp_ratios SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = layer_norm_eps SCREAMING_SNAKE_CASE = layer_scale_init_value SCREAMING_SNAKE_CASE = drop_path_rate SCREAMING_SNAKE_CASE = dropout_rate
673
0
import argparse import logging import os import re import tensorflow as tf from transformers import ( AutoConfig, AutoTokenizer, DataCollatorForLanguageModeling, PushToHubCallback, TFAutoModelForMaskedLM, create_optimizer, ) a_ : Optional[int] = logging.getLogger(__name__) a_ : Any = tf.data.AUTOTUNE def __lowerCAmelCase ( ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE = argparse.ArgumentParser(description='Train a masked language model on TPU.' ) parser.add_argument( '--pretrained_model_config' , type=_UpperCamelCase , default='roberta-base' , help='The model config to use. Note that we don\'t copy the model\'s weights, only the config!' , ) parser.add_argument( '--tokenizer' , type=_UpperCamelCase , default='unigram-tokenizer-wikitext' , help='The name of the tokenizer to load. We use the pretrained tokenizer to initialize the model\'s vocab size.' , ) parser.add_argument( '--per_replica_batch_size' , type=_UpperCamelCase , default=8 , help='Batch size per TPU core.' , ) parser.add_argument( '--no_tpu' , action='store_true' , help='If set, run on CPU and don\'t try to initialize a TPU. Useful for debugging on non-TPU instances.' , ) parser.add_argument( '--tpu_name' , type=_UpperCamelCase , help='Name of TPU resource to initialize. Should be blank on Colab, and \'local\' on TPU VMs.' , default='local' , ) parser.add_argument( '--tpu_zone' , type=_UpperCamelCase , help='Google cloud zone that TPU resource is located in. Only used for non-Colab TPU nodes.' , ) parser.add_argument( '--gcp_project' , type=_UpperCamelCase , help='Google cloud project name. Only used for non-Colab TPU nodes.' ) parser.add_argument( '--bfloat16' , action='store_true' , help='Use mixed-precision bfloat16 for training. This is the recommended lower-precision format for TPU.' , ) parser.add_argument( '--train_dataset' , type=_UpperCamelCase , help='Path to training dataset to load. If the path begins with `gs://`' ' then the dataset will be loaded from a Google Cloud Storage bucket.' , ) parser.add_argument( '--shuffle_buffer_size' , type=_UpperCamelCase , default=2**18 , help='Size of the shuffle buffer (in samples)' , ) parser.add_argument( '--eval_dataset' , type=_UpperCamelCase , help='Path to evaluation dataset to load. If the path begins with `gs://`' ' then the dataset will be loaded from a Google Cloud Storage bucket.' , ) parser.add_argument( '--num_epochs' , type=_UpperCamelCase , default=1 , help='Number of epochs to train for.' , ) parser.add_argument( '--learning_rate' , type=_UpperCamelCase , default=1e-4 , help='Learning rate to use for training.' , ) parser.add_argument( '--weight_decay_rate' , type=_UpperCamelCase , default=1e-3 , help='Weight decay rate to use for training.' , ) parser.add_argument( '--max_length' , type=_UpperCamelCase , default=5_12 , help='Maximum length of tokenized sequences. Should match the setting used in prepare_tfrecord_shards.py' , ) parser.add_argument( '--mlm_probability' , type=_UpperCamelCase , default=0.15 , help='Fraction of tokens to mask during training.' , ) parser.add_argument('--output_dir' , type=_UpperCamelCase , required=_UpperCamelCase , help='Path to save model checkpoints to.' ) parser.add_argument('--hub_model_id' , type=_UpperCamelCase , help='Model ID to upload to on the Hugging Face Hub.' ) SCREAMING_SNAKE_CASE = parser.parse_args() return args def __lowerCAmelCase ( _UpperCamelCase : str ) -> int: '''simple docstring''' try: if args.tpu_name: SCREAMING_SNAKE_CASE = tf.distribute.cluster_resolver.TPUClusterResolver( args.tpu_name , zone=args.tpu_zone , project=args.gcp_project ) else: SCREAMING_SNAKE_CASE = tf.distribute.cluster_resolver.TPUClusterResolver() except ValueError: raise RuntimeError( 'Couldn\'t connect to TPU! Most likely you need to specify --tpu_name, --tpu_zone, or ' '--gcp_project. When running on a TPU VM, use --tpu_name local.' ) tf.config.experimental_connect_to_cluster(_UpperCamelCase ) tf.tpu.experimental.initialize_tpu_system(_UpperCamelCase ) return tpu def __lowerCAmelCase ( _UpperCamelCase : Any ) -> List[Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = 0 for file in file_list: SCREAMING_SNAKE_CASE = file.split('/' )[-1] SCREAMING_SNAKE_CASE = re.search(R'-\d+-(\d+)\.tfrecord' , _UpperCamelCase ).group(1 ) SCREAMING_SNAKE_CASE = int(_UpperCamelCase ) num_samples += sample_count return num_samples def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : str , _UpperCamelCase : Any , _UpperCamelCase : Optional[int] , _UpperCamelCase : str , _UpperCamelCase : str=None ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = count_samples(_UpperCamelCase ) SCREAMING_SNAKE_CASE = tf.data.Dataset.from_tensor_slices(_UpperCamelCase ) if shuffle: SCREAMING_SNAKE_CASE = dataset.shuffle(len(_UpperCamelCase ) ) SCREAMING_SNAKE_CASE = tf.data.TFRecordDataset(_UpperCamelCase , num_parallel_reads=_UpperCamelCase ) # TF can't infer the total sample count because it doesn't read all the records yet, so we assert it here SCREAMING_SNAKE_CASE = dataset.apply(tf.data.experimental.assert_cardinality(_UpperCamelCase ) ) SCREAMING_SNAKE_CASE = dataset.map(_UpperCamelCase , num_parallel_calls=_UpperCamelCase ) if shuffle: assert shuffle_buffer_size is not None SCREAMING_SNAKE_CASE = dataset.shuffle(args.shuffle_buffer_size ) SCREAMING_SNAKE_CASE = dataset.batch(_UpperCamelCase , drop_remainder=_UpperCamelCase ) SCREAMING_SNAKE_CASE = dataset.map(_UpperCamelCase , num_parallel_calls=_UpperCamelCase ) SCREAMING_SNAKE_CASE = dataset.prefetch(_UpperCamelCase ) return dataset def __lowerCAmelCase ( _UpperCamelCase : Optional[int] ) -> int: '''simple docstring''' if not args.no_tpu: SCREAMING_SNAKE_CASE = initialize_tpu(_UpperCamelCase ) SCREAMING_SNAKE_CASE = tf.distribute.TPUStrategy(_UpperCamelCase ) else: SCREAMING_SNAKE_CASE = tf.distribute.OneDeviceStrategy(device='/gpu:0' ) if args.bfloataa: tf.keras.mixed_precision.set_global_policy('mixed_bfloat16' ) SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained(args.tokenizer ) SCREAMING_SNAKE_CASE = AutoConfig.from_pretrained(args.pretrained_model_config ) SCREAMING_SNAKE_CASE = tokenizer.vocab_size SCREAMING_SNAKE_CASE = tf.io.gfile.glob(os.path.join(args.train_dataset , '*.tfrecord' ) ) if not training_records: raise ValueError(f"""No .tfrecord files found in {args.train_dataset}.""" ) SCREAMING_SNAKE_CASE = tf.io.gfile.glob(os.path.join(args.eval_dataset , '*.tfrecord' ) ) if not eval_records: raise ValueError(f"""No .tfrecord files found in {args.eval_dataset}.""" ) SCREAMING_SNAKE_CASE = count_samples(_UpperCamelCase ) SCREAMING_SNAKE_CASE = num_train_samples // (args.per_replica_batch_size * strategy.num_replicas_in_sync) SCREAMING_SNAKE_CASE = steps_per_epoch * args.num_epochs with strategy.scope(): SCREAMING_SNAKE_CASE = TFAutoModelForMaskedLM.from_config(_UpperCamelCase ) model(model.dummy_inputs ) # Pass some dummy inputs through the model to ensure all the weights are built SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = create_optimizer( num_train_steps=_UpperCamelCase , num_warmup_steps=total_train_steps // 20 , init_lr=args.learning_rate , weight_decay_rate=args.weight_decay_rate , ) # Transformers models compute the right loss for their task by default when labels are passed, and will # use this for training unless you specify your own loss function in compile(). model.compile(optimizer=_UpperCamelCase , metrics=['accuracy'] ) def decode_fn(_UpperCamelCase : Union[str, Any] ): SCREAMING_SNAKE_CASE = { 'input_ids': tf.io.FixedLenFeature(dtype=tf.intaa , shape=(args.max_length,) ), 'attention_mask': tf.io.FixedLenFeature(dtype=tf.intaa , shape=(args.max_length,) ), } return tf.io.parse_single_example(_UpperCamelCase , _UpperCamelCase ) # Many of the data collators in Transformers are TF-compilable when return_tensors == "tf", so we can # use their methods in our data pipeline. SCREAMING_SNAKE_CASE = DataCollatorForLanguageModeling( tokenizer=_UpperCamelCase , mlm_probability=args.mlm_probability , mlm=_UpperCamelCase , return_tensors='tf' ) def mask_with_collator(_UpperCamelCase : Any ): # TF really needs an isin() function SCREAMING_SNAKE_CASE = ( ~tf.cast(batch['attention_mask'] , tf.bool ) | (batch['input_ids'] == tokenizer.cls_token_id) | (batch['input_ids'] == tokenizer.sep_token_id) ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = data_collator.tf_mask_tokens( batch['input_ids'] , vocab_size=len(_UpperCamelCase ) , mask_token_id=tokenizer.mask_token_id , special_tokens_mask=_UpperCamelCase , ) return batch SCREAMING_SNAKE_CASE = args.per_replica_batch_size * strategy.num_replicas_in_sync SCREAMING_SNAKE_CASE = prepare_dataset( _UpperCamelCase , decode_fn=_UpperCamelCase , mask_fn=_UpperCamelCase , batch_size=_UpperCamelCase , shuffle=_UpperCamelCase , shuffle_buffer_size=args.shuffle_buffer_size , ) SCREAMING_SNAKE_CASE = prepare_dataset( _UpperCamelCase , decode_fn=_UpperCamelCase , mask_fn=_UpperCamelCase , batch_size=_UpperCamelCase , shuffle=_UpperCamelCase , ) SCREAMING_SNAKE_CASE = [] if args.hub_model_id: callbacks.append( PushToHubCallback(output_dir=args.output_dir , hub_model_id=args.hub_model_id , tokenizer=_UpperCamelCase ) ) model.fit( _UpperCamelCase , validation_data=_UpperCamelCase , epochs=args.num_epochs , callbacks=_UpperCamelCase , ) model.save_pretrained(args.output_dir ) if __name__ == "__main__": a_ : Union[str, Any] = parse_args() main(args)
711
def __lowerCAmelCase ( _UpperCamelCase : str , _UpperCamelCase : int ) -> list[str]: '''simple docstring''' return [sentence[i : i + ngram_size] for i in range(len(_UpperCamelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
673
0
from functools import reduce a_ : str = ( "73167176531330624919225119674426574742355349194934" "96983520312774506326239578318016984801869478851843" "85861560789112949495459501737958331952853208805511" "12540698747158523863050715693290963295227443043557" "66896648950445244523161731856403098711121722383113" "62229893423380308135336276614282806444486645238749" "30358907296290491560440772390713810515859307960866" "70172427121883998797908792274921901699720888093776" "65727333001053367881220235421809751254540594752243" "52584907711670556013604839586446706324415722155397" "53697817977846174064955149290862569321978468622482" "83972241375657056057490261407972968652414535100474" "82166370484403199890008895243450658541227588666881" "16427171479924442928230863465674813919123162824586" "17866458359124566529476545682848912883142607690042" "24219022671055626321111109370544217506941658960408" "07198403850962455444362981230987879927244284909188" "84580156166097919133875499200524063689912560717606" "05886116467109405077541002256983155200055935729725" "71636269561882670428252483600823257530420752963450" ) def __lowerCAmelCase ( _UpperCamelCase : str = N ) -> int: '''simple docstring''' return max( # mypy cannot properly interpret reduce int(reduce(lambda _UpperCamelCase , _UpperCamelCase : str(int(_UpperCamelCase ) * int(_UpperCamelCase ) ) , n[i : i + 13] ) ) for i in range(len(_UpperCamelCase ) - 12 ) ) if __name__ == "__main__": print(F"""{solution() = }""")
712
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING a_ : Dict = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE ) class UpperCamelCase ( SCREAMING_SNAKE_CASE ): def __init__( self : Any , **snake_case__ : Optional[int] ): """simple docstring""" super().__init__(**snake_case__ ) if self.framework == "tf": raise ValueError(F"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(snake_case__ ) def __call__( self : List[Any] , snake_case__ : Union[str, "Image.Image", List[Dict[str, Any]]] , snake_case__ : Union[str, List[str]] = None , **snake_case__ : Union[str, Any] , ): """simple docstring""" if "text_queries" in kwargs: SCREAMING_SNAKE_CASE = kwargs.pop('text_queries' ) if isinstance(snake_case__ , (str, Image.Image) ): SCREAMING_SNAKE_CASE = {'image': image, 'candidate_labels': candidate_labels} else: SCREAMING_SNAKE_CASE = image SCREAMING_SNAKE_CASE = super().__call__(snake_case__ , **snake_case__ ) return results def UpperCamelCase ( self : Union[str, Any] , **snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = {} if "threshold" in kwargs: SCREAMING_SNAKE_CASE = kwargs['threshold'] if "top_k" in kwargs: SCREAMING_SNAKE_CASE = kwargs['top_k'] return {}, {}, postprocess_params def UpperCamelCase ( self : List[Any] , snake_case__ : Optional[int] ): """simple docstring""" SCREAMING_SNAKE_CASE = load_image(inputs['image'] ) SCREAMING_SNAKE_CASE = inputs['candidate_labels'] if isinstance(snake_case__ , snake_case__ ): SCREAMING_SNAKE_CASE = candidate_labels.split(',' ) SCREAMING_SNAKE_CASE = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(snake_case__ ): SCREAMING_SNAKE_CASE = self.tokenizer(snake_case__ , return_tensors=self.framework ) SCREAMING_SNAKE_CASE = self.image_processor(snake_case__ , return_tensors=self.framework ) yield { "is_last": i == len(snake_case__ ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def UpperCamelCase ( self : Any , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = model_inputs.pop('target_size' ) SCREAMING_SNAKE_CASE = model_inputs.pop('candidate_label' ) SCREAMING_SNAKE_CASE = model_inputs.pop('is_last' ) SCREAMING_SNAKE_CASE = self.model(**snake_case__ ) SCREAMING_SNAKE_CASE = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : str=0.1 , snake_case__ : Union[str, Any]=None ): """simple docstring""" SCREAMING_SNAKE_CASE = [] for model_output in model_outputs: SCREAMING_SNAKE_CASE = model_output['candidate_label'] SCREAMING_SNAKE_CASE = BaseModelOutput(snake_case__ ) SCREAMING_SNAKE_CASE = self.image_processor.post_process_object_detection( outputs=snake_case__ , threshold=snake_case__ , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): SCREAMING_SNAKE_CASE = outputs['scores'][index].item() SCREAMING_SNAKE_CASE = self._get_bounding_box(outputs['boxes'][index][0] ) SCREAMING_SNAKE_CASE = {'score': score, 'label': label, 'box': box} results.append(snake_case__ ) SCREAMING_SNAKE_CASE = sorted(snake_case__ , key=lambda snake_case__ : x["score"] , reverse=snake_case__ ) if top_k: SCREAMING_SNAKE_CASE = results[:top_k] return results def UpperCamelCase ( self : List[Any] , snake_case__ : "torch.Tensor" ): """simple docstring""" if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = box.int().tolist() SCREAMING_SNAKE_CASE = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
673
0
import argparse import OmegaConf import torch from diffusers import DDIMScheduler, LDMPipeline, UNetLDMModel, VQModel def __lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE = OmegaConf.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = torch.load(_UpperCamelCase , map_location='cpu' )['model'] SCREAMING_SNAKE_CASE = list(state_dict.keys() ) # extract state_dict for VQVAE SCREAMING_SNAKE_CASE = {} SCREAMING_SNAKE_CASE = 'first_stage_model.' for key in keys: if key.startswith(_UpperCamelCase ): SCREAMING_SNAKE_CASE = state_dict[key] # extract state_dict for UNetLDM SCREAMING_SNAKE_CASE = {} SCREAMING_SNAKE_CASE = 'model.diffusion_model.' for key in keys: if key.startswith(_UpperCamelCase ): SCREAMING_SNAKE_CASE = state_dict[key] SCREAMING_SNAKE_CASE = config.model.params.first_stage_config.params SCREAMING_SNAKE_CASE = config.model.params.unet_config.params SCREAMING_SNAKE_CASE = VQModel(**_UpperCamelCase ).eval() vqvae.load_state_dict(_UpperCamelCase ) SCREAMING_SNAKE_CASE = UNetLDMModel(**_UpperCamelCase ).eval() unet.load_state_dict(_UpperCamelCase ) SCREAMING_SNAKE_CASE = DDIMScheduler( timesteps=config.model.params.timesteps , beta_schedule='scaled_linear' , beta_start=config.model.params.linear_start , beta_end=config.model.params.linear_end , clip_sample=_UpperCamelCase , ) SCREAMING_SNAKE_CASE = LDMPipeline(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) pipeline.save_pretrained(_UpperCamelCase ) if __name__ == "__main__": a_ : Union[str, Any] = argparse.ArgumentParser() parser.add_argument("--checkpoint_path", type=str, required=True) parser.add_argument("--config_path", type=str, required=True) parser.add_argument("--output_path", type=str, required=True) a_ : str = parser.parse_args() convert_ldm_original(args.checkpoint_path, args.config_path, args.output_path)
713
def __lowerCAmelCase ( _UpperCamelCase : int = 10_00 ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 2**power SCREAMING_SNAKE_CASE = str(_UpperCamelCase ) SCREAMING_SNAKE_CASE = list(_UpperCamelCase ) SCREAMING_SNAKE_CASE = 0 for i in list_num: sum_of_num += int(_UpperCamelCase ) return sum_of_num if __name__ == "__main__": a_ : List[str] = int(input("Enter the power of 2: ").strip()) print("2 ^ ", power, " = ", 2**power) a_ : int = solution(power) print("Sum of the digits is: ", result)
673
0
def __lowerCAmelCase ( _UpperCamelCase : str = "The quick brown fox jumps over the lazy dog" , ) -> bool: '''simple docstring''' SCREAMING_SNAKE_CASE = set() # Replace all the whitespace in our sentence SCREAMING_SNAKE_CASE = input_str.replace(' ' , '' ) for alpha in input_str: if "a" <= alpha.lower() <= "z": frequency.add(alpha.lower() ) return len(_UpperCamelCase ) == 26 def __lowerCAmelCase ( _UpperCamelCase : str = "The quick brown fox jumps over the lazy dog" , ) -> bool: '''simple docstring''' SCREAMING_SNAKE_CASE = [False] * 26 for char in input_str: if char.islower(): SCREAMING_SNAKE_CASE = True elif char.isupper(): SCREAMING_SNAKE_CASE = True return all(_UpperCamelCase ) def __lowerCAmelCase ( _UpperCamelCase : str = "The quick brown fox jumps over the lazy dog" , ) -> bool: '''simple docstring''' return len({char for char in input_str.lower() if char.isalpha()} ) == 26 def __lowerCAmelCase ( ) -> None: '''simple docstring''' from timeit import timeit SCREAMING_SNAKE_CASE = 'from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest' print(timeit('is_pangram()' , setup=_UpperCamelCase ) ) print(timeit('is_pangram_faster()' , setup=_UpperCamelCase ) ) print(timeit('is_pangram_fastest()' , setup=_UpperCamelCase ) ) # 5.348480500048026, 2.6477354579837993, 1.8470395830227062 # 5.036091582966037, 2.644472333951853, 1.8869528750656173 if __name__ == "__main__": import doctest doctest.testmod() benchmark()
714
# Copyright 2023 The HuggingFace Inc. 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 torch from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer from .base import PipelineTool class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase ="facebook/bart-large-mnli" __UpperCamelCase =( "This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which " "should be the text to classify, and `labels`, which should be the list of labels to use for classification. " "It returns the most likely label in the list of provided `labels` for the input text." ) __UpperCamelCase ="text_classifier" __UpperCamelCase =AutoTokenizer __UpperCamelCase =AutoModelForSequenceClassification __UpperCamelCase =["text", ["text"]] __UpperCamelCase =["text"] def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" super().setup() SCREAMING_SNAKE_CASE = self.model.config SCREAMING_SNAKE_CASE = -1 for idx, label in config.idalabel.items(): if label.lower().startswith('entail' ): SCREAMING_SNAKE_CASE = int(snake_case__ ) if self.entailment_id == -1: raise ValueError('Could not determine the entailment ID from the model config, please pass it at init.' ) def UpperCamelCase ( self : Optional[Any] , snake_case__ : List[str] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = labels return self.pre_processor( [text] * len(snake_case__ ) , [F"""This example is {label}""" for label in labels] , return_tensors='pt' , padding='max_length' , ) def UpperCamelCase ( self : Dict , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = outputs.logits SCREAMING_SNAKE_CASE = torch.argmax(logits[:, 2] ).item() return self._labels[label_id]
673
0
from dataclasses import dataclass from enum import Enum from typing import List, Optional, Union import numpy as np import PIL from PIL import Image from ...utils import BaseOutput, is_torch_available, is_transformers_available @dataclass class UpperCamelCase ( SCREAMING_SNAKE_CASE ): __UpperCamelCase =42 __UpperCamelCase =42 if is_transformers_available() and is_torch_available(): from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline
715
# Note: if you intend to run this script make sure you look under scripts/fsmt/ # to locate the appropriate script to do the work correctly. There is a set of scripts to: # - download and prepare data and run the conversion script # - perform eval to get the best hparam into the config # - generate model_cards - useful if you have multiple models from the same paper import argparse import json import os import re from collections import OrderedDict from os.path import basename, dirname import fairseq import torch from fairseq import hub_utils from fairseq.data.dictionary import Dictionary from transformers import FSMTConfig, FSMTForConditionalGeneration from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE from transformers.utils import WEIGHTS_NAME, logging logging.set_verbosity_warning() a_ : str = 2 # based on the results of a search on a range of `num_beams`, `length_penalty` and `early_stopping` # values against wmt19 test data to obtain the best BLEU scores, we will use the following defaults: # # * `num_beams`: 5 (higher scores better, but requires more memory/is slower, can be adjusted by users) # * `early_stopping`: `False` consistently scored better # * `length_penalty` varied, so will assign the best one depending on the model a_ : int = { # fairseq: "wmt19-ru-en": {"length_penalty": 1.1}, "wmt19-en-ru": {"length_penalty": 1.1_5}, "wmt19-en-de": {"length_penalty": 1.0}, "wmt19-de-en": {"length_penalty": 1.1}, # allenai: "wmt16-en-de-dist-12-1": {"length_penalty": 0.6}, "wmt16-en-de-dist-6-1": {"length_penalty": 0.6}, "wmt16-en-de-12-1": {"length_penalty": 0.8}, "wmt19-de-en-6-6-base": {"length_penalty": 0.6}, "wmt19-de-en-6-6-big": {"length_penalty": 0.6}, } # this remaps the different models to their organization names a_ : str = {} for m in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: a_ : List[Any] = "facebook" for m in [ "wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1", "wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big", ]: a_ : Any = "allenai" def __lowerCAmelCase ( _UpperCamelCase : List[Any] ) -> Any: '''simple docstring''' SCREAMING_SNAKE_CASE = dict((re.sub(R'@@$' , '' , _UpperCamelCase ), v) if k.endswith('@@' ) else (re.sub(R'$' , '</w>' , _UpperCamelCase ), v) for k, v in d.items() ) SCREAMING_SNAKE_CASE = '<s> <pad> </s> <unk>'.split() # restore the special tokens for k in keep_keys: del da[f"""{k}</w>"""] SCREAMING_SNAKE_CASE = d[k] # restore return da def __lowerCAmelCase ( _UpperCamelCase : Dict , _UpperCamelCase : List[str] ) -> Dict: '''simple docstring''' assert os.path.exists(_UpperCamelCase ) os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) print(f"""Writing results to {pytorch_dump_folder_path}""" ) # handle various types of models SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = fairseq.model_parallel.models.transformer.ModelParallelTransformerModel SCREAMING_SNAKE_CASE = cls.hub_models() SCREAMING_SNAKE_CASE = {'bpe': 'fastbpe', 'tokenizer': 'moses'} SCREAMING_SNAKE_CASE = '.' # note: since the model dump is old, fairseq has upgraded its model some # time later, and it does a whole lot of rewrites and splits on the saved # weights, therefore we can't use torch.load() directly on the model file. # see: upgrade_state_dict(state_dict) in fairseq_model.py print(f"""using checkpoint {checkpoint_file}""" ) SCREAMING_SNAKE_CASE = hub_utils.from_pretrained( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , archive_map=_UpperCamelCase , **_UpperCamelCase ) SCREAMING_SNAKE_CASE = vars(chkpt['args']['model'] ) SCREAMING_SNAKE_CASE = args['source_lang'] SCREAMING_SNAKE_CASE = args['target_lang'] SCREAMING_SNAKE_CASE = dirname(_UpperCamelCase ) SCREAMING_SNAKE_CASE = basename(_UpperCamelCase ) # dicts SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{src_lang}.txt""" ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , f"""dict.{tgt_lang}.txt""" ) SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(src_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-src.json' ) print(f"""Generating {src_vocab_file} of {src_vocab_size} of {src_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # detect whether this is a do_lower_case situation, which can be derived by checking whether we # have at least one uppercase letter in the source vocab SCREAMING_SNAKE_CASE = True for k in src_vocab.keys(): if not k.islower(): SCREAMING_SNAKE_CASE = False break SCREAMING_SNAKE_CASE = Dictionary.load(_UpperCamelCase ) SCREAMING_SNAKE_CASE = rewrite_dict_keys(tgt_dict.indices ) SCREAMING_SNAKE_CASE = len(_UpperCamelCase ) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'vocab-tgt.json' ) print(f"""Generating {tgt_vocab_file} of {tgt_vocab_size} of {tgt_lang} records""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # merges_file (bpecodes) SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , VOCAB_FILES_NAMES['merges_file'] ) for fn in ["bpecodes", "code"]: # older fairseq called the merges file "code" SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) if os.path.exists(_UpperCamelCase ): break with open(_UpperCamelCase , encoding='utf-8' ) as fin: SCREAMING_SNAKE_CASE = fin.read() SCREAMING_SNAKE_CASE = re.sub(R' \d+$' , '' , _UpperCamelCase , 0 , re.M ) # remove frequency number print(f"""Generating {merges_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as fout: fout.write(_UpperCamelCase ) # model config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , 'config.json' ) # validate bpe/tokenizer config, as currently it's hardcoded to moses+fastbpe - # may have to modify the tokenizer if a different type is used by a future model assert args["bpe"] == "fastbpe", f"""need to extend tokenizer to support bpe={args['bpe']}""" assert args["tokenizer"] == "moses", f"""need to extend tokenizer to support bpe={args['tokenizer']}""" SCREAMING_SNAKE_CASE = { 'architectures': ['FSMTForConditionalGeneration'], 'model_type': 'fsmt', 'activation_dropout': args['activation_dropout'], 'activation_function': 'relu', 'attention_dropout': args['attention_dropout'], 'd_model': args['decoder_embed_dim'], 'dropout': args['dropout'], 'init_std': 0.02, 'max_position_embeddings': args['max_source_positions'], 'num_hidden_layers': args['encoder_layers'], 'src_vocab_size': src_vocab_size, 'tgt_vocab_size': tgt_vocab_size, 'langs': [src_lang, tgt_lang], 'encoder_attention_heads': args['encoder_attention_heads'], 'encoder_ffn_dim': args['encoder_ffn_embed_dim'], 'encoder_layerdrop': args['encoder_layerdrop'], 'encoder_layers': args['encoder_layers'], 'decoder_attention_heads': args['decoder_attention_heads'], 'decoder_ffn_dim': args['decoder_ffn_embed_dim'], 'decoder_layerdrop': args['decoder_layerdrop'], 'decoder_layers': args['decoder_layers'], 'bos_token_id': 0, 'pad_token_id': 1, 'eos_token_id': 2, 'is_encoder_decoder': True, 'scale_embedding': not args['no_scale_embedding'], 'tie_word_embeddings': args['share_all_embeddings'], } # good hparam defaults to start with SCREAMING_SNAKE_CASE = 5 SCREAMING_SNAKE_CASE = False if model_dir in best_score_hparams and "length_penalty" in best_score_hparams[model_dir]: SCREAMING_SNAKE_CASE = best_score_hparams[model_dir]['length_penalty'] else: SCREAMING_SNAKE_CASE = 1.0 print(f"""Generating {fsmt_model_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # tokenizer config SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = { 'langs': [src_lang, tgt_lang], 'model_max_length': 10_24, 'do_lower_case': do_lower_case, } print(f"""Generating {fsmt_tokenizer_config_file}""" ) with open(_UpperCamelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(_UpperCamelCase , ensure_ascii=_UpperCamelCase , indent=_UpperCamelCase ) ) # model SCREAMING_SNAKE_CASE = chkpt['models'][0] SCREAMING_SNAKE_CASE = model.state_dict() # rename keys to start with 'model.' SCREAMING_SNAKE_CASE = OrderedDict(('model.' + k, v) for k, v in model_state_dict.items() ) # remove unneeded keys SCREAMING_SNAKE_CASE = [ 'model.model', 'model.encoder.version', 'model.decoder.version', 'model.encoder_embed_tokens.weight', 'model.decoder_embed_tokens.weight', 'model.encoder.embed_positions._float_tensor', 'model.decoder.embed_positions._float_tensor', ] for k in ignore_keys: model_state_dict.pop(_UpperCamelCase , _UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTConfig.from_pretrained(_UpperCamelCase ) SCREAMING_SNAKE_CASE = FSMTForConditionalGeneration(_UpperCamelCase ) # check that it loads ok model_new.load_state_dict(_UpperCamelCase , strict=_UpperCamelCase ) # save SCREAMING_SNAKE_CASE = os.path.join(_UpperCamelCase , _UpperCamelCase ) print(f"""Generating {pytorch_weights_dump_path}""" ) torch.save(_UpperCamelCase , _UpperCamelCase ) print('Conversion is done!' ) print('\nLast step is to upload the files to s3' ) print(f"""cd {data_root}""" ) print(f"""transformers-cli upload {model_dir}""" ) if __name__ == "__main__": a_ : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--fsmt_checkpoint_path", default=None, type=str, required=True, help=( "Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts," " bpecodes, etc." ), ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) a_ : int = parser.parse_args() convert_fsmt_checkpoint_to_pytorch(args.fsmt_checkpoint_path, args.pytorch_dump_folder_path)
673
0
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 : Union[str, Any] , snake_case__ : List[str] , snake_case__ : str=1_3 , snake_case__ : Dict=7 , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : List[str]=True , snake_case__ : Tuple=True , snake_case__ : str=9_9 , snake_case__ : Dict=3_2 , snake_case__ : Any=5 , snake_case__ : List[Any]=4 , snake_case__ : Tuple=3_7 , snake_case__ : List[Any]="gelu" , snake_case__ : str=0.1 , snake_case__ : Optional[int]=0.1 , snake_case__ : int=5_1_2 , snake_case__ : int=1_6 , snake_case__ : List[str]=2 , snake_case__ : str=0.02 , snake_case__ : List[str]=4 , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_attention_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_choices def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_attention_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = 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=snake_case__ , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class UpperCamelCase ( SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( FlaxAlbertModel, FlaxAlbertForPreTraining, FlaxAlbertForMaskedLM, FlaxAlbertForMultipleChoice, FlaxAlbertForQuestionAnswering, FlaxAlbertForSequenceClassification, FlaxAlbertForTokenClassification, FlaxAlbertForQuestionAnswering, ) if is_flax_available() else () ) def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = FlaxAlbertModelTester(self ) @slow def UpperCamelCase ( self : int ): """simple docstring""" for model_class_name in self.all_model_classes: SCREAMING_SNAKE_CASE = model_class_name.from_pretrained('albert-base-v2' ) SCREAMING_SNAKE_CASE = model(np.ones((1, 1) ) ) self.assertIsNotNone(snake_case__ ) @require_flax class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = FlaxAlbertModel.from_pretrained('albert-base-v2' ) SCREAMING_SNAKE_CASE = np.array([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]] ) SCREAMING_SNAKE_CASE = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ )[0] SCREAMING_SNAKE_CASE = (1, 1_1, 7_6_8) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = 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] , snake_case__ , atol=1E-4 ) )
716
import random def __lowerCAmelCase ( _UpperCamelCase : int , _UpperCamelCase : float , _UpperCamelCase : bool = False ) -> dict: '''simple docstring''' SCREAMING_SNAKE_CASE = {i: [] for i in range(_UpperCamelCase )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(_UpperCamelCase ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(_UpperCamelCase ): for j in range(i + 1 , _UpperCamelCase ): if random.random() < probability: graph[i].append(_UpperCamelCase ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(_UpperCamelCase ) return graph def __lowerCAmelCase ( _UpperCamelCase : int ) -> dict: '''simple docstring''' return { i: [j for j in range(_UpperCamelCase ) if i != j] for i in range(_UpperCamelCase ) } if __name__ == "__main__": import doctest doctest.testmod()
673
0
from collections import defaultdict def __lowerCAmelCase ( _UpperCamelCase : int ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE = 1 SCREAMING_SNAKE_CASE = True for v in tree[start]: if v not in visited: ret += dfs(_UpperCamelCase ) if ret % 2 == 0: cuts.append(_UpperCamelCase ) return ret def __lowerCAmelCase ( ) -> Union[str, Any]: '''simple docstring''' dfs(1 ) if __name__ == "__main__": a_ : Optional[int] = 10, 9 a_ : int = defaultdict(list) a_ : dict[int, bool] = {} a_ : list[int] = [] a_ : Dict = 0 a_ : List[Any] = [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (10, 8)] for u, v in edges: tree[u].append(v) tree[v].append(u) even_tree() print(len(cuts) - 1)
717
import unittest from transformers import AutoTokenizer, NystromformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, NystromformerModel, ) from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST class UpperCamelCase : def __init__( self : List[str] , snake_case__ : Dict , snake_case__ : Optional[Any]=1_3 , snake_case__ : Union[str, Any]=7 , snake_case__ : List[str]=True , snake_case__ : Any=True , snake_case__ : List[str]=True , snake_case__ : Optional[Any]=True , snake_case__ : List[str]=9_9 , snake_case__ : str=3_2 , snake_case__ : Dict=5 , snake_case__ : str=4 , snake_case__ : int=3_7 , snake_case__ : Union[str, Any]="gelu" , snake_case__ : Any=0.1 , snake_case__ : Dict=0.1 , snake_case__ : Optional[Any]=5_1_2 , snake_case__ : List[Any]=1_6 , snake_case__ : str=2 , snake_case__ : int=0.02 , snake_case__ : List[str]=3 , snake_case__ : Dict=4 , snake_case__ : str=None , ): """simple docstring""" SCREAMING_SNAKE_CASE = parent SCREAMING_SNAKE_CASE = batch_size SCREAMING_SNAKE_CASE = seq_length SCREAMING_SNAKE_CASE = is_training SCREAMING_SNAKE_CASE = use_input_mask SCREAMING_SNAKE_CASE = use_token_type_ids SCREAMING_SNAKE_CASE = use_labels SCREAMING_SNAKE_CASE = vocab_size SCREAMING_SNAKE_CASE = hidden_size SCREAMING_SNAKE_CASE = num_hidden_layers SCREAMING_SNAKE_CASE = num_attention_heads SCREAMING_SNAKE_CASE = intermediate_size SCREAMING_SNAKE_CASE = hidden_act SCREAMING_SNAKE_CASE = hidden_dropout_prob SCREAMING_SNAKE_CASE = attention_probs_dropout_prob SCREAMING_SNAKE_CASE = max_position_embeddings SCREAMING_SNAKE_CASE = type_vocab_size SCREAMING_SNAKE_CASE = type_sequence_label_size SCREAMING_SNAKE_CASE = initializer_range SCREAMING_SNAKE_CASE = num_labels SCREAMING_SNAKE_CASE = num_choices SCREAMING_SNAKE_CASE = scope def UpperCamelCase ( self : List[str] ): """simple docstring""" SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE = None if self.use_input_mask: SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length] ) SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None SCREAMING_SNAKE_CASE = None if self.use_labels: SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self : Optional[Any] ): """simple docstring""" return NystromformerConfig( 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=snake_case__ , initializer_range=self.initializer_range , ) def UpperCamelCase ( self : List[str] , snake_case__ : Any , snake_case__ : Tuple , snake_case__ : Union[str, Any] , snake_case__ : Dict , snake_case__ : List[str] , snake_case__ : int , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ , token_type_ids=snake_case__ ) SCREAMING_SNAKE_CASE = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase ( self : List[Any] , snake_case__ : str , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : Dict , snake_case__ : int , snake_case__ : int , snake_case__ : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForMaskedLM(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCamelCase ( self : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[Any] , snake_case__ : int , snake_case__ : Optional[int] , snake_case__ : str , snake_case__ : List[str] , snake_case__ : Optional[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerForQuestionAnswering(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , start_positions=snake_case__ , end_positions=snake_case__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCamelCase ( self : List[str] , snake_case__ : int , snake_case__ : int , snake_case__ : int , snake_case__ : str , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForSequenceClassification(snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCamelCase ( self : Tuple , snake_case__ : int , snake_case__ : Tuple , snake_case__ : List[str] , snake_case__ : List[Any] , snake_case__ : Optional[Any] , snake_case__ : List[Any] , snake_case__ : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_labels SCREAMING_SNAKE_CASE = NystromformerForTokenClassification(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = model(snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCamelCase ( self : int , snake_case__ : Optional[Any] , snake_case__ : List[str] , snake_case__ : Union[str, Any] , snake_case__ : Tuple , snake_case__ : Optional[int] , snake_case__ : Any , snake_case__ : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.num_choices SCREAMING_SNAKE_CASE = NystromformerForMultipleChoice(config=snake_case__ ) model.to(snake_case__ ) model.eval() SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() SCREAMING_SNAKE_CASE = model( snake_case__ , attention_mask=snake_case__ , token_type_ids=snake_case__ , labels=snake_case__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ( SCREAMING_SNAKE_CASE ) , ) = config_and_inputs SCREAMING_SNAKE_CASE = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , unittest.TestCase ): __UpperCamelCase =( ( NystromformerModel, NystromformerForMaskedLM, NystromformerForMultipleChoice, NystromformerForQuestionAnswering, NystromformerForSequenceClassification, NystromformerForTokenClassification, ) if is_torch_available() else () ) __UpperCamelCase =( { "feature-extraction": NystromformerModel, "fill-mask": NystromformerForMaskedLM, "question-answering": NystromformerForQuestionAnswering, "text-classification": NystromformerForSequenceClassification, "token-classification": NystromformerForTokenClassification, "zero-shot": NystromformerForSequenceClassification, } if is_torch_available() else {} ) __UpperCamelCase =False __UpperCamelCase =False def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModelTester(self ) SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=snake_case__ , hidden_size=3_7 ) def UpperCamelCase ( self : List[str] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: SCREAMING_SNAKE_CASE = type self.model_tester.create_and_check_model(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case__ ) def UpperCamelCase ( self : Union[str, Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case__ ) def UpperCamelCase ( self : Tuple ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case__ ) def UpperCamelCase ( self : Any ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case__ ) def UpperCamelCase ( self : List[Any] ): """simple docstring""" SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case__ ) @slow def UpperCamelCase ( self : List[str] ): """simple docstring""" for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) @require_torch class UpperCamelCase ( unittest.TestCase ): @slow def UpperCamelCase ( self : int ): """simple docstring""" SCREAMING_SNAKE_CASE = NystromformerModel.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]] ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(snake_case__ )[0] SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8) ) self.assertEqual(output.shape , snake_case__ ) SCREAMING_SNAKE_CASE = torch.tensor( [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case__ , atol=1E-4 ) ) @slow def UpperCamelCase ( self : Dict ): """simple docstring""" SCREAMING_SNAKE_CASE = 'the [MASK] of Belgium is Brussels' SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512' ) SCREAMING_SNAKE_CASE = tokenizer(snake_case__ , return_tensors='pt' ) with torch.no_grad(): SCREAMING_SNAKE_CASE = model(encoding.input_ids ).logits SCREAMING_SNAKE_CASE = token_logits[:, 2, :].argmax(-1 )[0] self.assertEqual(tokenizer.decode(snake_case__ ) , 'capital' )
673
0