code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
import shutil import tempfile import unittest from transformers import ( SPIECE_UNDERLINE, AddedToken, BatchEncoding, NllbTokenizer, NllbTokenizerFast, is_torch_available, ) from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin lowercase__ : Dict = get_tests_dir("fixtures/test_sentencepiece.model") if is_torch_available(): from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right lowercase__ : Union[str, Any] = 25_6047 lowercase__ : str = 25_6145 @require_sentencepiece @require_tokenizers class UpperCAmelCase ( _a , unittest.TestCase ): '''simple docstring''' lowerCAmelCase_ = NllbTokenizer lowerCAmelCase_ = NllbTokenizerFast lowerCAmelCase_ = True lowerCAmelCase_ = True lowerCAmelCase_ = {} def snake_case__ ( self : Optional[int] ): """simple docstring""" super().setUp() # We have a SentencePiece fixture for testing snake_case_ = NllbTokenizer(__lowercase , keep_accents=__lowercase ) tokenizer.save_pretrained(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): """simple docstring""" snake_case_ = NllbTokenizer(__lowercase , keep_accents=__lowercase ) snake_case_ = tokenizer.tokenize("This is a test" ) self.assertListEqual(__lowercase , ["▁This", "▁is", "▁a", "▁t", "est"] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(__lowercase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) snake_case_ = tokenizer.tokenize("I was born in 92000, and this is falsé." ) self.assertListEqual( __lowercase , [ SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "9", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "é", ".", ] , ) snake_case_ = tokenizer.convert_tokens_to_ids(__lowercase ) self.assertListEqual( __lowercase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) snake_case_ = tokenizer.convert_ids_to_tokens(__lowercase ) self.assertListEqual( __lowercase , [ SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "<unk>", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "<unk>", ".", ] , ) def snake_case__ ( self : str ): """simple docstring""" snake_case_ = (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): snake_case_ = self.rust_tokenizer_class.from_pretrained(__lowercase , **__lowercase ) snake_case_ = self.tokenizer_class.from_pretrained(__lowercase , **__lowercase ) snake_case_ = tempfile.mkdtemp() snake_case_ = tokenizer_r.save_pretrained(__lowercase ) snake_case_ = tokenizer_p.save_pretrained(__lowercase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files ) ) snake_case_ = tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f ) self.assertSequenceEqual(__lowercase , __lowercase ) # Checks everything loads correctly in the same way snake_case_ = tokenizer_r.from_pretrained(__lowercase ) snake_case_ = tokenizer_p.from_pretrained(__lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__lowercase , __lowercase ) ) shutil.rmtree(__lowercase ) # Save tokenizer rust, legacy_format=True snake_case_ = tempfile.mkdtemp() snake_case_ = tokenizer_r.save_pretrained(__lowercase , legacy_format=__lowercase ) snake_case_ = tokenizer_p.save_pretrained(__lowercase ) # Checks it save with the same files self.assertSequenceEqual(__lowercase , __lowercase ) # Checks everything loads correctly in the same way snake_case_ = tokenizer_r.from_pretrained(__lowercase ) snake_case_ = tokenizer_p.from_pretrained(__lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__lowercase , __lowercase ) ) shutil.rmtree(__lowercase ) # Save tokenizer rust, legacy_format=False snake_case_ = tempfile.mkdtemp() snake_case_ = tokenizer_r.save_pretrained(__lowercase , legacy_format=__lowercase ) snake_case_ = tokenizer_p.save_pretrained(__lowercase ) # Checks it saved the tokenizer.json file self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way snake_case_ = tokenizer_r.from_pretrained(__lowercase ) snake_case_ = tokenizer_p.from_pretrained(__lowercase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__lowercase , __lowercase ) ) shutil.rmtree(__lowercase ) @require_torch def snake_case__ ( self : int ): """simple docstring""" if not self.test_seqaseq: return snake_case_ = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f"{tokenizer.__class__.__name__}" ): # Longer text that will definitely require truncation. snake_case_ = [ ' UN Chief Says There Is No Military Solution in Syria', ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for' ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons' ' will only worsen the violence and misery for millions of people.', ] snake_case_ = [ 'Şeful ONU declară că nu există o soluţie militară în Siria', 'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al' ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi' ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.', ] try: snake_case_ = tokenizer.prepare_seqaseq_batch( src_texts=__lowercase , tgt_texts=__lowercase , max_length=3 , max_target_length=10 , return_tensors="pt" , src_lang="eng_Latn" , tgt_lang="ron_Latn" , ) except NotImplementedError: return self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 10 ) # max_target_length will default to max_length if not specified snake_case_ = tokenizer.prepare_seqaseq_batch( __lowercase , tgt_texts=__lowercase , max_length=3 , return_tensors="pt" ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 3 ) snake_case_ = tokenizer.prepare_seqaseq_batch( src_texts=__lowercase , max_length=3 , max_target_length=10 , return_tensors="pt" ) self.assertEqual(batch_encoder_only.input_ids.shape[1] , 3 ) self.assertEqual(batch_encoder_only.attention_mask.shape[1] , 3 ) self.assertNotIn("decoder_input_ids" , __lowercase ) @unittest.skip("Unfortunately way too slow to build a BPE with SentencePiece." ) def snake_case__ ( self : Any ): """simple docstring""" pass def snake_case__ ( self : str ): """simple docstring""" for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): snake_case_ = [AddedToken("<special>" , lstrip=__lowercase )] snake_case_ = self.rust_tokenizer_class.from_pretrained( __lowercase , additional_special_tokens=__lowercase , **__lowercase ) snake_case_ = tokenizer_r.encode("Hey this is a <special> token" ) snake_case_ = tokenizer_r.encode("<special>" , add_special_tokens=__lowercase )[0] self.assertTrue(special_token_id in r_output ) if self.test_slow_tokenizer: snake_case_ = self.rust_tokenizer_class.from_pretrained( __lowercase , additional_special_tokens=__lowercase , **__lowercase , ) snake_case_ = self.tokenizer_class.from_pretrained( __lowercase , additional_special_tokens=__lowercase , **__lowercase ) snake_case_ = tokenizer_p.encode("Hey this is a <special> token" ) snake_case_ = tokenizer_cr.encode("Hey this is a <special> token" ) self.assertEqual(__lowercase , __lowercase ) self.assertEqual(__lowercase , __lowercase ) self.assertTrue(special_token_id in p_output ) self.assertTrue(special_token_id in cr_output ) @require_torch @require_sentencepiece @require_tokenizers class UpperCAmelCase ( unittest.TestCase ): '''simple docstring''' lowerCAmelCase_ = """facebook/nllb-200-distilled-600M""" lowerCAmelCase_ = [ """ UN Chief Says There Is No Military Solution in Syria""", """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""", ] lowerCAmelCase_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei""" """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor""" """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""", ] lowerCAmelCase_ = [ 25_6047, 1_6297, 13_4408, 8165, 24_8066, 1_4734, 950, 1135, 10_5721, 3573, 83, 2_7352, 108, 4_9486, 2, ] @classmethod def snake_case__ ( cls : Optional[Any] ): """simple docstring""" snake_case_ = NllbTokenizer.from_pretrained( cls.checkpoint_name , src_lang="eng_Latn" , tgt_lang="ron_Latn" ) snake_case_ = 1 return cls def snake_case__ ( self : Union[str, Any] ): """simple docstring""" self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Arab"] , 25_60_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ace_Latn"] , 25_60_02 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["fra_Latn"] , 25_60_57 ) def snake_case__ ( self : Any ): """simple docstring""" snake_case_ = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , __lowercase ) def snake_case__ ( self : str ): """simple docstring""" self.assertIn(__lowercase , self.tokenizer.all_special_ids ) # fmt: off snake_case_ = [RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47] # fmt: on snake_case_ = self.tokenizer.decode(__lowercase , skip_special_tokens=__lowercase ) snake_case_ = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=__lowercase ) self.assertEqual(__lowercase , __lowercase ) self.assertNotIn(self.tokenizer.eos_token , __lowercase ) def snake_case__ ( self : Optional[Any] ): """simple docstring""" snake_case_ = ['this is gunna be a long sentence ' * 20] assert isinstance(src_text[0] , __lowercase ) snake_case_ = 10 snake_case_ = self.tokenizer(__lowercase , max_length=__lowercase , truncation=__lowercase ).input_ids[0] self.assertEqual(ids[-1] , 2 ) self.assertEqual(ids[0] , __lowercase ) self.assertEqual(len(__lowercase ) , __lowercase ) def snake_case__ ( self : Optional[Any] ): """simple docstring""" self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"] ) , [25_62_03, 3] ) def snake_case__ ( self : Union[str, Any] ): """simple docstring""" snake_case_ = tempfile.mkdtemp() snake_case_ = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(__lowercase ) snake_case_ = NllbTokenizer.from_pretrained(__lowercase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , __lowercase ) @require_torch def snake_case__ ( self : Tuple ): """simple docstring""" snake_case_ = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=__lowercase , truncation=__lowercase , max_length=len(self.expected_src_tokens ) , return_tensors="pt" , ) snake_case_ = shift_tokens_right( batch["labels"] , self.tokenizer.pad_token_id , self.tokenizer.lang_code_to_id["ron_Latn"] ) self.assertIsInstance(__lowercase , __lowercase ) self.assertEqual((2, 15) , batch.input_ids.shape ) self.assertEqual((2, 15) , batch.attention_mask.shape ) snake_case_ = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , __lowercase ) self.assertEqual(__lowercase , batch.decoder_input_ids[0, 0] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def snake_case__ ( self : List[Any] ): """simple docstring""" snake_case_ = self.tokenizer(self.src_text , padding=__lowercase , truncation=__lowercase , max_length=3 , return_tensors="pt" ) snake_case_ = self.tokenizer( text_target=self.tgt_text , padding=__lowercase , truncation=__lowercase , max_length=10 , return_tensors="pt" ) snake_case_ = targets['input_ids'] snake_case_ = shift_tokens_right( __lowercase , self.tokenizer.pad_token_id , decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang] , ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def snake_case__ ( self : Union[str, Any] ): """simple docstring""" snake_case_ = self.tokenizer._build_translation_inputs( "A test" , return_tensors="pt" , src_lang="eng_Latn" , tgt_lang="fra_Latn" ) self.assertEqual( nested_simplify(__lowercase ) , { # A, test, EOS, en_XX "input_ids": [[25_60_47, 70, 73_56, 2]], "attention_mask": [[1, 1, 1, 1]], # ar_AR "forced_bos_token_id": 25_60_57, } , ) @require_torch def snake_case__ ( self : Optional[int] ): """simple docstring""" snake_case_ = True snake_case_ = self.tokenizer( "UN Chief says there is no military solution in Syria" , src_lang="eng_Latn" , tgt_lang="fra_Latn" ) self.assertEqual( inputs.input_ids , [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47] ) snake_case_ = False snake_case_ = self.tokenizer( "UN Chief says there is no military solution in Syria" , src_lang="eng_Latn" , tgt_lang="fra_Latn" ) self.assertEqual( inputs.input_ids , [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2] )
187
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """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.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
'''simple docstring''' from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING __snake_case = logging.get_logger(__name__) @add_end_docstrings(_a ) class lowercase ( _a ): """simple docstring""" def __init__( self , *UpperCamelCase_ , **UpperCamelCase_ ): '''simple docstring''' super().__init__(*UpperCamelCase_ , **UpperCamelCase_ ) requires_backends(self , '''vision''' ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == '''tf''' else MODEL_FOR_VISION_2_SEQ_MAPPING ) def lowerCAmelCase__ ( self , UpperCamelCase_=None , UpperCamelCase_=None , UpperCamelCase_=None ): '''simple docstring''' UpperCamelCase__ :Tuple = {} UpperCamelCase__ :List[Any] = {} if prompt is not None: UpperCamelCase__ :List[str] = prompt if generate_kwargs is not None: UpperCamelCase__ :Optional[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: UpperCamelCase__ :str = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( '''\'max_new_tokens\' is defined twice, once in \'generate_kwargs\' and once as a direct parameter,''' ''' please use only one''' ) UpperCamelCase__ :Union[str, Any] = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self , UpperCamelCase_ , **UpperCamelCase_ ): '''simple docstring''' return super().__call__(UpperCamelCase_ , **UpperCamelCase_ ) def lowerCAmelCase__ ( self , UpperCamelCase_ , UpperCamelCase_=None ): '''simple docstring''' UpperCamelCase__ :Any = load_image(UpperCamelCase_ ) if prompt is not None: if not isinstance(UpperCamelCase_ , UpperCamelCase_ ): raise ValueError( F'''Received an invalid text input, got - {type(UpperCamelCase_ )} - but expected a single string. ''' '''Note also that one single text can be provided for conditional image to text generation.''' ) UpperCamelCase__ :int = self.model.config.model_type if model_type == "git": UpperCamelCase__ :Optional[int] = self.image_processor(images=UpperCamelCase_ , return_tensors=self.framework ) UpperCamelCase__ :str = self.tokenizer(text=UpperCamelCase_ , add_special_tokens=UpperCamelCase_ ).input_ids UpperCamelCase__ :Optional[int] = [self.tokenizer.cls_token_id] + input_ids UpperCamelCase__ :int = torch.tensor(UpperCamelCase_ ).unsqueeze(0 ) model_inputs.update({'''input_ids''': input_ids} ) elif model_type == "pix2struct": UpperCamelCase__ :List[Any] = self.image_processor(images=UpperCamelCase_ , header_text=UpperCamelCase_ , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation UpperCamelCase__ :Optional[int] = self.image_processor(images=UpperCamelCase_ , return_tensors=self.framework ) UpperCamelCase__ :Optional[int] = self.tokenizer(UpperCamelCase_ , return_tensors=self.framework ) model_inputs.update(UpperCamelCase_ ) else: raise ValueError(F'''Model type {model_type} does not support conditional text generation''' ) else: UpperCamelCase__ :int = self.image_processor(images=UpperCamelCase_ , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: UpperCamelCase__ :Optional[Any] = None return model_inputs def lowerCAmelCase__ ( self , UpperCamelCase_ , UpperCamelCase_=None ): '''simple docstring''' if ( "input_ids" in model_inputs and isinstance(model_inputs['''input_ids'''] , UpperCamelCase_ ) and all(x is None for x in model_inputs['''input_ids'''] ) ): UpperCamelCase__ :List[Any] = None if generate_kwargs is None: UpperCamelCase__ :int = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. UpperCamelCase__ :Optional[int] = model_inputs.pop(self.model.main_input_name ) UpperCamelCase__ :Optional[Any] = self.model.generate(UpperCamelCase_ , **UpperCamelCase_ , **UpperCamelCase_ ) return model_outputs def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' UpperCamelCase__ :Any = [] for output_ids in model_outputs: UpperCamelCase__ :List[str] = { 'generated_text': self.tokenizer.decode( UpperCamelCase_ , skip_special_tokens=UpperCamelCase_ , ) } records.append(UpperCamelCase_ ) return records
97
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging __A = logging.get_logger(__name__) __A = { "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 _lowerCAmelCase ( _a ): """simple docstring""" __magic_name__ :int = """roberta""" def __init__( self , __UpperCAmelCase=5_0_2_6_5 , __UpperCAmelCase=7_6_8 , __UpperCAmelCase=1_2 , __UpperCAmelCase=1_2 , __UpperCAmelCase=3_0_7_2 , __UpperCAmelCase="gelu" , __UpperCAmelCase=0.1 , __UpperCAmelCase=0.1 , __UpperCAmelCase=5_1_2 , __UpperCAmelCase=2 , __UpperCAmelCase=0.02 , __UpperCAmelCase=1E-12 , __UpperCAmelCase=1 , __UpperCAmelCase=0 , __UpperCAmelCase=2 , __UpperCAmelCase="absolute" , __UpperCAmelCase=True , __UpperCAmelCase=None , **__UpperCAmelCase , ): '''simple docstring''' super().__init__(pad_token_id=__UpperCAmelCase , bos_token_id=__UpperCAmelCase , eos_token_id=__UpperCAmelCase , **__UpperCAmelCase ) lowerCAmelCase__ :str = vocab_size lowerCAmelCase__ :Optional[int] = hidden_size lowerCAmelCase__ :List[Any] = num_hidden_layers lowerCAmelCase__ :List[str] = num_attention_heads lowerCAmelCase__ :Tuple = hidden_act lowerCAmelCase__ :Optional[Any] = intermediate_size lowerCAmelCase__ :Any = hidden_dropout_prob lowerCAmelCase__ :Dict = attention_probs_dropout_prob lowerCAmelCase__ :Dict = max_position_embeddings lowerCAmelCase__ :Union[str, Any] = type_vocab_size lowerCAmelCase__ :int = initializer_range lowerCAmelCase__ :Optional[Any] = layer_norm_eps lowerCAmelCase__ :Tuple = position_embedding_type lowerCAmelCase__ :Union[str, Any] = use_cache lowerCAmelCase__ :Union[str, Any] = classifier_dropout class _lowerCAmelCase ( _a ): """simple docstring""" @property def snake_case ( self ): '''simple docstring''' if self.task == "multiple-choice": lowerCAmelCase__ :List[Any] = {0: 'batch', 1: 'choice', 2: 'sequence'} else: lowerCAmelCase__ :int = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
293
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
"""simple docstring""" from __future__ import annotations import time import numpy as np lowerCAmelCase = [8, 5, 9, 7] lowerCAmelCase = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] lowerCAmelCase = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class A_ : """simple docstring""" def __init__( self :Any , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :Optional[int] , ): """simple docstring""" lowerCamelCase__ : List[str] =claim_vector lowerCamelCase__ : int =allocated_resources_table lowerCamelCase__ : Dict =maximum_claim_table def UpperCAmelCase__ ( self :Any ): """simple docstring""" return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def UpperCAmelCase__ ( self :Any ): """simple docstring""" return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def UpperCAmelCase__ ( self :Any ): """simple docstring""" return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(lowerCamelCase_ ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def UpperCAmelCase__ ( self :str ): """simple docstring""" return {self.__need().index(lowerCamelCase_ ): i for i in self.__need()} def UpperCAmelCase__ ( self :List[str] , **lowerCamelCase_ :int ): """simple docstring""" lowerCamelCase__ : Union[str, Any] =self.__need() lowerCamelCase__ : List[str] =self.__allocated_resources_table lowerCamelCase__ : List[Any] =self.__available_resources() lowerCamelCase__ : Union[str, Any] =self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('_' * 50 + '\n' ) while need_list: lowerCamelCase__ : int =False for each_need in need_list: lowerCamelCase__ : Dict =True for index, need in enumerate(lowerCamelCase_ ): if need > available_resources[index]: lowerCamelCase__ : Tuple =False break if execution: lowerCamelCase__ : Tuple =True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: lowerCamelCase__ : Tuple =original_need_index print(f"""Process {process_number + 1} is executing.""" ) # remove the process run from stack need_list.remove(lowerCamelCase_ ) # update available/freed resources stack lowerCamelCase__ : Optional[Any] =np.array(lowerCamelCase_ ) + np.array( alloc_resources_table[process_number] ) print( 'Updated available resource stack for processes: ' + ' '.join([str(lowerCamelCase_ ) for x in available_resources] ) ) break if safe: print('The process is in a safe state.\n' ) else: print('System in unsafe state. Aborting...\n' ) break def UpperCAmelCase__ ( self :Any ): """simple docstring""" print(' ' * 9 + 'Allocated Resource Table' ) for item in self.__allocated_resources_table: print( f"""P{self.__allocated_resources_table.index(lowerCamelCase_ ) + 1}""" + ' '.join(f"""{it:>8}""" for it in item ) + '\n' ) print(' ' * 9 + 'System Resource Table' ) for item in self.__maximum_claim_table: print( f"""P{self.__maximum_claim_table.index(lowerCamelCase_ ) + 1}""" + ' '.join(f"""{it:>8}""" for it in item ) + '\n' ) print( 'Current Usage by Active Processes: ' + ' '.join(str(lowerCamelCase_ ) for x in self.__claim_vector ) ) print( 'Initial Available Resources: ' + ' '.join(str(lowerCamelCase_ ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()
126
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
import warnings from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch from ...models import UNetaDModel from ...schedulers import RePaintScheduler from ...utils import PIL_INTERPOLATION, logging, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) # pylint: disable=invalid-name def lowercase( UpperCamelCase_ ) -> Any: '''simple docstring''' warnings.warn( """The preprocess method is deprecated and will be removed in a future version. Please""" """ use VaeImageProcessor.preprocess instead""" , lowerCamelCase_ , ) if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): UpperCamelCase = [image] if isinstance(image[0] , PIL.Image.Image ): UpperCamelCase = image[0].size UpperCamelCase = (x - x % 8 for x in (w, h)) # resize to integer multiple of 8 UpperCamelCase = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION["""lanczos"""] ) )[None, :] for i in image] UpperCamelCase = np.concatenate(lowerCamelCase_ , axis=0 ) UpperCamelCase = np.array(lowerCamelCase_ ).astype(np.floataa ) / 255.0 UpperCamelCase = image.transpose(0 , 3 , 1 , 2 ) UpperCamelCase = 2.0 * image - 1.0 UpperCamelCase = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): UpperCamelCase = torch.cat(lowerCamelCase_ , dim=0 ) return image def lowercase( UpperCamelCase_ ) -> str: '''simple docstring''' if isinstance(lowerCamelCase_ , torch.Tensor ): return mask elif isinstance(lowerCamelCase_ , PIL.Image.Image ): UpperCamelCase = [mask] if isinstance(mask[0] , PIL.Image.Image ): UpperCamelCase = mask[0].size UpperCamelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 UpperCamelCase = [np.array(m.convert("""L""" ).resize((w, h) , resample=PIL_INTERPOLATION["""nearest"""] ) )[None, :] for m in mask] UpperCamelCase = np.concatenate(lowerCamelCase_ , axis=0 ) UpperCamelCase = mask.astype(np.floataa ) / 255.0 UpperCamelCase = 0 UpperCamelCase = 1 UpperCamelCase = torch.from_numpy(lowerCamelCase_ ) elif isinstance(mask[0] , torch.Tensor ): UpperCamelCase = torch.cat(lowerCamelCase_ , dim=0 ) return mask class SCREAMING_SNAKE_CASE_ ( _a ): __lowerCAmelCase = 42 __lowerCAmelCase = 42 def __init__( self : Any , lowerCamelCase_ : Dict , lowerCamelCase_ : Dict ): """simple docstring""" super().__init__() self.register_modules(unet=lowerCamelCase_ , scheduler=lowerCamelCase_ ) @torch.no_grad() def __call__( self : Union[str, Any] , lowerCamelCase_ : List[str] , lowerCamelCase_ : Optional[int] , lowerCamelCase_ : List[str] = 250 , lowerCamelCase_ : Any = 0.0 , lowerCamelCase_ : Union[str, Any] = 10 , lowerCamelCase_ : Optional[int] = 10 , lowerCamelCase_ : Dict = None , lowerCamelCase_ : int = "pil" , lowerCamelCase_ : Any = True , ): """simple docstring""" UpperCamelCase = image UpperCamelCase = _preprocess_image(lowerCamelCase_ ) UpperCamelCase = original_image.to(device=self.device , dtype=self.unet.dtype ) UpperCamelCase = _preprocess_mask(lowerCamelCase_ ) UpperCamelCase = mask_image.to(device=self.device , dtype=self.unet.dtype ) UpperCamelCase = original_image.shape[0] # sample gaussian noise to begin the loop if isinstance(lowerCamelCase_ , lowerCamelCase_ ) and len(lowerCamelCase_ ) != batch_size: raise ValueError( f"""You have passed a list of generators of length {len(lowerCamelCase_ )}, but requested an effective batch""" f""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) UpperCamelCase = original_image.shape UpperCamelCase = randn_tensor(lowerCamelCase_ , generator=lowerCamelCase_ , device=self.device , dtype=self.unet.dtype ) # set step values self.scheduler.set_timesteps(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , self.device ) UpperCamelCase = eta UpperCamelCase = self.scheduler.timesteps[0] + 1 UpperCamelCase = generator[0] if isinstance(lowerCamelCase_ , lowerCamelCase_ ) else generator for i, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): if t < t_last: # predict the noise residual UpperCamelCase = self.unet(lowerCamelCase_ , lowerCamelCase_ ).sample # compute previous image: x_t -> x_t-1 UpperCamelCase = self.scheduler.step(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ).prev_sample else: # compute the reverse: x_t-1 -> x_t UpperCamelCase = self.scheduler.undo_step(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) UpperCamelCase = t UpperCamelCase = (image / 2 + 0.5).clamp(0 , 1 ) UpperCamelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": UpperCamelCase = self.numpy_to_pil(lowerCamelCase_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=lowerCamelCase_ )
343
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
import os from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_pegasus import PegasusTokenizer else: UpperCAmelCase : Any = None UpperCAmelCase : Union[str, Any] = logging.get_logger(__name__) UpperCAmelCase : Union[str, Any] = "▁" UpperCAmelCase : Union[str, Any] = {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"} UpperCAmelCase : int = { "vocab_file": {"google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"}, "tokenizer_file": { "google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/tokenizer.json" }, } UpperCAmelCase : str = { "google/pegasus-xsum": 5_12, } class _A( _a ): """simple docstring""" UpperCamelCase : Optional[Any] = VOCAB_FILES_NAMES UpperCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase : List[Any] = PegasusTokenizer UpperCamelCase : Optional[Any] = ["""input_ids""", """attention_mask"""] def __init__( self , _A=None , _A=None , _A="<pad>" , _A="</s>" , _A="<unk>" , _A="<mask_2>" , _A="<mask_1>" , _A=None , _A=103 , **_A , ): __A : str = offset if additional_special_tokens is not None: if not isinstance(_A , _A ): raise TypeError( F"""additional_special_tokens should be of type {type(_A )}, but is""" F""" {type(_A )}""" ) __A : Any = ( ([mask_token_sent] + additional_special_tokens) if mask_token_sent not in additional_special_tokens and mask_token_sent is not None else additional_special_tokens ) # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken additional_special_tokens_extended += [ F"""<unk_{i}>""" for i in range(len(_A ) , self.offset - 1 ) ] if len(set(_A ) ) != len(_A ): raise ValueError( 'Please make sure that the provided additional_special_tokens do not contain an incorrectly' F""" shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.""" ) __A : Any = additional_special_tokens_extended else: __A : Optional[Any] = [mask_token_sent] if mask_token_sent is not None else [] additional_special_tokens += [F"""<unk_{i}>""" for i in range(2 , self.offset )] super().__init__( _A , tokenizer_file=_A , pad_token=_A , eos_token=_A , unk_token=_A , mask_token=_A , mask_token_sent=_A , offset=_A , additional_special_tokens=_A , **_A , ) __A : Optional[Any] = vocab_file __A : List[str] = False if not self.vocab_file else True def UpperCAmelCase_ ( self , _A ): __A : str = set(self.all_special_ids ) # call it once instead of inside list comp all_special_ids.remove(self.unk_token_id ) # <unk> is only sometimes special if all_special_ids != set(range(len(self.additional_special_tokens ) + 3 ) ): raise ValueError( 'There should be 3 special tokens: mask_token, pad_token, and eos_token +' F""" {len(self.additional_special_tokens )} additional_special_tokens, but got {all_special_ids}""" ) return [1 if x in all_special_ids else 0 for x in seq] def UpperCAmelCase_ ( self , _A , _A = None , _A = False ): if already_has_special_tokens: return self._special_token_mask(_A ) elif token_ids_a is None: return self._special_token_mask(_A ) + [1] else: return self._special_token_mask(token_ids_a + token_ids_a ) + [1] def UpperCAmelCase_ ( self , _A , _A=None ): if token_ids_a is None: return token_ids_a + [self.eos_token_id] # We don't expect to process pairs, but leave the pair logic for API consistency return token_ids_a + token_ids_a + [self.eos_token_id] def UpperCAmelCase_ ( self , _A , _A = None ): if not self.can_save_slow_tokenizer: raise ValueError( 'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow ' 'tokenizer.' ) if not os.path.isdir(_A ): logger.error(F"""Vocabulary path ({save_directory}) should be a directory""" ) return __A : Any = os.path.join( _A , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_A ): copyfile(self.vocab_file , _A ) return (out_vocab_file,)
280
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" from collections import OrderedDict from typing import Any, Mapping, Optional from ... import PreTrainedTokenizer from ...configuration_utils import PretrainedConfig from ...file_utils import TensorType, is_torch_available from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast from ...onnx.utils import compute_effective_axis_dimension from ...utils import logging _UpperCAmelCase = logging.get_logger(__name__) _UpperCAmelCase = { "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json", # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small } class a ( _a ): UpperCamelCase : Any = """blenderbot-small""" UpperCamelCase : List[Any] = ["""past_key_values"""] UpperCamelCase : Union[str, Any] = {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""} def __init__( self : Tuple , lowerCAmelCase : Any=5_0265 , lowerCAmelCase : Any=512 , lowerCAmelCase : Dict=8 , lowerCAmelCase : List[Any]=2048 , lowerCAmelCase : Any=16 , lowerCAmelCase : Union[str, Any]=8 , lowerCAmelCase : List[str]=2048 , lowerCAmelCase : Optional[int]=16 , lowerCAmelCase : Tuple=0.0 , lowerCAmelCase : Optional[int]=0.0 , lowerCAmelCase : Optional[Any]=True , lowerCAmelCase : int=True , lowerCAmelCase : str="gelu" , lowerCAmelCase : Union[str, Any]=512 , lowerCAmelCase : Tuple=0.1 , lowerCAmelCase : Any=0.0 , lowerCAmelCase : List[Any]=0.0 , lowerCAmelCase : Optional[int]=0.0_2 , lowerCAmelCase : List[str]=1 , lowerCAmelCase : str=False , lowerCAmelCase : List[Any]=0 , lowerCAmelCase : Tuple=1 , lowerCAmelCase : Any=2 , lowerCAmelCase : Tuple=2 , **lowerCAmelCase : str , ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Dict =vocab_size SCREAMING_SNAKE_CASE_: Dict =max_position_embeddings SCREAMING_SNAKE_CASE_: Optional[int] =d_model SCREAMING_SNAKE_CASE_: str =encoder_ffn_dim SCREAMING_SNAKE_CASE_: str =encoder_layers SCREAMING_SNAKE_CASE_: Any =encoder_attention_heads SCREAMING_SNAKE_CASE_: Any =decoder_ffn_dim SCREAMING_SNAKE_CASE_: List[str] =decoder_layers SCREAMING_SNAKE_CASE_: str =decoder_attention_heads SCREAMING_SNAKE_CASE_: Dict =dropout SCREAMING_SNAKE_CASE_: str =attention_dropout SCREAMING_SNAKE_CASE_: Union[str, Any] =activation_dropout SCREAMING_SNAKE_CASE_: Tuple =activation_function SCREAMING_SNAKE_CASE_: Optional[int] =init_std SCREAMING_SNAKE_CASE_: Any =encoder_layerdrop SCREAMING_SNAKE_CASE_: Optional[int] =decoder_layerdrop SCREAMING_SNAKE_CASE_: Optional[Any] =use_cache SCREAMING_SNAKE_CASE_: Dict =encoder_layers SCREAMING_SNAKE_CASE_: List[str] =scale_embedding # scale factor will be sqrt(d_model) if True super().__init__( pad_token_id=lowerCAmelCase , bos_token_id=lowerCAmelCase , eos_token_id=lowerCAmelCase , is_encoder_decoder=lowerCAmelCase , decoder_start_token_id=lowerCAmelCase , forced_eos_token_id=lowerCAmelCase , **lowerCAmelCase , ) class a ( _a ): @property def lowerCamelCase__ ( self : Any ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' if self.task in ["default", "seq2seq-lm"]: SCREAMING_SNAKE_CASE_: List[Any] =OrderedDict( [ ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}), ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}), ] ) if self.use_past: SCREAMING_SNAKE_CASE_: Tuple ={0: 'batch'} SCREAMING_SNAKE_CASE_: Optional[int] ={0: 'batch', 1: 'past_decoder_sequence + sequence'} else: SCREAMING_SNAKE_CASE_: str ={0: 'batch', 1: 'decoder_sequence'} SCREAMING_SNAKE_CASE_: int ={0: 'batch', 1: 'decoder_sequence'} if self.use_past: self.fill_with_past_key_values_(lowerCAmelCase , direction="""inputs""" ) elif self.task == "causal-lm": # TODO: figure this case out. SCREAMING_SNAKE_CASE_: Tuple =OrderedDict( [ ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}), ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}), ] ) if self.use_past: SCREAMING_SNAKE_CASE_: List[str] =self.num_layers for i in range(lowerCAmelCase ): SCREAMING_SNAKE_CASE_: int ={0: 'batch', 2: 'past_sequence + sequence'} SCREAMING_SNAKE_CASE_: str ={0: 'batch', 2: 'past_sequence + sequence'} else: SCREAMING_SNAKE_CASE_: str =OrderedDict( [ ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}), ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}), ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}), ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}), ] ) return common_inputs @property def lowerCamelCase__ ( self : List[Any] ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' if self.task in ["default", "seq2seq-lm"]: SCREAMING_SNAKE_CASE_: Any =super().outputs else: SCREAMING_SNAKE_CASE_: Tuple =super(lowerCAmelCase , self ).outputs if self.use_past: SCREAMING_SNAKE_CASE_: int =self.num_layers for i in range(lowerCAmelCase ): SCREAMING_SNAKE_CASE_: Any ={0: 'batch', 2: 'past_sequence + sequence'} SCREAMING_SNAKE_CASE_: Tuple ={0: 'batch', 2: 'past_sequence + sequence'} return common_outputs def lowerCamelCase__ ( self : Dict , lowerCAmelCase : str , lowerCAmelCase : List[Any] = -1 , lowerCAmelCase : Tuple = -1 , lowerCAmelCase : str = False , lowerCAmelCase : int = None , ) -> Mapping[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Optional[int] =self._generate_dummy_inputs_for_sequence_classification_and_question_answering( lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) # Generate decoder inputs SCREAMING_SNAKE_CASE_: str =seq_length if not self.use_past else 1 SCREAMING_SNAKE_CASE_: List[Any] =self._generate_dummy_inputs_for_sequence_classification_and_question_answering( lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Optional[int] ={f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()} SCREAMING_SNAKE_CASE_: Any =dict(**lowerCAmelCase , **lowerCAmelCase ) 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_: int =common_inputs['input_ids'].shape SCREAMING_SNAKE_CASE_: Dict =common_inputs['decoder_input_ids'].shape[1] SCREAMING_SNAKE_CASE_: int =self.num_attention_heads SCREAMING_SNAKE_CASE_: Tuple =( batch, num_encoder_attention_heads, encoder_seq_length, self._config.hidden_size // num_encoder_attention_heads, ) SCREAMING_SNAKE_CASE_: Tuple =decoder_seq_length + 3 SCREAMING_SNAKE_CASE_: str =( batch, num_decoder_attention_heads, decoder_past_length, self._config.hidden_size // num_decoder_attention_heads, ) SCREAMING_SNAKE_CASE_: int =torch.cat( [common_inputs["""decoder_attention_mask"""], torch.ones(lowerCAmelCase , lowerCAmelCase )] , dim=1 ) SCREAMING_SNAKE_CASE_: Optional[int] =[] # If the number of encoder and decoder layers are present in the model configuration, both are considered SCREAMING_SNAKE_CASE_: Dict =self.num_layers SCREAMING_SNAKE_CASE_: List[str] =min(lowerCAmelCase , lowerCAmelCase ) SCREAMING_SNAKE_CASE_: str =max(lowerCAmelCase , lowerCAmelCase ) - min_num_layers SCREAMING_SNAKE_CASE_: Optional[int] ='encoder' if num_encoder_layers > num_decoder_layers else 'decoder' for _ in range(lowerCAmelCase ): common_inputs["past_key_values"].append( ( torch.zeros(lowerCAmelCase ), torch.zeros(lowerCAmelCase ), torch.zeros(lowerCAmelCase ), torch.zeros(lowerCAmelCase ), ) ) # TODO: test this. SCREAMING_SNAKE_CASE_: List[Any] =encoder_shape if remaining_side_name == 'encoder' else decoder_shape for _ in range(lowerCAmelCase , lowerCAmelCase ): common_inputs["past_key_values"].append((torch.zeros(lowerCAmelCase ), torch.zeros(lowerCAmelCase )) ) return common_inputs def lowerCamelCase__ ( self : int , lowerCAmelCase : Optional[int] , lowerCAmelCase : Optional[int] = -1 , lowerCAmelCase : Any = -1 , lowerCAmelCase : List[Any] = False , lowerCAmelCase : List[str] = None , ) -> Mapping[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Any =self._generate_dummy_inputs_for_sequence_classification_and_question_answering( lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) 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_: Optional[Any] =common_inputs['input_ids'].shape # Not using the same length for past_key_values SCREAMING_SNAKE_CASE_: Any =seqlen + 2 SCREAMING_SNAKE_CASE_: Dict =self.num_layers SCREAMING_SNAKE_CASE_: Optional[Any] =self.num_attention_heads SCREAMING_SNAKE_CASE_: Union[str, Any] =( batch, num_encoder_attention_heads, past_key_values_length, self._config.hidden_size // num_encoder_attention_heads, ) SCREAMING_SNAKE_CASE_: Tuple =common_inputs['attention_mask'].dtype SCREAMING_SNAKE_CASE_: Optional[int] =torch.cat( [common_inputs["""attention_mask"""], torch.ones(lowerCAmelCase , lowerCAmelCase , dtype=lowerCAmelCase )] , dim=1 ) SCREAMING_SNAKE_CASE_: Any =[ (torch.zeros(lowerCAmelCase ), torch.zeros(lowerCAmelCase )) for _ in range(lowerCAmelCase ) ] return common_inputs def lowerCamelCase__ ( self : List[str] , lowerCAmelCase : Dict , lowerCAmelCase : Optional[int] = -1 , lowerCAmelCase : int = -1 , lowerCAmelCase : List[Any] = False , lowerCAmelCase : Tuple = None , ) -> Mapping[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Tuple =compute_effective_axis_dimension( lowerCAmelCase , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX SCREAMING_SNAKE_CASE_: List[str] =tokenizer.num_special_tokens_to_add(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: int =compute_effective_axis_dimension( lowerCAmelCase , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=lowerCAmelCase ) # Generate dummy inputs according to compute batch and sequence SCREAMING_SNAKE_CASE_: Optional[int] =[' '.join([tokenizer.unk_token] ) * seq_length] * batch_size SCREAMING_SNAKE_CASE_: List[str] =dict(tokenizer(lowerCAmelCase , return_tensors=lowerCAmelCase ) ) return common_inputs def lowerCamelCase__ ( self : Tuple , lowerCAmelCase : Any , lowerCAmelCase : List[str] = -1 , lowerCAmelCase : Optional[Any] = -1 , lowerCAmelCase : int = False , lowerCAmelCase : Tuple = None , ) -> Mapping[str, Any]: '''simple docstring''' if self.task in ["default", "seq2seq-lm"]: SCREAMING_SNAKE_CASE_: Optional[Any] =self._generate_dummy_inputs_for_default_and_seqaseq_lm( lowerCAmelCase , batch_size=lowerCAmelCase , seq_length=lowerCAmelCase , is_pair=lowerCAmelCase , framework=lowerCAmelCase ) elif self.task == "causal-lm": SCREAMING_SNAKE_CASE_: Any =self._generate_dummy_inputs_for_causal_lm( lowerCAmelCase , batch_size=lowerCAmelCase , seq_length=lowerCAmelCase , is_pair=lowerCAmelCase , framework=lowerCAmelCase ) else: SCREAMING_SNAKE_CASE_: Optional[int] =self._generate_dummy_inputs_for_sequence_classification_and_question_answering( lowerCAmelCase , batch_size=lowerCAmelCase , seq_length=lowerCAmelCase , is_pair=lowerCAmelCase , framework=lowerCAmelCase ) return common_inputs def lowerCamelCase__ ( self : Tuple , lowerCAmelCase : Optional[int] , lowerCAmelCase : int , lowerCAmelCase : Any , lowerCAmelCase : int ) -> int: '''simple docstring''' if self.task in ["default", "seq2seq-lm"]: SCREAMING_SNAKE_CASE_: List[Any] =super()._flatten_past_key_values_(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) else: SCREAMING_SNAKE_CASE_: Tuple =super(lowerCAmelCase , self )._flatten_past_key_values_( lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase )
173
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
from ...processing_utils import ProcessorMixin class __A ( _a ): '''simple docstring''' lowerCAmelCase_ = """WhisperFeatureExtractor""" lowerCAmelCase_ = """WhisperTokenizer""" def __init__( self , __lowerCAmelCase , __lowerCAmelCase ): '''simple docstring''' super().__init__(__lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = self.feature_extractor lowerCamelCase__ = False def __lowerCamelCase ( self , __lowerCAmelCase=None , __lowerCAmelCase=None , __lowerCAmelCase=True ): '''simple docstring''' return self.tokenizer.get_decoder_prompt_ids(task=__lowerCAmelCase , language=__lowerCAmelCase , no_timestamps=__lowerCAmelCase ) def __call__( self , *__lowerCAmelCase , **__lowerCAmelCase ): '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__lowerCAmelCase , **__lowerCAmelCase ) lowerCamelCase__ = kwargs.pop('''audio''' , __lowerCAmelCase ) lowerCamelCase__ = kwargs.pop('''sampling_rate''' , __lowerCAmelCase ) lowerCamelCase__ = kwargs.pop('''text''' , __lowerCAmelCase ) if len(__lowerCAmelCase ) > 0: lowerCamelCase__ = args[0] lowerCamelCase__ = args[1:] if audio is None and text is None: raise ValueError('''You need to specify either an `audio` or `text` input to process.''' ) if audio is not None: lowerCamelCase__ = self.feature_extractor(__lowerCAmelCase , *__lowerCAmelCase , sampling_rate=__lowerCAmelCase , **__lowerCAmelCase ) if text is not None: lowerCamelCase__ = self.tokenizer(__lowerCAmelCase , **__lowerCAmelCase ) if text is None: return inputs elif audio is None: return encodings else: lowerCamelCase__ = encodings['input_ids'] return inputs def __lowerCamelCase ( self , *__lowerCAmelCase , **__lowerCAmelCase ): '''simple docstring''' return self.tokenizer.batch_decode(*__lowerCAmelCase , **__lowerCAmelCase ) def __lowerCamelCase ( self , *__lowerCAmelCase , **__lowerCAmelCase ): '''simple docstring''' return self.tokenizer.decode(*__lowerCAmelCase , **__lowerCAmelCase ) def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase="np" ): '''simple docstring''' return self.tokenizer.get_prompt_ids(__lowerCAmelCase , return_tensors=__lowerCAmelCase )
209
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : Dict = 0 while len(lowerCamelCase_ ) > 1: UpperCAmelCase_ : Dict = 0 # Consider two files with minimum cost to be merged for _ in range(2 ): UpperCAmelCase_ : Union[str, Any] = files.index(min(lowerCamelCase_ ) ) temp += files[min_index] files.pop(lowerCamelCase_ ) files.append(lowerCamelCase_ ) optimal_merge_cost += temp return optimal_merge_cost if __name__ == "__main__": import doctest doctest.testmod()
29
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowerCamelCase__ = logging.get_logger(__name__) lowerCamelCase__ = { "xlm-roberta-base": "https://huggingface.co/xlm-roberta-base/resolve/main/config.json", "xlm-roberta-large": "https://huggingface.co/xlm-roberta-large/resolve/main/config.json", "xlm-roberta-large-finetuned-conll02-dutch": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/config.json" ), "xlm-roberta-large-finetuned-conll02-spanish": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/config.json" ), "xlm-roberta-large-finetuned-conll03-english": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/config.json" ), "xlm-roberta-large-finetuned-conll03-german": ( "https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/config.json" ), } class A__ ( _a ): lowercase = """xlm-roberta""" def __init__( self : Any , a : List[str]=30_522 , a : Optional[int]=768 , a : Optional[int]=12 , a : int=12 , a : str=3_072 , a : List[str]="gelu" , a : Dict=0.1 , a : int=0.1 , a : str=512 , a : Optional[int]=2 , a : str=0.0_2 , a : Union[str, Any]=1E-12 , a : Optional[int]=1 , a : Tuple=0 , a : Union[str, Any]=2 , a : Tuple="absolute" , a : str=True , a : Tuple=None , **a : Optional[int] , ): '''simple docstring''' super().__init__(pad_token_id=a , bos_token_id=a , eos_token_id=a , **a ) lowerCAmelCase__ : int = vocab_size lowerCAmelCase__ : Union[str, Any] = hidden_size lowerCAmelCase__ : Dict = num_hidden_layers lowerCAmelCase__ : Any = num_attention_heads lowerCAmelCase__ : Any = hidden_act lowerCAmelCase__ : List[Any] = intermediate_size lowerCAmelCase__ : Optional[int] = hidden_dropout_prob lowerCAmelCase__ : Any = attention_probs_dropout_prob lowerCAmelCase__ : List[Any] = max_position_embeddings lowerCAmelCase__ : Optional[int] = type_vocab_size lowerCAmelCase__ : Optional[Any] = initializer_range lowerCAmelCase__ : Optional[int] = layer_norm_eps lowerCAmelCase__ : Tuple = position_embedding_type lowerCAmelCase__ : str = use_cache lowerCAmelCase__ : Optional[int] = classifier_dropout class A__ ( _a ): @property def _lowerCamelCase ( self : Any ): '''simple docstring''' if self.task == "multiple-choice": lowerCAmelCase__ : Any = {0: 'batch', 1: 'choice', 2: 'sequence'} else: lowerCAmelCase__ : int = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
212
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
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() lowerCAmelCase__ :Tuple = logging.get_logger(__name__) def lowerCAmelCase__ ( a__: Optional[Any] ) -> int: '''simple docstring''' if "resnet-50" in model_name: _UpperCAmelCase = ResNetConfig.from_pretrained('microsoft/resnet-50' ) elif "resnet-101" in model_name: _UpperCAmelCase = ResNetConfig.from_pretrained('microsoft/resnet-101' ) else: raise ValueError('Model name should include either resnet50 or resnet101' ) _UpperCAmelCase = DetrConfig(use_timm_backbone=lowerCamelCase_ , backbone_config=lowerCamelCase_ ) # set label attributes _UpperCAmelCase = 'panoptic' in model_name if is_panoptic: _UpperCAmelCase = 2_5_0 else: _UpperCAmelCase = 9_1 _UpperCAmelCase = 'huggingface/label-files' _UpperCAmelCase = 'coco-detection-id2label.json' _UpperCAmelCase = json.load(open(hf_hub_download(lowerCamelCase_ , lowerCamelCase_ , repo_type='dataset' ) , 'r' ) ) _UpperCAmelCase = {int(lowerCamelCase_ ): v for k, v in idalabel.items()} _UpperCAmelCase = idalabel _UpperCAmelCase = {v: k for k, v in idalabel.items()} return config, is_panoptic def lowerCAmelCase__ ( a__: Optional[Any] ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = [] # 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__ ( a__: Any , a__: Optional[int] , a__: Optional[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase = state_dict.pop(lowerCamelCase_ ) _UpperCAmelCase = val def lowerCAmelCase__ ( a__: str , a__: Union[str, Any]=False ) -> int: '''simple docstring''' _UpperCAmelCase = '' if is_panoptic: _UpperCAmelCase = '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) _UpperCAmelCase = state_dict.pop(F'''{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight''' ) _UpperCAmelCase = 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 _UpperCAmelCase = in_proj_weight[:2_5_6, :] _UpperCAmelCase = in_proj_bias[:2_5_6] _UpperCAmelCase = in_proj_weight[2_5_6:5_1_2, :] _UpperCAmelCase = in_proj_bias[2_5_6:5_1_2] _UpperCAmelCase = in_proj_weight[-2_5_6:, :] _UpperCAmelCase = in_proj_bias[-2_5_6:] # 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 _UpperCAmelCase = state_dict.pop(F'''{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight''' ) _UpperCAmelCase = 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 _UpperCAmelCase = in_proj_weight[:2_5_6, :] _UpperCAmelCase = in_proj_bias[:2_5_6] _UpperCAmelCase = in_proj_weight[2_5_6:5_1_2, :] _UpperCAmelCase = in_proj_bias[2_5_6:5_1_2] _UpperCAmelCase = in_proj_weight[-2_5_6:, :] _UpperCAmelCase = in_proj_bias[-2_5_6:] # read in weights + bias of input projection layer of cross-attention _UpperCAmelCase = state_dict.pop( F'''{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight''' ) _UpperCAmelCase = 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 _UpperCAmelCase = in_proj_weight_cross_attn[:2_5_6, :] _UpperCAmelCase = in_proj_bias_cross_attn[:2_5_6] _UpperCAmelCase = in_proj_weight_cross_attn[2_5_6:5_1_2, :] _UpperCAmelCase = in_proj_bias_cross_attn[2_5_6:5_1_2] _UpperCAmelCase = in_proj_weight_cross_attn[-2_5_6:, :] _UpperCAmelCase = in_proj_bias_cross_attn[-2_5_6:] def lowerCAmelCase__ ( ) -> int: '''simple docstring''' _UpperCAmelCase = 'http://images.cocodataset.org/val2017/000000039769.jpg' _UpperCAmelCase = Image.open(requests.get(lowerCamelCase_ , stream=lowerCamelCase_ ).raw ) return im @torch.no_grad() def lowerCAmelCase__ ( a__: Optional[Any] , a__: Any=None , a__: Dict=False ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = get_detr_config(lowerCamelCase_ ) # load original model from torch hub _UpperCAmelCase = { 'detr-resnet-50': 'detr_resnet50', 'detr-resnet-101': 'detr_resnet101', } logger.info(F'''Converting model {model_name}...''' ) _UpperCAmelCase = torch.hub.load('facebookresearch/detr' , model_name_to_original_name[model_name] , pretrained=lowerCamelCase_ ).eval() _UpperCAmelCase = detr.state_dict() # rename keys for src, dest in create_rename_keys(lowerCamelCase_ ): if is_panoptic: _UpperCAmelCase = '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 _UpperCAmelCase = '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' ) ): _UpperCAmelCase = state_dict.pop(lowerCamelCase_ ) _UpperCAmelCase = val elif "class_labels_classifier" in key or "bbox_predictor" in key: _UpperCAmelCase = state_dict.pop(lowerCamelCase_ ) _UpperCAmelCase = val elif key.startswith('bbox_attention' ) or key.startswith('mask_head' ): continue else: _UpperCAmelCase = state_dict.pop(lowerCamelCase_ ) _UpperCAmelCase = val else: if not key.startswith('class_labels_classifier' ) and not key.startswith('bbox_predictor' ): _UpperCAmelCase = state_dict.pop(lowerCamelCase_ ) _UpperCAmelCase = val # finally, create HuggingFace model and load state dict _UpperCAmelCase = DetrForSegmentation(lowerCamelCase_ ) if is_panoptic else DetrForObjectDetection(lowerCamelCase_ ) model.load_state_dict(lowerCamelCase_ ) model.eval() # verify our conversion on an image _UpperCAmelCase = 'coco_panoptic' if is_panoptic else 'coco_detection' _UpperCAmelCase = DetrImageProcessor(format=lowerCamelCase_ ) _UpperCAmelCase = processor(images=prepare_img() , return_tensors='pt' ) _UpperCAmelCase = encoding['pixel_values'] _UpperCAmelCase = detr(lowerCamelCase_ ) _UpperCAmelCase = 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__": lowerCAmelCase__ :Dict = 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.''') lowerCAmelCase__ :List[str] = parser.parse_args() convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
329
import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" return MobileViTVaConfig( image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_act=self.hidden_act, conv_kernel_size=self.conv_kernel_size, output_stride=self.output_stride, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, width_multiplier=self.width_multiplier, ffn_dropout=self.ffn_dropout_prob, attn_dropout=self.attn_dropout_prob, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): self.assertListEqual( list(hidden_states[i].shape[-2:]), [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor], ) divisor *= 2 self.assertEqual(self.model_tester.output_stride, divisor // 2) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor( [ [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]], [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]], [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]], ], device=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
0
import inspect import unittest from transformers import MobileNetVaConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import MobileNetVaImageProcessor class UpperCAmelCase ( _a ): '''simple docstring''' def snake_case__ ( self : int ): """simple docstring""" snake_case_ = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(__lowercase , "tf_padding" ) ) self.parent.assertTrue(hasattr(__lowercase , "depth_multiplier" ) ) class UpperCAmelCase : '''simple docstring''' def __init__( self : Union[str, Any] , __lowercase : Optional[Any] , __lowercase : Optional[int]=13 , __lowercase : Optional[int]=3 , __lowercase : Tuple=32 , __lowercase : Optional[Any]=0.25 , __lowercase : Optional[int]=8 , __lowercase : List[str]=8 , __lowercase : str=6 , __lowercase : Optional[Any]=32 , __lowercase : Optional[Any]=True , __lowercase : Union[str, Any]=True , __lowercase : List[str]=True , __lowercase : Optional[Any]="relu6" , __lowercase : Union[str, Any]=12_80 , __lowercase : Dict=0.1 , __lowercase : Optional[Any]=0.02 , __lowercase : Union[str, Any]=True , __lowercase : int=True , __lowercase : Union[str, Any]=10 , __lowercase : Optional[int]=None , ): """simple docstring""" snake_case_ = parent snake_case_ = batch_size snake_case_ = num_channels snake_case_ = image_size snake_case_ = depth_multiplier snake_case_ = depth_divisible_by snake_case_ = min_depth snake_case_ = expand_ratio snake_case_ = tf_padding snake_case_ = output_stride snake_case_ = first_layer_is_expansion snake_case_ = finegrained_output snake_case_ = hidden_act snake_case_ = last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier ) snake_case_ = classifier_dropout_prob snake_case_ = use_labels snake_case_ = is_training snake_case_ = num_labels snake_case_ = initializer_range snake_case_ = scope def snake_case__ ( self : Union[str, Any] ): """simple docstring""" snake_case_ = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) snake_case_ = None snake_case_ = None if self.use_labels: snake_case_ = ids_tensor([self.batch_size] , self.num_labels ) snake_case_ = ids_tensor([self.batch_size, self.image_size, self.image_size] , self.num_labels ) snake_case_ = self.get_config() return config, pixel_values, labels, pixel_labels def snake_case__ ( self : Dict ): """simple docstring""" return MobileNetVaConfig( num_channels=self.num_channels , image_size=self.image_size , depth_multiplier=self.depth_multiplier , depth_divisible_by=self.depth_divisible_by , min_depth=self.min_depth , expand_ratio=self.expand_ratio , output_stride=self.output_stride , first_layer_is_expansion=self.first_layer_is_expansion , finegrained_output=self.finegrained_output , hidden_act=self.hidden_act , tf_padding=self.tf_padding , classifier_dropout_prob=self.classifier_dropout_prob , initializer_range=self.initializer_range , ) def snake_case__ ( self : List[Any] , __lowercase : List[Any] , __lowercase : List[Any] , __lowercase : Any , __lowercase : List[str] ): """simple docstring""" snake_case_ = MobileNetVaModel(config=__lowercase ) model.to(__lowercase ) model.eval() snake_case_ = model(__lowercase ) self.parent.assertEqual( result.last_hidden_state.shape , ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) self.parent.assertEqual( result.pooler_output.shape , (self.batch_size, self.last_hidden_size) , ) def snake_case__ ( self : List[Any] , __lowercase : str , __lowercase : Tuple , __lowercase : Union[str, Any] , __lowercase : str ): """simple docstring""" snake_case_ = self.num_labels snake_case_ = MobileNetVaForImageClassification(__lowercase ) model.to(__lowercase ) model.eval() snake_case_ = model(__lowercase , labels=__lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def snake_case__ ( self : List[str] , __lowercase : Optional[int] , __lowercase : int , __lowercase : Optional[int] , __lowercase : Optional[Any] ): """simple docstring""" snake_case_ = self.num_labels snake_case_ = MobileNetVaForSemanticSegmentation(__lowercase ) model.to(__lowercase ) model.eval() snake_case_ = model(__lowercase ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) snake_case_ = model(__lowercase , labels=__lowercase ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) def snake_case__ ( self : Union[str, Any] ): """simple docstring""" snake_case_ = self.prepare_config_and_inputs() snake_case_ = config_and_inputs snake_case_ = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class UpperCAmelCase ( _a , _a , unittest.TestCase ): '''simple docstring''' lowerCAmelCase_ = ( (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation) if is_torch_available() else () ) lowerCAmelCase_ = ( { """feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification, """image-segmentation""": MobileNetVaForSemanticSegmentation, } if is_torch_available() else {} ) lowerCAmelCase_ = False lowerCAmelCase_ = False lowerCAmelCase_ = False lowerCAmelCase_ = False def snake_case__ ( self : Optional[int] ): """simple docstring""" snake_case_ = MobileNetVaModelTester(self ) snake_case_ = MobileNetVaConfigTester(self , config_class=__lowercase , has_text_modality=__lowercase ) def snake_case__ ( self : Any ): """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason="MobileNetV2 does not use inputs_embeds" ) def snake_case__ ( self : str ): """simple docstring""" pass @unittest.skip(reason="MobileNetV2 does not support input and output embeddings" ) def snake_case__ ( self : str ): """simple docstring""" pass @unittest.skip(reason="MobileNetV2 does not output attentions" ) def snake_case__ ( self : int ): """simple docstring""" pass def snake_case__ ( self : Dict ): """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: snake_case_ = model_class(__lowercase ) snake_case_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic snake_case_ = [*signature.parameters.keys()] snake_case_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , __lowercase ) def snake_case__ ( self : Optional[Any] ): """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__lowercase ) def snake_case__ ( self : Any ): """simple docstring""" def check_hidden_states_output(__lowercase : Tuple , __lowercase : int , __lowercase : str ): snake_case_ = model_class(__lowercase ) model.to(__lowercase ) model.eval() with torch.no_grad(): snake_case_ = model(**self._prepare_for_class(__lowercase , __lowercase ) ) snake_case_ = outputs.hidden_states snake_case_ = 16 self.assertEqual(len(__lowercase ) , __lowercase ) snake_case_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: snake_case_ = True check_hidden_states_output(__lowercase , __lowercase , __lowercase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] snake_case_ = True check_hidden_states_output(__lowercase , __lowercase , __lowercase ) def snake_case__ ( self : Tuple ): """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__lowercase ) def snake_case__ ( self : Optional[Any] ): """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__lowercase ) @slow def snake_case__ ( self : Union[str, Any] ): """simple docstring""" for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: snake_case_ = MobileNetVaModel.from_pretrained(__lowercase ) self.assertIsNotNone(__lowercase ) def lowerCamelCase__ ( ): '''simple docstring''' snake_case_ = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_torch @require_vision class UpperCAmelCase ( unittest.TestCase ): '''simple docstring''' @cached_property def snake_case__ ( self : Dict ): """simple docstring""" return ( MobileNetVaImageProcessor.from_pretrained("google/mobilenet_v2_1.0_224" ) if is_vision_available() else None ) @slow def snake_case__ ( self : Optional[Any] ): """simple docstring""" snake_case_ = MobileNetVaForImageClassification.from_pretrained("google/mobilenet_v2_1.0_224" ).to(__lowercase ) snake_case_ = self.default_image_processor snake_case_ = prepare_img() snake_case_ = image_processor(images=__lowercase , return_tensors="pt" ).to(__lowercase ) # forward pass with torch.no_grad(): snake_case_ = model(**__lowercase ) # verify the logits snake_case_ = torch.Size((1, 10_01) ) self.assertEqual(outputs.logits.shape , __lowercase ) snake_case_ = torch.tensor([0.2445, -1.1993, 0.1905] ).to(__lowercase ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , __lowercase , atol=1E-4 ) ) @slow def snake_case__ ( self : List[Any] ): """simple docstring""" snake_case_ = MobileNetVaForSemanticSegmentation.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513" ) snake_case_ = model.to(__lowercase ) snake_case_ = MobileNetVaImageProcessor.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513" ) snake_case_ = prepare_img() snake_case_ = image_processor(images=__lowercase , return_tensors="pt" ).to(__lowercase ) # forward pass with torch.no_grad(): snake_case_ = model(**__lowercase ) snake_case_ = outputs.logits # verify the logits snake_case_ = torch.Size((1, 21, 65, 65) ) self.assertEqual(logits.shape , __lowercase ) snake_case_ = torch.tensor( [ [[17.57_90, 17.75_81, 18.33_55], [18.32_57, 18.42_30, 18.89_73], [18.61_69, 18.86_50, 19.21_87]], [[-2.1595, -2.0977, -2.3741], [-2.4226, -2.3028, -2.6835], [-2.7819, -2.5991, -2.7706]], [[4.2058, 4.8317, 4.7638], [4.4136, 5.0361, 4.9383], [4.5028, 4.9644, 4.8734]], ] , device=__lowercase , ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3] , __lowercase , atol=1E-4 ) )
187
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
0
'''simple docstring''' import tempfile import unittest import numpy as np from diffusers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionPipeline, PNDMScheduler, ) from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class lowercase ( _a , unittest.TestCase ): """simple docstring""" _a = """hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline""" def lowerCAmelCase__ ( self , UpperCamelCase_=0 ): '''simple docstring''' UpperCamelCase__ :str = np.random.RandomState(UpperCamelCase_ ) UpperCamelCase__ :List[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Tuple = self.get_dummy_inputs() UpperCamelCase__ :Optional[Any] = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :Any = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :Tuple = np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) UpperCamelCase__ :List[Any] = PNDMScheduler.from_config(pipe.scheduler.config , skip_prk_steps=UpperCamelCase_ ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Dict = self.get_dummy_inputs() UpperCamelCase__ :str = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :List[str] = np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) UpperCamelCase__ :List[str] = LMSDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :List[Any] = self.get_dummy_inputs() UpperCamelCase__ :Union[str, Any] = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :Tuple = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :str = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Union[str, Any] = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) UpperCamelCase__ :Optional[int] = EulerDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :List[Any] = self.get_dummy_inputs() UpperCamelCase__ :int = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :Any = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :Any = np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) UpperCamelCase__ :Union[str, Any] = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :List[Any] = self.get_dummy_inputs() UpperCamelCase__ :List[str] = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :Any = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :Any = np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) UpperCamelCase__ :int = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :List[Any] = self.get_dummy_inputs() UpperCamelCase__ :Optional[Any] = pipe(**UpperCamelCase_ ).images UpperCamelCase__ :List[Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 128, 128, 3) UpperCamelCase__ :int = np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :int = self.get_dummy_inputs() UpperCamelCase__ :str = 3 * [inputs['prompt']] # forward UpperCamelCase__ :Optional[Any] = pipe(**UpperCamelCase_ ) UpperCamelCase__ :Optional[Any] = output.images[0, -3:, -3:, -1] UpperCamelCase__ :List[Any] = self.get_dummy_inputs() UpperCamelCase__ :Any = 3 * [inputs.pop('''prompt''' )] UpperCamelCase__ :Optional[int] = pipe.tokenizer( UpperCamelCase_ , padding='''max_length''' , max_length=pipe.tokenizer.model_max_length , truncation=UpperCamelCase_ , return_tensors='''np''' , ) UpperCamelCase__ :Optional[int] = text_inputs['input_ids'] UpperCamelCase__ :str = pipe.text_encoder(input_ids=text_inputs.astype(np.intaa ) )[0] UpperCamelCase__ :Tuple = prompt_embeds # forward UpperCamelCase__ :Union[str, Any] = pipe(**UpperCamelCase_ ) UpperCamelCase__ :Tuple = output.images[0, -3:, -3:, -1] assert np.abs(image_slice_a.flatten() - image_slice_a.flatten() ).max() < 1e-4 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[str] = OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint , provider='''CPUExecutionProvider''' ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Union[str, Any] = self.get_dummy_inputs() UpperCamelCase__ :Any = 3 * ['this is a negative prompt'] UpperCamelCase__ :int = negative_prompt UpperCamelCase__ :List[str] = 3 * [inputs['prompt']] # forward UpperCamelCase__ :str = pipe(**UpperCamelCase_ ) UpperCamelCase__ :Tuple = output.images[0, -3:, -3:, -1] UpperCamelCase__ :Optional[Any] = self.get_dummy_inputs() UpperCamelCase__ :int = 3 * [inputs.pop('''prompt''' )] UpperCamelCase__ :Optional[int] = [] for p in [prompt, negative_prompt]: UpperCamelCase__ :int = pipe.tokenizer( UpperCamelCase_ , padding='''max_length''' , max_length=pipe.tokenizer.model_max_length , truncation=UpperCamelCase_ , return_tensors='''np''' , ) UpperCamelCase__ :List[Any] = text_inputs['input_ids'] embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa ) )[0] ) UpperCamelCase__ :Optional[Any] = embeds # forward UpperCamelCase__ :List[str] = pipe(**UpperCamelCase_ ) UpperCamelCase__ :str = output.images[0, -3:, -3:, -1] assert np.abs(image_slice_a.flatten() - image_slice_a.flatten() ).max() < 1e-4 @nightly @require_onnxruntime @require_torch_gpu class lowercase ( unittest.TestCase ): """simple docstring""" @property def lowerCAmelCase__ ( self ): '''simple docstring''' return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Union[str, Any] = ort.SessionOptions() UpperCamelCase__ :str = False return options def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = OnnxStableDiffusionPipeline.from_pretrained( '''CompVis/stable-diffusion-v1-4''' , revision='''onnx''' , safety_checker=UpperCamelCase_ , feature_extractor=UpperCamelCase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) sd_pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Tuple = 'A painting of a squirrel eating a burger' np.random.seed(0 ) UpperCamelCase__ :int = sd_pipe([prompt] , guidance_scale=6.0 , num_inference_steps=10 , output_type='''np''' ) UpperCamelCase__ :Union[str, Any] = output.images UpperCamelCase__ :Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase__ :Optional[int] = np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-3 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Union[str, Any] = DDIMScheduler.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , subfolder='''scheduler''' , revision='''onnx''' ) UpperCamelCase__ :int = OnnxStableDiffusionPipeline.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , revision='''onnx''' , scheduler=UpperCamelCase_ , safety_checker=UpperCamelCase_ , feature_extractor=UpperCamelCase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) sd_pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Dict = 'open neural network exchange' UpperCamelCase__ :Union[str, Any] = np.random.RandomState(0 ) UpperCamelCase__ :int = sd_pipe([prompt] , guidance_scale=7.5 , num_inference_steps=10 , generator=UpperCamelCase_ , output_type='''np''' ) UpperCamelCase__ :Tuple = output.images UpperCamelCase__ :Union[str, Any] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase__ :List[Any] = np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-3 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = LMSDiscreteScheduler.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , subfolder='''scheduler''' , revision='''onnx''' ) UpperCamelCase__ :Optional[int] = OnnxStableDiffusionPipeline.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , revision='''onnx''' , scheduler=UpperCamelCase_ , safety_checker=UpperCamelCase_ , feature_extractor=UpperCamelCase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) sd_pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :int = 'open neural network exchange' UpperCamelCase__ :Optional[Any] = np.random.RandomState(0 ) UpperCamelCase__ :List[str] = sd_pipe([prompt] , guidance_scale=7.5 , num_inference_steps=10 , generator=UpperCamelCase_ , output_type='''np''' ) UpperCamelCase__ :Dict = output.images UpperCamelCase__ :List[str] = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase__ :str = np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-3 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = 0 def test_callback_fn(UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ ) -> None: UpperCamelCase__ :int = True nonlocal number_of_steps number_of_steps += 1 if step == 0: assert latents.shape == (1, 4, 64, 64) UpperCamelCase__ :Tuple = latents[0, -3:, -3:, -1] UpperCamelCase__ :List[str] = np.array( [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167] ) assert np.abs(latents_slice.flatten() - expected_slice ).max() < 1e-3 elif step == 5: assert latents.shape == (1, 4, 64, 64) UpperCamelCase__ :int = latents[0, -3:, -3:, -1] UpperCamelCase__ :Optional[int] = np.array( [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875] ) assert np.abs(latents_slice.flatten() - expected_slice ).max() < 1e-3 UpperCamelCase__ :Any = False UpperCamelCase__ :List[str] = OnnxStableDiffusionPipeline.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , revision='''onnx''' , safety_checker=UpperCamelCase_ , feature_extractor=UpperCamelCase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :str = 'Andromeda galaxy in a bottle' UpperCamelCase__ :Union[str, Any] = np.random.RandomState(0 ) pipe( prompt=UpperCamelCase_ , num_inference_steps=5 , guidance_scale=7.5 , generator=UpperCamelCase_ , callback=UpperCamelCase_ , callback_steps=1 , ) assert test_callback_fn.has_been_called assert number_of_steps == 6 def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :str = OnnxStableDiffusionPipeline.from_pretrained( '''runwayml/stable-diffusion-v1-5''' , revision='''onnx''' , safety_checker=UpperCamelCase_ , feature_extractor=UpperCamelCase_ , provider=self.gpu_provider , sess_options=self.gpu_options , ) assert isinstance(UpperCamelCase_ , UpperCamelCase_ ) assert pipe.safety_checker is None UpperCamelCase__ :Union[str, Any] = pipe('''example prompt''' , num_inference_steps=2 ).images[0] assert image is not None # check that there's no error when saving a pipeline with one of the models being None with tempfile.TemporaryDirectory() as tmpdirname: pipe.save_pretrained(UpperCamelCase_ ) UpperCamelCase__ :int = OnnxStableDiffusionPipeline.from_pretrained(UpperCamelCase_ ) # sanity check that the pipeline still works assert pipe.safety_checker is None UpperCamelCase__ :Optional[int] = pipe('''example prompt''' , num_inference_steps=2 ).images[0] assert image is not None
97
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
0
"""simple docstring""" def __A (_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ->Any: """simple docstring""" if b == 0: return 1 if (b % 2) == 0: return actual_power(lowerCamelCase_ , int(b / 2 ) ) * actual_power(lowerCamelCase_ , int(b / 2 ) ) else: return a * actual_power(lowerCamelCase_ , int(b / 2 ) ) * actual_power(lowerCamelCase_ , int(b / 2 ) ) def __A (_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ->float: """simple docstring""" if b < 0: return 1 / actual_power(lowerCamelCase_ , lowerCamelCase_ ) return actual_power(lowerCamelCase_ , lowerCamelCase_ ) if __name__ == "__main__": print(power(-2, -3))
293
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
0
"""simple docstring""" from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow if is_tf_available(): import numpy as np import tensorflow as tf from transformers import TFCamembertModel @require_tf @require_sentencepiece @require_tokenizers class A_ ( unittest.TestCase ): """simple docstring""" @slow def UpperCAmelCase__ ( self :Dict ): """simple docstring""" lowerCamelCase__ : Dict =TFCamembertModel.from_pretrained('jplu/tf-camembert-base' ) lowerCamelCase__ : Tuple =tf.convert_to_tensor( [[5, 121, 11, 660, 16, 730, 25_543, 110, 83, 6]] , dtype=tf.intaa , ) # J'aime le camembert !" lowerCamelCase__ : List[Any] =model(lowerCamelCase_ )['last_hidden_state'] lowerCamelCase__ : Optional[int] =tf.TensorShape((1, 10, 768) ) self.assertEqual(output.shape , lowerCamelCase_ ) # compare the actual values for a slice. lowerCamelCase__ : Any =tf.convert_to_tensor( [[[-0.02_54, 0.02_35, 0.10_27], [0.06_06, -0.18_11, -0.04_18], [-0.15_61, -0.11_27, 0.26_87]]] , dtype=tf.floataa , ) # camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0') # camembert.eval() # expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach() self.assertTrue(np.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
126
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
0
def lowercase( UpperCamelCase_ ) -> bool: '''simple docstring''' UpperCamelCase = (1 + 24 * n) ** 0.5 return ((1 + root) / 6) % 1 == 0 def lowercase( UpperCamelCase_ = 5000 ) -> int: '''simple docstring''' UpperCamelCase = [(i * (3 * i - 1)) // 2 for i in range(1 , lowerCamelCase_ )] for i, pentagonal_i in enumerate(lowerCamelCase_ ): for j in range(lowerCamelCase_ , len(lowerCamelCase_ ) ): UpperCamelCase = pentagonal_nums[j] UpperCamelCase = pentagonal_i + pentagonal_j UpperCamelCase = pentagonal_j - pentagonal_i if is_pentagonal(lowerCamelCase_ ) and is_pentagonal(lowerCamelCase_ ): return b return -1 if __name__ == "__main__": print(F'''{solution() = }''')
343
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
0
from ....configuration_utils import PretrainedConfig from ....utils import logging UpperCAmelCase : str = logging.get_logger(__name__) UpperCAmelCase : List[Any] = { "CarlCochet/trajectory-transformer-halfcheetah-medium-v2": ( "https://huggingface.co/CarlCochet/trajectory-transformer-halfcheetah-medium-v2/resolve/main/config.json" ), # See all TrajectoryTransformer models at https://huggingface.co/models?filter=trajectory_transformer } class _A( _a ): """simple docstring""" UpperCamelCase : List[str] = """trajectory_transformer""" UpperCamelCase : Optional[Any] = ["""past_key_values"""] UpperCamelCase : Any = { """hidden_size""": """n_embd""", """num_attention_heads""": """n_head""", """num_hidden_layers""": """n_layer""", } def __init__( self , _A=100 , _A=5 , _A=1 , _A=1 , _A=249 , _A=6 , _A=17 , _A=25 , _A=4 , _A=4 , _A=128 , _A=0.1 , _A=0.1 , _A=0.1 , _A=0.0_0_0_6 , _A=512 , _A=0.0_2 , _A=1e-1_2 , _A=1 , _A=True , _A=1 , _A=50256 , _A=50256 , **_A , ): __A : int = vocab_size __A : Dict = action_weight __A : Any = reward_weight __A : List[Any] = value_weight __A : List[str] = max_position_embeddings __A : Any = block_size __A : Tuple = action_dim __A : List[str] = observation_dim __A : Union[str, Any] = transition_dim __A : Optional[Any] = learning_rate __A : Tuple = n_layer __A : str = n_head __A : Union[str, Any] = n_embd __A : Dict = embd_pdrop __A : Optional[int] = attn_pdrop __A : Union[str, Any] = resid_pdrop __A : Any = initializer_range __A : List[str] = layer_norm_eps __A : List[Any] = kaiming_initializer_range __A : Any = use_cache super().__init__(pad_token_id=_A , bos_token_id=_A , eos_token_id=_A , **_A )
280
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
0
"""simple docstring""" from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
173
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class __A ( _a ): '''simple docstring''' lowerCAmelCase_ = DistilBertTokenizer lowerCAmelCase_ = DistilBertTokenizerFast lowerCAmelCase_ = True @slow def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = DistilBertTokenizer.from_pretrained('''distilbert-base-uncased''' ) lowerCamelCase__ = tokenizer.encode('''sequence builders''' , add_special_tokens=__lowerCAmelCase ) lowerCamelCase__ = tokenizer.encode('''multi-sequence build''' , add_special_tokens=__lowerCAmelCase ) lowerCamelCase__ = tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase ) lowerCamelCase__ = tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase , __lowerCAmelCase ) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]
209
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
0
import random import timeit from functools import wraps from typing import Callable, Optional from ..configuration_utils import PretrainedConfig from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING from ..utils import is_pyanvml_available, is_tf_available, logging from .benchmark_utils import ( Benchmark, Memory, MemorySummary, measure_peak_memory_cpu, start_memory_tracing, stop_memory_tracing, ) if is_tf_available(): import tensorflow as tf from tensorflow.python.framework.errors_impl import ResourceExhaustedError from .benchmark_args_tf import TensorFlowBenchmarkArguments if is_pyanvml_available(): import pyanvml.pyanvml as nvml __UpperCAmelCase = logging.get_logger(__name__) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : str ): '''simple docstring''' def run_func(__snake_case : Optional[Any] ): @wraps(lowerCamelCase_ ) def run_in_eager_mode(*__snake_case : int , **__snake_case : str ): return func(*lowerCamelCase_ , **lowerCamelCase_ ) @wraps(lowerCamelCase_ ) @tf.function(experimental_compile=lowerCamelCase_ ) def run_in_graph_mode(*__snake_case : Optional[int] , **__snake_case : Optional[Any] ): return func(*lowerCamelCase_ , **lowerCamelCase_ ) if do_eager_mode is True: if use_xla is not False: raise ValueError( 'Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`.' ) return run_in_eager_mode else: return run_in_graph_mode return run_func def lowercase__ ( __snake_case : List[Any] , __snake_case : Optional[int] , __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : int = random.Random() UpperCAmelCase_ : List[Any] = [rng.randint(0 , vocab_size - 1 ) for i in range(batch_size * sequence_length )] return tf.constant(lowerCamelCase_ , shape=(batch_size, sequence_length) , dtype=tf.intaa ) class lowerCamelCase (_a ): '''simple docstring''' _snake_case : TensorFlowBenchmarkArguments _snake_case : PretrainedConfig _snake_case : str = "TensorFlow" @property def __UpperCAmelCase ( self ) -> Optional[Any]: return tf.__version__ def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> float: UpperCAmelCase_ : Union[str, Any] = self.args.strategy if strategy is None: raise ValueError('A device strategy has to be initialized before using TensorFlow.' ) UpperCAmelCase_ : Optional[int] = self._prepare_inference_func(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return self._measure_speed(_inference ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> float: UpperCAmelCase_ : Dict = self.args.strategy if strategy is None: raise ValueError('A device strategy has to be initialized before using TensorFlow.' ) UpperCAmelCase_ : str = self._prepare_train_func(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return self._measure_speed(_train ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> [Memory, Optional[MemorySummary]]: if self.args.is_gpu: tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = self.args.strategy if strategy is None: raise ValueError('A device strategy has to be initialized before using TensorFlow.' ) UpperCAmelCase_ : Any = self._prepare_inference_func(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return self._measure_memory(_inference ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> [Memory, Optional[MemorySummary]]: if self.args.is_gpu: tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = self.args.strategy if strategy is None: raise ValueError('A device strategy has to be initialized before using TensorFlow.' ) UpperCAmelCase_ : Union[str, Any] = self._prepare_train_func(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return self._measure_memory(_train ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Callable[[], None]: UpperCAmelCase_ : List[str] = self.config_dict[model_name] if self.args.fpaa: raise NotImplementedError('Mixed precision is currently not supported.' ) UpperCAmelCase_ : Union[str, Any] = ( hasattr(_UpperCamelCase , 'architectures' ) and isinstance(config.architectures , _UpperCamelCase ) and len(config.architectures ) > 0 ) if not self.args.only_pretrain_model and has_model_class_in_config: try: UpperCAmelCase_ : List[Any] = 'TF' + config.architectures[0] # prepend 'TF' for tensorflow model UpperCAmelCase_ : Union[str, Any] = __import__('transformers' , fromlist=[model_class] ) UpperCAmelCase_ : Dict = getattr(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = model_cls(_UpperCamelCase ) except ImportError: raise ImportError( f"{model_class} does not exist. If you just want to test the pretrained model, you might want to" ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' ) else: UpperCAmelCase_ : Dict = TF_MODEL_MAPPING[config.__class__](_UpperCamelCase ) # encoder-decoder has vocab size saved differently UpperCAmelCase_ : Tuple = config.vocab_size if hasattr(_UpperCamelCase , 'vocab_size' ) else config.encoder.vocab_size UpperCAmelCase_ : List[Any] = random_input_ids(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) @run_with_tf_optimizations(self.args.eager_mode , self.args.use_xla ) def encoder_decoder_forward(): return model(_UpperCamelCase , decoder_input_ids=_UpperCamelCase , training=_UpperCamelCase ) @run_with_tf_optimizations(self.args.eager_mode , self.args.use_xla ) def encoder_forward(): return model(_UpperCamelCase , training=_UpperCamelCase ) UpperCAmelCase_ : str = encoder_decoder_forward if config.is_encoder_decoder else encoder_forward return _inference def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Callable[[], None]: UpperCAmelCase_ : List[Any] = self.config_dict[model_name] if self.args.eager_mode is not False: raise ValueError('Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.' ) if self.args.fpaa: raise NotImplementedError('Mixed precision is currently not supported.' ) UpperCAmelCase_ : Optional[Any] = ( hasattr(_UpperCamelCase , 'architectures' ) and isinstance(config.architectures , _UpperCamelCase ) and len(config.architectures ) > 0 ) if not self.args.only_pretrain_model and has_model_class_in_config: try: UpperCAmelCase_ : List[Any] = 'TF' + config.architectures[0] # prepend 'TF' for tensorflow model UpperCAmelCase_ : str = __import__('transformers' , fromlist=[model_class] ) UpperCAmelCase_ : Tuple = getattr(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = model_cls(_UpperCamelCase ) except ImportError: raise ImportError( f"{model_class} does not exist. If you just want to test the pretrained model, you might want to" ' set `--only_pretrain_model` or `args.only_pretrain_model=True`.' ) else: UpperCAmelCase_ : str = TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_UpperCamelCase ) # encoder-decoder has vocab size saved differently UpperCAmelCase_ : List[str] = config.vocab_size if hasattr(_UpperCamelCase , 'vocab_size' ) else config.encoder.vocab_size UpperCAmelCase_ : Union[str, Any] = random_input_ids(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) @run_with_tf_optimizations(self.args.eager_mode , self.args.use_xla ) def encoder_decoder_train(): UpperCAmelCase_ : Any = model(_UpperCamelCase , decoder_input_ids=_UpperCamelCase , labels=_UpperCamelCase , training=_UpperCamelCase )[0] UpperCAmelCase_ : List[str] = tf.gradients(_UpperCamelCase , model.trainable_variables ) return gradients @run_with_tf_optimizations(self.args.eager_mode , self.args.use_xla ) def encoder_train(): UpperCAmelCase_ : Optional[Any] = model(_UpperCamelCase , labels=_UpperCamelCase , training=_UpperCamelCase )[0] UpperCAmelCase_ : List[str] = tf.gradients(_UpperCamelCase , model.trainable_variables ) return gradients UpperCAmelCase_ : str = encoder_decoder_train if config.is_encoder_decoder else encoder_train return _train def __UpperCAmelCase ( self , _UpperCamelCase ) -> float: with self.args.strategy.scope(): try: if self.args.is_tpu or self.args.use_xla: # run additional 10 times to stabilize compilation for tpu logger.info('Do inference on TPU. Running model 5 times to stabilize compilation' ) timeit.repeat(_UpperCamelCase , repeat=1 , number=5 ) # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average UpperCAmelCase_ : Dict = timeit.repeat( _UpperCamelCase , repeat=self.args.repeat , number=1_0 , ) return min(_UpperCamelCase ) / 1_0.0 except ResourceExhaustedError as e: self.print_fn(f"Doesn\'t fit on GPU. {e}" ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> [Memory, MemorySummary]: logger.info( 'Note that TensorFlow allocates more memory than ' 'it might need to speed up computation. ' 'The memory reported here corresponds to the memory ' 'reported by `nvidia-smi`, which can vary depending ' 'on total available memory on the GPU that is used.' ) with self.args.strategy.scope(): try: if self.args.trace_memory_line_by_line: if not self.args.eager_mode: raise ValueError( '`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory' ' consumption line by line.' ) UpperCAmelCase_ : str = start_memory_tracing('transformers' ) if self.args.is_tpu: # tpu raise NotImplementedError( 'Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking' ' with `args.memory=False`' ) elif self.args.is_gpu: # gpu if not is_pyanvml_available(): logger.warning( 'py3nvml not installed, we won\'t log GPU memory usage. ' 'Install py3nvml (pip install py3nvml) to log information about GPU.' ) UpperCAmelCase_ : Dict = 'N/A' else: logger.info( 'Measuring total GPU usage on GPU device. Make sure to not have additional processes' ' running on the same GPU.' ) # init nvml nvml.nvmlInit() func() UpperCAmelCase_ : int = nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx ) UpperCAmelCase_ : str = nvml.nvmlDeviceGetMemoryInfo(_UpperCamelCase ) UpperCAmelCase_ : Dict = meminfo.used UpperCAmelCase_ : Any = Memory(_UpperCamelCase ) # shutdown nvml nvml.nvmlShutdown() else: # cpu if self.args.trace_memory_line_by_line: logger.info( 'When enabling line by line tracing, the max peak memory for CPU is inaccurate in' ' TensorFlow.' ) UpperCAmelCase_ : str = None else: UpperCAmelCase_ : Any = measure_peak_memory_cpu(_UpperCamelCase ) UpperCAmelCase_ : Dict = Memory(_UpperCamelCase ) if isinstance(_UpperCamelCase , _UpperCamelCase ) else memory_bytes if self.args.trace_memory_line_by_line: UpperCAmelCase_ : Optional[int] = stop_memory_tracing(_UpperCamelCase ) if memory is None: UpperCAmelCase_ : List[str] = summary.total else: UpperCAmelCase_ : Optional[int] = None return memory, summary except ResourceExhaustedError as e: self.print_fn(f"Doesn\'t fit on GPU. {e}" ) return "N/A", None
29
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
0
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowerCamelCase__ = logging.get_logger(__name__) lowerCamelCase__ = "▁" lowerCamelCase__ = {"vocab_file": "sentencepiece.bpe.model"} lowerCamelCase__ = { "vocab_file": { "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model", } } lowerCamelCase__ = { "facebook/xglm-564M": 2048, } class A__ ( _a ): lowercase = VOCAB_FILES_NAMES lowercase = PRETRAINED_VOCAB_FILES_MAP lowercase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase = ["""input_ids""", """attention_mask"""] def __init__( self : Optional[Any] , a : List[Any] , a : str="<s>" , a : Union[str, Any]="</s>" , a : str="</s>" , a : Optional[int]="<s>" , a : str="<unk>" , a : str="<pad>" , a : Any = None , **a : Any , ): '''simple docstring''' lowerCAmelCase__ : str = {} if sp_model_kwargs is None else sp_model_kwargs # Compatibility with the original tokenizer lowerCAmelCase__ : List[str] = 7 lowerCAmelCase__ : str = [f'''<madeupword{i}>''' for i in range(self.num_madeup_words )] lowerCAmelCase__ : List[str] = kwargs.get('additional_special_tokens' , [] ) kwargs["additional_special_tokens"] += [ word for word in madeup_words if word not in kwargs["additional_special_tokens"] ] super().__init__( bos_token=a , eos_token=a , unk_token=a , sep_token=a , cls_token=a , pad_token=a , sp_model_kwargs=self.sp_model_kwargs , **a , ) lowerCAmelCase__ : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(a ) ) lowerCAmelCase__ : List[Any] = vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-' # spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a' # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab lowerCAmelCase__ : int = 1 # Mimic fairseq token-to-id alignment for the first 4 token lowerCAmelCase__ : int = {'<s>': 0, '<pad>': 1, '</s>': 2, '<unk>': 3} lowerCAmelCase__ : Any = len(self.sp_model ) lowerCAmelCase__ : Optional[int] = {f'''<madeupword{i}>''': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words )} self.fairseq_tokens_to_ids.update(a ) lowerCAmelCase__ : Tuple = {v: k for k, v in self.fairseq_tokens_to_ids.items()} def __getstate__( self : Optional[int] ): '''simple docstring''' lowerCAmelCase__ : Any = self.__dict__.copy() lowerCAmelCase__ : Optional[int] = None lowerCAmelCase__ : Optional[Any] = self.sp_model.serialized_model_proto() return state def __setstate__( self : Optional[Any] , a : Any ): '''simple docstring''' lowerCAmelCase__ : List[Any] = d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): lowerCAmelCase__ : str = {} lowerCAmelCase__ : List[str] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) def _lowerCamelCase ( self : Optional[Any] , a : str , a : Optional[Any] = None ): '''simple docstring''' if token_ids_a is None: return [self.sep_token_id] + token_ids_a lowerCAmelCase__ : Union[str, Any] = [self.sep_token_id] return sep + token_ids_a + sep + sep + token_ids_a def _lowerCamelCase ( self : Any , a : Tuple , a : Dict = None , a : str = False ): '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=a , token_ids_a=a , already_has_special_tokens=a ) if token_ids_a is None: return [1] + ([0] * len(a )) return [1] + ([0] * len(a )) + [1, 1] + ([0] * len(a )) def _lowerCamelCase ( self : Optional[int] , a : List[Any] , a : Optional[Any] = None ): '''simple docstring''' lowerCAmelCase__ : Optional[int] = [self.sep_token_id] if token_ids_a is None: return len(sep + token_ids_a ) * [0] return len(sep + token_ids_a + sep + sep + token_ids_a ) * [0] @property def _lowerCamelCase ( self : Union[str, Any] ): '''simple docstring''' return len(self.sp_model ) + self.fairseq_offset + self.num_madeup_words def _lowerCamelCase ( self : Tuple ): '''simple docstring''' lowerCAmelCase__ : List[Any] = {self.convert_ids_to_tokens(a ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def _lowerCamelCase ( self : Tuple , a : Any ): '''simple docstring''' return self.sp_model.encode(a , out_type=a ) def _lowerCamelCase ( self : Tuple , a : Optional[Any] ): '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] lowerCAmelCase__ : Optional[Any] = self.sp_model.PieceToId(a ) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def _lowerCamelCase ( self : List[Any] , a : Union[str, Any] ): '''simple docstring''' if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset ) def _lowerCamelCase ( self : List[Any] , a : Optional[int] ): '''simple docstring''' lowerCAmelCase__ : Union[str, Any] = ''.join(a ).replace(a , ' ' ).strip() return out_string def _lowerCamelCase ( self : Optional[Any] , a : Dict , a : List[str] = None ): '''simple docstring''' if not os.path.isdir(a ): logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' ) return lowerCAmelCase__ : Optional[Any] = os.path.join( a , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(a ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , a ) elif not os.path.isfile(self.vocab_file ): with open(a , 'wb' ) as fi: lowerCAmelCase__ : Optional[int] = self.sp_model.serialized_model_proto() fi.write(a ) return (out_vocab_file,)
212
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
0
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer lowerCAmelCase__ :Any = logging.get_logger(__name__) lowerCAmelCase__ :Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowerCAmelCase__ :Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } lowerCAmelCase__ :Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } lowerCAmelCase__ :str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } lowerCAmelCase__ :Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 5_1_2, "facebook/dpr-ctx_encoder-multiset-base": 5_1_2, } lowerCAmelCase__ :Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 5_1_2, "facebook/dpr-question_encoder-multiset-base": 5_1_2, } lowerCAmelCase__ :Dict = { "facebook/dpr-reader-single-nq-base": 5_1_2, "facebook/dpr-reader-multiset-base": 5_1_2, } lowerCAmelCase__ :List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } lowerCAmelCase__ :Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } lowerCAmelCase__ :Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class __a ( _a ): _a : Any = VOCAB_FILES_NAMES _a : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP _a : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class __a ( _a ): _a : Optional[int] = VOCAB_FILES_NAMES _a : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP _a : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION lowerCAmelCase__ :Optional[int] = collections.namedtuple( '''DPRSpanPrediction''', ['''span_score''', '''relevance_score''', '''doc_id''', '''start_index''', '''end_index''', '''text'''] ) lowerCAmelCase__ :Any = collections.namedtuple('''DPRReaderOutput''', ['''start_logits''', '''end_logits''', '''relevance_logits''']) lowerCAmelCase__ :str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class __a : def __call__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , **_SCREAMING_SNAKE_CASE , ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( _SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE , ) elif titles is None or texts is None: _UpperCAmelCase = titles if texts is None else texts return super().__call__( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE , ) _UpperCAmelCase = titles if not isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) else [titles] _UpperCAmelCase = texts if not isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) else [texts] _UpperCAmelCase = len(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = questions if not isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) else [questions] * n_passages if len(_SCREAMING_SNAKE_CASE ) != len(_SCREAMING_SNAKE_CASE ): raise ValueError( f'''There should be as many titles than texts but got {len(_SCREAMING_SNAKE_CASE )} titles and {len(_SCREAMING_SNAKE_CASE )} texts.''' ) _UpperCAmelCase = super().__call__(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE )['input_ids'] _UpperCAmelCase = super().__call__(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE )['input_ids'] _UpperCAmelCase = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ] } if return_attention_mask is not False: _UpperCAmelCase = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id ) for input_id in input_ids] ) _UpperCAmelCase = attention_mask return self.pad(_SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = 16 , _SCREAMING_SNAKE_CASE = 64 , _SCREAMING_SNAKE_CASE = 4 , ) -> List[DPRSpanPrediction]: """simple docstring""" _UpperCAmelCase = reader_input['input_ids'] _UpperCAmelCase = reader_output[:3] _UpperCAmelCase = len(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = sorted(range(_SCREAMING_SNAKE_CASE ) , reverse=_SCREAMING_SNAKE_CASE , key=relevance_logits.__getitem__ ) _UpperCAmelCase = [] for doc_id in sorted_docs: _UpperCAmelCase = list(input_ids[doc_id] ) # assuming question & title information is at the beginning of the sequence _UpperCAmelCase = sequence_ids.index(self.sep_token_id , 2 ) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _UpperCAmelCase = sequence_ids.index(self.pad_token_id ) else: _UpperCAmelCase = len(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len] , end_logits=end_logits[doc_id][passage_offset:sequence_len] , max_answer_length=_SCREAMING_SNAKE_CASE , top_spans=_SCREAMING_SNAKE_CASE , ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index] , relevance_score=relevance_logits[doc_id] , doc_id=_SCREAMING_SNAKE_CASE , start_index=_SCREAMING_SNAKE_CASE , end_index=_SCREAMING_SNAKE_CASE , text=self.decode(sequence_ids[start_index : end_index + 1] ) , ) ) if len(_SCREAMING_SNAKE_CASE ) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , ) -> List[DPRSpanPrediction]: """simple docstring""" _UpperCAmelCase = [] for start_index, start_score in enumerate(_SCREAMING_SNAKE_CASE ): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length] ): scores.append(((start_index, start_index + answer_length), start_score + end_score) ) _UpperCAmelCase = sorted(_SCREAMING_SNAKE_CASE , key=lambda _SCREAMING_SNAKE_CASE : x[1] , reverse=_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(f'''Wrong span indices: [{start_index}:{end_index}]''' ) _UpperCAmelCase = end_index - start_index + 1 if length > max_answer_length: raise ValueError(f'''Span is too long: {length} > {max_answer_length}''' ) if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals ): continue chosen_span_intervals.append((start_index, end_index) ) if len(_SCREAMING_SNAKE_CASE ) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class __a ( _a , _a ): _a : Union[str, Any] = VOCAB_FILES_NAMES _a : Any = READER_PRETRAINED_VOCAB_FILES_MAP _a : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION _a : str = ["""input_ids""", """attention_mask"""]
329
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
0
from ..utils import DummyObject, requires_backends class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Union[str, Any] , *__lowercase : Dict , **__lowercase : List[str] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Optional[int] , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : List[Any] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : int , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : List[Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : List[Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Any , *__lowercase : Union[str, Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : Dict , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Optional[Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : Dict , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[Any] , *__lowercase : Any , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Any , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : List[Any] , **__lowercase : Any ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Union[str, Any] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Union[str, Any] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : Tuple , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : List[str] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Union[str, Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[int] , *__lowercase : str , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : str , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[int] , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[int] , *__lowercase : Any , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Union[str, Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Union[str, Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : Tuple , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : List[Any] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Dict , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : List[Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : int , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Dict , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Union[str, Any] , *__lowercase : Union[str, Any] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Optional[int] , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Optional[Any] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) def lowerCamelCase__ ( *_A , **_A ): '''simple docstring''' requires_backends(lowerCamelCase_ , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : int , *__lowercase : Any , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : str , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Union[str, Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : int , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Any , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : Any , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : str , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : List[str] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : int , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : Dict , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : str , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Optional[Any] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : int , **__lowercase : Any ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : Optional[int] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Dict , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Dict , *__lowercase : List[str] , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Any , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[Any] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : Optional[Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : str , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : str , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : Dict , **__lowercase : List[str] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : Tuple , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[int] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : Any , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Optional[Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : List[Any] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : Optional[Any] , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Tuple , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Union[str, Any] , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : int , *__lowercase : Dict , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : List[str] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : Dict , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Any , *__lowercase : Tuple , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Tuple , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Dict , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : Any , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Optional[Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : int , **__lowercase : int ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Any , *__lowercase : Any , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : int , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : List[Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Union[str, Any] , *__lowercase : Optional[int] , **__lowercase : Any ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Any , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Optional[Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : List[Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[Any] , *__lowercase : Optional[Any] , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : int , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Union[str, Any] , *__lowercase : Tuple , **__lowercase : Any ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : Optional[int] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : List[str] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : Any , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : Union[str, Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : List[Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : int , *__lowercase : Dict , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : List[Any] , **__lowercase : int ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[int] , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : List[Any] , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : int , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : int , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Union[str, Any] , *__lowercase : List[str] , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : str , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Tuple , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : str , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : int , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : int , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : Optional[Any] , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Optional[int] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Tuple , *__lowercase : Optional[int] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : Dict , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : int , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : List[Any] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : int , *__lowercase : Optional[Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Union[str, Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Optional[Any] , **__lowercase : Dict ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Tuple , *__lowercase : Optional[int] , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : Tuple , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : Tuple , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[Any] , *__lowercase : Optional[int] , **__lowercase : Dict ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[Any] , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Dict , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : Optional[Any] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[Any] , *__lowercase : int , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : List[str] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : List[str] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : List[Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[int] , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Dict , *__lowercase : str , **__lowercase : Dict ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Dict , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Dict , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[Any] , *__lowercase : int , **__lowercase : int ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Union[str, Any] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Optional[int] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : int , *__lowercase : Dict , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[Any] , *__lowercase : Tuple , **__lowercase : List[str] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Any , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Any , *__lowercase : Tuple , **__lowercase : Tuple ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : List[Any] , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[Any] , *__lowercase : str , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[int] , *__lowercase : Optional[int] , **__lowercase : str ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : Tuple , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Optional[int] , *__lowercase : Optional[Any] , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : List[str] , *__lowercase : Any , **__lowercase : List[str] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Any , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : int , *__lowercase : Dict , **__lowercase : Optional[Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Optional[int] , *__lowercase : Union[str, Any] , **__lowercase : List[Any] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[Any] , *__lowercase : List[str] , **__lowercase : Tuple ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Optional[int] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : str , *__lowercase : List[str] , **__lowercase : Optional[int] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Optional[Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Dict , *__lowercase : Any , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Dict , *__lowercase : Dict , **__lowercase : List[str] ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : Union[str, Any] , *__lowercase : Tuple , **__lowercase : Any ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : Any , *__lowercase : Optional[int] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) class UpperCAmelCase ( metaclass=_a ): '''simple docstring''' lowerCAmelCase_ = ["""torch"""] def __init__( self : Dict , *__lowercase : Dict , **__lowercase : Dict ): """simple docstring""" requires_backends(self , ["torch"] ) @classmethod def snake_case__ ( cls : str , *__lowercase : Union[str, Any] , **__lowercase : Union[str, Any] ): """simple docstring""" requires_backends(cls , ["torch"] ) @classmethod def snake_case__ ( cls : List[str] , *__lowercase : Any , **__lowercase : str ): """simple docstring""" requires_backends(cls , ["torch"] )
187
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """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.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
'''simple docstring''' import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class lowercase ( unittest.TestCase ): """simple docstring""" def lowerCAmelCase__ ( self ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() @property def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[Any] = 1 UpperCamelCase__ :Any = 3 UpperCamelCase__ :Tuple = (32, 32) UpperCamelCase__ :Tuple = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0 ) ).to(UpperCamelCase_ ) return image @property def lowerCAmelCase__ ( self ): '''simple docstring''' torch.manual_seed(0 ) UpperCamelCase__ :Dict = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , ) return model @property def lowerCAmelCase__ ( self ): '''simple docstring''' torch.manual_seed(0 ) UpperCamelCase__ :str = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , ) return model @property def lowerCAmelCase__ ( self ): '''simple docstring''' torch.manual_seed(0 ) UpperCamelCase__ :Optional[int] = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=5006 , ) return RobertaSeriesModelWithTransformation(UpperCamelCase_ ) @property def lowerCAmelCase__ ( self ): '''simple docstring''' def extract(*UpperCamelCase_ , **UpperCamelCase_ ): class lowercase : """simple docstring""" def __init__( self ): '''simple docstring''' UpperCamelCase__ :Optional[int] = torch.ones([0] ) def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' self.pixel_values.to(UpperCamelCase_ ) return self return Out() return extract def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Any = 'cpu' # ensure determinism for the device-dependent torch.Generator UpperCamelCase__ :List[Any] = self.dummy_cond_unet UpperCamelCase__ :Union[str, Any] = PNDMScheduler(skip_prk_steps=UpperCamelCase_ ) UpperCamelCase__ :Optional[Any] = self.dummy_vae UpperCamelCase__ :List[Any] = self.dummy_text_encoder UpperCamelCase__ :Any = XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''' ) UpperCamelCase__ :Tuple = 77 UpperCamelCase__ :int = self.dummy_image.to(UpperCamelCase_ ) UpperCamelCase__ :int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk UpperCamelCase__ :Union[str, Any] = AltDiffusionImgaImgPipeline( unet=UpperCamelCase_ , scheduler=UpperCamelCase_ , vae=UpperCamelCase_ , text_encoder=UpperCamelCase_ , tokenizer=UpperCamelCase_ , safety_checker=UpperCamelCase_ , feature_extractor=self.dummy_extractor , ) UpperCamelCase__ :List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase_ ) UpperCamelCase__ :Optional[int] = alt_pipe.to(UpperCamelCase_ ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :Optional[Any] = 'A painting of a squirrel eating a burger' UpperCamelCase__ :Dict = torch.Generator(device=UpperCamelCase_ ).manual_seed(0 ) UpperCamelCase__ :Any = alt_pipe( [prompt] , generator=UpperCamelCase_ , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , image=UpperCamelCase_ , ) UpperCamelCase__ :Optional[int] = output.images UpperCamelCase__ :Optional[Any] = torch.Generator(device=UpperCamelCase_ ).manual_seed(0 ) UpperCamelCase__ :Optional[Any] = alt_pipe( [prompt] , generator=UpperCamelCase_ , guidance_scale=6.0 , num_inference_steps=2 , output_type='''np''' , image=UpperCamelCase_ , return_dict=UpperCamelCase_ , )[0] UpperCamelCase__ :Optional[int] = image[0, -3:, -3:, -1] UpperCamelCase__ :Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) UpperCamelCase__ :int = np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 5e-3 @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''' ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = self.dummy_cond_unet UpperCamelCase__ :Tuple = PNDMScheduler(skip_prk_steps=UpperCamelCase_ ) UpperCamelCase__ :str = self.dummy_vae UpperCamelCase__ :Optional[Any] = self.dummy_text_encoder UpperCamelCase__ :Optional[Any] = XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''' ) UpperCamelCase__ :Optional[Any] = 77 UpperCamelCase__ :str = self.dummy_image.to(UpperCamelCase_ ) # put models in fp16 UpperCamelCase__ :List[str] = unet.half() UpperCamelCase__ :List[Any] = vae.half() UpperCamelCase__ :Any = bert.half() # make sure here that pndm scheduler skips prk UpperCamelCase__ :Union[str, Any] = AltDiffusionImgaImgPipeline( unet=UpperCamelCase_ , scheduler=UpperCamelCase_ , vae=UpperCamelCase_ , text_encoder=UpperCamelCase_ , tokenizer=UpperCamelCase_ , safety_checker=UpperCamelCase_ , feature_extractor=self.dummy_extractor , ) UpperCamelCase__ :List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase_ ) UpperCamelCase__ :Any = alt_pipe.to(UpperCamelCase_ ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase_ ) UpperCamelCase__ :int = 'A painting of a squirrel eating a burger' UpperCamelCase__ :Optional[Any] = torch.manual_seed(0 ) UpperCamelCase__ :Union[str, Any] = alt_pipe( [prompt] , generator=UpperCamelCase_ , num_inference_steps=2 , output_type='''np''' , image=UpperCamelCase_ , ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''' ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''' ) # resize to resolution that is divisible by 8 but not 16 or 32 UpperCamelCase__ :str = init_image.resize((760, 504) ) UpperCamelCase__ :Optional[int] = 'BAAI/AltDiffusion' UpperCamelCase__ :str = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase_ , safety_checker=UpperCamelCase_ , ) pipe.to(UpperCamelCase_ ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) pipe.enable_attention_slicing() UpperCamelCase__ :List[str] = 'A fantasy landscape, trending on artstation' UpperCamelCase__ :Any = torch.manual_seed(0 ) UpperCamelCase__ :Dict = pipe( prompt=UpperCamelCase_ , image=UpperCamelCase_ , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase_ , output_type='''np''' , ) UpperCamelCase__ :List[str] = output.images[0] UpperCamelCase__ :Tuple = image[255:258, 383:386, -1] assert image.shape == (504, 760, 3) UpperCamelCase__ :Optional[Any] = np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch_gpu class lowercase ( unittest.TestCase ): """simple docstring""" def lowerCAmelCase__ ( self ): '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Union[str, Any] = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/img2img/sketch-mountains-input.jpg''' ) UpperCamelCase__ :str = init_image.resize((768, 512) ) UpperCamelCase__ :Any = load_numpy( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy''' ) UpperCamelCase__ :str = 'BAAI/AltDiffusion' UpperCamelCase__ :Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase_ , safety_checker=UpperCamelCase_ , ) pipe.to(UpperCamelCase_ ) pipe.set_progress_bar_config(disable=UpperCamelCase_ ) pipe.enable_attention_slicing() UpperCamelCase__ :int = 'A fantasy landscape, trending on artstation' UpperCamelCase__ :List[Any] = torch.manual_seed(0 ) UpperCamelCase__ :int = pipe( prompt=UpperCamelCase_ , image=UpperCamelCase_ , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase_ , output_type='''np''' , ) UpperCamelCase__ :Union[str, Any] = output.images[0] assert image.shape == (512, 768, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image ).max() < 1e-2
97
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" from __future__ import annotations def __A (_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ->float: """simple docstring""" lowerCAmelCase__ :Optional[int] = sorted(numsa + numsa ) lowerCAmelCase__ :int = divmod(len(lowerCamelCase_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() __A = [float(x) for x in input("""Enter the elements of first array: """).split()] __A = [float(x) for x in input("""Enter the elements of second array: """).split()] print(F'''The median of two arrays is: {median_of_two_arrays(array_a, array_a)}''')
293
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
"""simple docstring""" from __future__ import annotations from math import ceil, floor, sqrt def lowerCAmelCase_ ( snake_case_ : Optional[Any] = 2_0_0_0_0_0_0 ) ->int: lowerCamelCase__ : list[int] =[0] lowerCamelCase__ : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target lowerCamelCase__ : int =0 # the area corresponding to the grid that gives the product closest to target lowerCamelCase__ : int =0 # an estimate of b, using the quadratic formula lowerCamelCase__ : float # the largest integer less than b_estimate lowerCamelCase__ : int # the largest integer less than b_estimate lowerCamelCase__ : int # the triangle number corresponding to b_floor lowerCamelCase__ : int # the triangle number corresponding to b_ceil lowerCamelCase__ : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): lowerCamelCase__ : Optional[int] =(-1 + sqrt(1 + 8 * target / triangle_a )) / 2 lowerCamelCase__ : List[str] =floor(lowerCamelCase_ ) lowerCamelCase__ : Dict =ceil(lowerCamelCase_ ) lowerCamelCase__ : List[str] =triangle_numbers[b_floor] lowerCamelCase__ : List[str] =triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): lowerCamelCase__ : Union[str, Any] =triangle_b_first_guess * triangle_a lowerCamelCase__ : Union[str, Any] =idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): lowerCamelCase__ : Any =triangle_b_second_guess * triangle_a lowerCamelCase__ : Optional[Any] =idx_a * b_ceil return area if __name__ == "__main__": print(f"""{solution() = }""")
126
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
import shutil import tempfile import unittest from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast from transformers.testing_utils import require_sentencepiece, require_torchaudio from .test_feature_extraction_clap import floats_list @require_torchaudio @require_sentencepiece class SCREAMING_SNAKE_CASE_ ( unittest.TestCase ): def lowerCamelCase_ ( self : List[Any] ): """simple docstring""" UpperCamelCase = 'laion/clap-htsat-unfused' UpperCamelCase = tempfile.mkdtemp() def lowerCamelCase_ ( self : Union[str, Any] , **lowerCamelCase_ : Optional[int] ): """simple docstring""" return RobertaTokenizer.from_pretrained(self.checkpoint , **lowerCamelCase_ ) def lowerCamelCase_ ( self : Any , **lowerCamelCase_ : List[str] ): """simple docstring""" return ClapFeatureExtractor.from_pretrained(self.checkpoint , **lowerCamelCase_ ) def lowerCamelCase_ ( self : str ): """simple docstring""" shutil.rmtree(self.tmpdirname ) def lowerCamelCase_ ( self : int ): """simple docstring""" UpperCamelCase = self.get_tokenizer() UpperCamelCase = self.get_feature_extractor() UpperCamelCase = ClapProcessor(tokenizer=lowerCamelCase_ , feature_extractor=lowerCamelCase_ ) processor.save_pretrained(self.tmpdirname ) UpperCamelCase = ClapProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , lowerCamelCase_ ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor , lowerCamelCase_ ) def lowerCamelCase_ ( self : Optional[int] ): """simple docstring""" UpperCamelCase = ClapProcessor(tokenizer=self.get_tokenizer() , feature_extractor=self.get_feature_extractor() ) processor.save_pretrained(self.tmpdirname ) UpperCamelCase = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) UpperCamelCase = self.get_feature_extractor(do_normalize=lowerCamelCase_ , padding_value=1.0 ) UpperCamelCase = ClapProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=lowerCamelCase_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , lowerCamelCase_ ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.feature_extractor , lowerCamelCase_ ) def lowerCamelCase_ ( self : Dict ): """simple docstring""" UpperCamelCase = self.get_feature_extractor() UpperCamelCase = self.get_tokenizer() UpperCamelCase = ClapProcessor(tokenizer=lowerCamelCase_ , feature_extractor=lowerCamelCase_ ) UpperCamelCase = floats_list((3, 1000) ) UpperCamelCase = feature_extractor(lowerCamelCase_ , return_tensors="""np""" ) UpperCamelCase = processor(audios=lowerCamelCase_ , return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def lowerCamelCase_ ( self : Optional[Any] ): """simple docstring""" UpperCamelCase = self.get_feature_extractor() UpperCamelCase = self.get_tokenizer() UpperCamelCase = ClapProcessor(tokenizer=lowerCamelCase_ , feature_extractor=lowerCamelCase_ ) UpperCamelCase = 'This is a test string' UpperCamelCase = processor(text=lowerCamelCase_ ) UpperCamelCase = tokenizer(lowerCamelCase_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowerCamelCase_ ( self : List[str] ): """simple docstring""" UpperCamelCase = self.get_feature_extractor() UpperCamelCase = self.get_tokenizer() UpperCamelCase = ClapProcessor(tokenizer=lowerCamelCase_ , feature_extractor=lowerCamelCase_ ) UpperCamelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] UpperCamelCase = processor.batch_decode(lowerCamelCase_ ) UpperCamelCase = tokenizer.batch_decode(lowerCamelCase_ ) self.assertListEqual(lowerCamelCase_ , lowerCamelCase_ ) def lowerCamelCase_ ( self : str ): """simple docstring""" UpperCamelCase = self.get_feature_extractor() UpperCamelCase = self.get_tokenizer() UpperCamelCase = ClapProcessor(tokenizer=lowerCamelCase_ , feature_extractor=lowerCamelCase_ ) self.assertListEqual( processor.model_input_names[2:] , feature_extractor.model_input_names , msg="""`processor` and `feature_extractor` model input names do not match""" , )
343
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
from __future__ import annotations def _SCREAMING_SNAKE_CASE ( a ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) __A : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
280
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" from typing import List, Optional from tokenizers import ByteLevelBPETokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot_small import BlenderbotSmallTokenizer _UpperCAmelCase = logging.get_logger(__name__) _UpperCAmelCase = { "vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_config_file": "tokenizer_config.json", } _UpperCAmelCase = { "vocab_file": { "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json" }, "merges_file": { "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt" }, "tokenizer_config_file": { "facebook/blenderbot_small-90M": ( "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json" ) }, } _UpperCAmelCase = { "facebook/blenderbot_small-90M": 5_1_2, } class a ( _a ): UpperCamelCase : Tuple = VOCAB_FILES_NAMES UpperCamelCase : int = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase : Optional[int] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase : List[Any] = BlenderbotSmallTokenizer def __init__( self : List[str] , lowerCAmelCase : List[Any]=None , lowerCAmelCase : Dict=None , lowerCAmelCase : Optional[int]="<|endoftext|>" , lowerCAmelCase : str="<|endoftext|>" , lowerCAmelCase : List[Any]="<|endoftext|>" , lowerCAmelCase : List[str]=False , lowerCAmelCase : List[str]=True , **lowerCAmelCase : Optional[Any] , ) -> Tuple: '''simple docstring''' super().__init__( ByteLevelBPETokenizer( vocab=lowerCAmelCase , merges=lowerCAmelCase , add_prefix_space=lowerCAmelCase , trim_offsets=lowerCAmelCase , ) , bos_token=lowerCAmelCase , eos_token=lowerCAmelCase , unk_token=lowerCAmelCase , **lowerCAmelCase , ) SCREAMING_SNAKE_CASE_: Tuple =add_prefix_space def lowerCamelCase__ ( self : Optional[int] , lowerCAmelCase : List[str] , lowerCAmelCase : int=None ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE_: List[Any] =[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 lowerCamelCase__ ( self : Optional[Any] , lowerCAmelCase : Optional[int] , lowerCAmelCase : List[str] = None ) -> List[int]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Tuple =[self.sep_token_id] SCREAMING_SNAKE_CASE_: Union[str, Any] =[self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
173
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import logging import os import sys from dataclasses import dataclass, field from typing import Optional import torch from datasets import load_dataset from torchvision.transforms import Compose, Lambda, Normalize, RandomHorizontalFlip, RandomResizedCrop, ToTensor from torchvision.transforms.functional import InterpolationMode import transformers from transformers import ( HfArgumentParser, Trainer, TrainingArguments, ViTImageProcessor, ViTMAEConfig, ViTMAEForPreTraining, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version, send_example_telemetry from transformers.utils.versions import require_version _a = logging.getLogger(__name__) # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version("4.31.0") require_version("datasets>=1.8.0", "To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt") @dataclass class __A : '''simple docstring''' lowerCAmelCase_ = field( default="""cifar10""" , metadata={"""help""": """Name of a dataset from the datasets package"""} ) lowerCAmelCase_ = field( default=_a , metadata={"""help""": """The configuration name of the dataset to use (via the datasets library)."""} ) lowerCAmelCase_ = field( default=_a , metadata={"""help""": """The column name of the images in the files."""} ) lowerCAmelCase_ = field(default=_a , metadata={"""help""": """A folder containing the training data."""} ) lowerCAmelCase_ = field(default=_a , metadata={"""help""": """A folder containing the validation data."""} ) lowerCAmelCase_ = field( default=0.1_5 , metadata={"""help""": """Percent to split off of train for validation."""} ) lowerCAmelCase_ = field( default=_a , metadata={ """help""": ( """For debugging purposes or quicker training, truncate the number of training examples to this """ """value if set.""" ) } , ) lowerCAmelCase_ = field( default=_a , metadata={ """help""": ( """For debugging purposes or quicker training, truncate the number of evaluation examples to this """ """value if set.""" ) } , ) def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = {} if self.train_dir is not None: lowerCamelCase__ = self.train_dir if self.validation_dir is not None: lowerCamelCase__ = self.validation_dir lowerCamelCase__ = data_files if data_files else None @dataclass class __A : '''simple docstring''' lowerCAmelCase_ = field( default=_a , metadata={ """help""": ( """The model checkpoint for weights initialization.Don't set if you want to train a model from scratch.""" ) } , ) lowerCAmelCase_ = field( default=_a , metadata={"""help""": """Pretrained config name or path if not the same as model_name_or_path"""} ) lowerCAmelCase_ = field( default=_a , metadata={ """help""": ( """Override some existing default config settings when a model is trained from scratch. Example: """ """n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index""" ) } , ) lowerCAmelCase_ = field( default=_a , metadata={"""help""": """Where do you want to store the pretrained models downloaded from s3"""} ) lowerCAmelCase_ = field( default="""main""" , metadata={"""help""": """The specific model version to use (can be a branch name, tag name or commit id)."""} , ) lowerCAmelCase_ = field(default=_a , metadata={"""help""": """Name or path of preprocessor config."""} ) lowerCAmelCase_ = field( default=_a , metadata={ """help""": ( """Will use the token generated when running `huggingface-cli login` (necessary to use this script """ """with private models).""" ) } , ) lowerCAmelCase_ = field( default=0.7_5 , metadata={"""help""": """The ratio of the number of masked tokens in the input sequence."""} ) lowerCAmelCase_ = field( default=_a , metadata={"""help""": """Whether or not to train with normalized pixel values as target."""} ) @dataclass class __A ( _a ): '''simple docstring''' lowerCAmelCase_ = field( default=1e-3 , metadata={"""help""": """Base learning rate: absolute_lr = base_lr * total_batch_size / 256."""} ) def lowerCAmelCase__(__snake_case ) -> List[str]: '''simple docstring''' lowerCamelCase__ = torch.stack([example['''pixel_values'''] for example in examples] ) return {"pixel_values": pixel_values} def lowerCAmelCase__() -> Dict: '''simple docstring''' lowerCamelCase__ = HfArgumentParser((ModelArguments, DataTrainingArguments, CustomTrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('''.json''' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. lowerCamelCase__ = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: lowerCamelCase__ = parser.parse_args_into_dataclasses() # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The # information sent is the one passed as arguments along with your Python/PyTorch versions. send_example_telemetry('''run_mae''' ,lowerCamelCase_ ,lowerCamelCase_ ) # Setup logging logging.basicConfig( format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''' ,datefmt='''%m/%d/%Y %H:%M:%S''' ,handlers=[logging.StreamHandler(sys.stdout )] ,) if training_args.should_log: # The default of training_args.log_level is passive, so we set log level at info here to have that default. transformers.utils.logging.set_verbosity_info() lowerCamelCase__ = training_args.get_process_log_level() logger.setLevel(lowerCamelCase_ ) transformers.utils.logging.set_verbosity(lowerCamelCase_ ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}' + F'distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}' ) logger.info(F'Training/evaluation parameters {training_args}' ) # Detecting last checkpoint. lowerCamelCase__ = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: lowerCamelCase__ = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( F'Output directory ({training_args.output_dir}) already exists and is not empty. ' '''Use --overwrite_output_dir to overcome.''' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change ' '''the `--output_dir` or add `--overwrite_output_dir` to train from scratch.''' ) # Initialize our dataset. lowerCamelCase__ = load_dataset( data_args.dataset_name ,data_args.dataset_config_name ,data_files=data_args.data_files ,cache_dir=model_args.cache_dir ,use_auth_token=True if model_args.use_auth_token else None ,) # If we don't have a validation split, split off a percentage of train as validation. lowerCamelCase__ = None if 'validation' in ds.keys() else data_args.train_val_split if isinstance(data_args.train_val_split ,lowerCamelCase_ ) and data_args.train_val_split > 0.0: lowerCamelCase__ = ds['train'].train_test_split(data_args.train_val_split ) lowerCamelCase__ = split['train'] lowerCamelCase__ = split['test'] # Load pretrained model and image processor # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. lowerCamelCase__ = { 'cache_dir': model_args.cache_dir, 'revision': model_args.model_revision, 'use_auth_token': True if model_args.use_auth_token else None, } if model_args.config_name: lowerCamelCase__ = ViTMAEConfig.from_pretrained(model_args.config_name ,**lowerCamelCase_ ) elif model_args.model_name_or_path: lowerCamelCase__ = ViTMAEConfig.from_pretrained(model_args.model_name_or_path ,**lowerCamelCase_ ) else: lowerCamelCase__ = ViTMAEConfig() logger.warning('''You are instantiating a new config instance from scratch.''' ) if model_args.config_overrides is not None: logger.info(F'Overriding config: {model_args.config_overrides}' ) config.update_from_string(model_args.config_overrides ) logger.info(F'New config: {config}' ) # adapt config config.update( { '''mask_ratio''': model_args.mask_ratio, '''norm_pix_loss''': model_args.norm_pix_loss, } ) # create image processor if model_args.image_processor_name: lowerCamelCase__ = ViTImageProcessor.from_pretrained(model_args.image_processor_name ,**lowerCamelCase_ ) elif model_args.model_name_or_path: lowerCamelCase__ = ViTImageProcessor.from_pretrained(model_args.model_name_or_path ,**lowerCamelCase_ ) else: lowerCamelCase__ = ViTImageProcessor() # create model if model_args.model_name_or_path: lowerCamelCase__ = ViTMAEForPreTraining.from_pretrained( model_args.model_name_or_path ,from_tf=bool('''.ckpt''' in model_args.model_name_or_path ) ,config=lowerCamelCase_ ,cache_dir=model_args.cache_dir ,revision=model_args.model_revision ,use_auth_token=True if model_args.use_auth_token else None ,) else: logger.info('''Training new model from scratch''' ) lowerCamelCase__ = ViTMAEForPreTraining(lowerCamelCase_ ) if training_args.do_train: lowerCamelCase__ = ds['train'].column_names else: lowerCamelCase__ = ds['validation'].column_names if data_args.image_column_name is not None: lowerCamelCase__ = data_args.image_column_name elif "image" in column_names: lowerCamelCase__ = 'image' elif "img" in column_names: lowerCamelCase__ = 'img' else: lowerCamelCase__ = column_names[0] # transformations as done in original MAE paper # source: https://github.com/facebookresearch/mae/blob/main/main_pretrain.py if "shortest_edge" in image_processor.size: lowerCamelCase__ = image_processor.size['shortest_edge'] else: lowerCamelCase__ = (image_processor.size['height'], image_processor.size['width']) lowerCamelCase__ = Compose( [ Lambda(lambda __snake_case : img.convert('''RGB''' ) if img.mode != "RGB" else img ), RandomResizedCrop(lowerCamelCase_ ,scale=(0.2, 1.0) ,interpolation=InterpolationMode.BICUBIC ), RandomHorizontalFlip(), ToTensor(), Normalize(mean=image_processor.image_mean ,std=image_processor.image_std ), ] ) def preprocess_images(__snake_case ): lowerCamelCase__ = [transforms(lowerCamelCase_ ) for image in examples[image_column_name]] return examples if training_args.do_train: if "train" not in ds: raise ValueError('''--do_train requires a train dataset''' ) if data_args.max_train_samples is not None: lowerCamelCase__ = ds['train'].shuffle(seed=training_args.seed ).select(range(data_args.max_train_samples ) ) # Set the training transforms ds["train"].set_transform(lowerCamelCase_ ) if training_args.do_eval: if "validation" not in ds: raise ValueError('''--do_eval requires a validation dataset''' ) if data_args.max_eval_samples is not None: lowerCamelCase__ = ( ds['validation'].shuffle(seed=training_args.seed ).select(range(data_args.max_eval_samples ) ) ) # Set the validation transforms ds["validation"].set_transform(lowerCamelCase_ ) # Compute absolute learning rate lowerCamelCase__ = ( training_args.train_batch_size * training_args.gradient_accumulation_steps * training_args.world_size ) if training_args.base_learning_rate is not None: lowerCamelCase__ = training_args.base_learning_rate * total_train_batch_size / 256 # Initialize our trainer lowerCamelCase__ = Trainer( model=lowerCamelCase_ ,args=lowerCamelCase_ ,train_dataset=ds['''train'''] if training_args.do_train else None ,eval_dataset=ds['''validation'''] if training_args.do_eval else None ,tokenizer=lowerCamelCase_ ,data_collator=lowerCamelCase_ ,) # Training if training_args.do_train: lowerCamelCase__ = None if training_args.resume_from_checkpoint is not None: lowerCamelCase__ = training_args.resume_from_checkpoint elif last_checkpoint is not None: lowerCamelCase__ = last_checkpoint lowerCamelCase__ = trainer.train(resume_from_checkpoint=lowerCamelCase_ ) trainer.save_model() trainer.log_metrics('''train''' ,train_result.metrics ) trainer.save_metrics('''train''' ,train_result.metrics ) trainer.save_state() # Evaluation if training_args.do_eval: lowerCamelCase__ = trainer.evaluate() trainer.log_metrics('''eval''' ,lowerCamelCase_ ) trainer.save_metrics('''eval''' ,lowerCamelCase_ ) # Write model card and (optionally) push to hub lowerCamelCase__ = { 'tasks': 'masked-auto-encoding', 'dataset': data_args.dataset_name, 'tags': ['masked-auto-encoding'], } if training_args.push_to_hub: trainer.push_to_hub(**lowerCamelCase_ ) else: trainer.create_model_card(**lowerCamelCase_ ) def lowerCAmelCase__(__snake_case ) -> Tuple: '''simple docstring''' main() if __name__ == "__main__": main()
209
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
import torch from diffusers import StableDiffusionPipeline __UpperCAmelCase = "path-to-your-trained-model" __UpperCAmelCase = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to('cuda') __UpperCAmelCase = "A photo of sks dog in a bucket" __UpperCAmelCase = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0] image.save('dog-bucket.png')
29
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
import random import unittest from torch.utils.data import BatchSampler, DataLoader, IterableDataset from accelerate import Accelerator from accelerate.data_loader import ( BatchSamplerShard, DataLoaderDispatcher, DataLoaderShard, IterableDatasetShard, SkipBatchSampler, SkipDataLoader, skip_first_batches, ) class A__ ( _a ): def __init__( self : int , a : List[str]=0.0_1 , a : int=1_000 ): '''simple docstring''' lowerCAmelCase__ : List[str] = p_stop lowerCAmelCase__ : Tuple = max_length def __iter__( self : List[Any] ): '''simple docstring''' lowerCAmelCase__ : List[Any] = 0 lowerCAmelCase__ : Union[str, Any] = False while not stop and count < self.max_length: yield count count += 1 lowerCAmelCase__ : int = random.random() < self.p_stop class A__ ( unittest.TestCase ): def _lowerCamelCase ( self : Optional[int] , a : str , a : Dict , a : Dict=False , a : List[Any]=True ): '''simple docstring''' lowerCAmelCase__ : Dict = [ BatchSamplerShard(a , 2 , a , split_batches=a , even_batches=a ) for i in range(2 ) ] lowerCAmelCase__ : str = [list(a ) for batch_sampler_shard in batch_sampler_shards] if not split_batches: self.assertListEqual([len(a ) for shard in batch_sampler_shards] , [len(a ) for e in expected] ) self.assertListEqual(a , a ) def _lowerCamelCase ( self : int ): '''simple docstring''' lowerCAmelCase__ : List[str] = BatchSampler(range(24 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]], ] self.check_batch_sampler_shards(a , a ) lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(24 ) , batch_size=3 , drop_last=a ) # Expected shouldn't change self.check_batch_sampler_shards(a , a ) # Check the shards when the dataset is a round multiple of batch size but not total batch size. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(21 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : List[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]], ] self.check_batch_sampler_shards(a , a ) lowerCAmelCase__ : Dict = BatchSampler(range(21 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a ) # Check the shards when the dataset is not a round multiple of batch size but has a multiple of # num_processes batch. lowerCAmelCase__ : Any = BatchSampler(range(22 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : List[Any] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]], ] self.check_batch_sampler_shards(a , a ) lowerCAmelCase__ : List[str] = BatchSampler(range(22 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a ) # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of # num_processes batch. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(20 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Dict = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]], ] self.check_batch_sampler_shards(a , a ) lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(20 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Tuple = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a ) # Check the shards when the dataset is very small. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(2 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Dict = [[[0, 1, 0]], [[1, 0, 1]]] self.check_batch_sampler_shards(a , a ) lowerCAmelCase__ : List[str] = BatchSampler(range(2 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Dict = [[], []] self.check_batch_sampler_shards(a , a ) def _lowerCamelCase ( self : Union[str, Any] ): '''simple docstring''' lowerCAmelCase__ : str = BatchSampler(range(24 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Optional[Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]], ] self.check_batch_sampler_shards(a , a , split_batches=a ) lowerCAmelCase__ : List[str] = BatchSampler(range(24 ) , batch_size=4 , drop_last=a ) # Expected shouldn't change self.check_batch_sampler_shards(a , a , split_batches=a ) # Check the shards when the dataset is not a round multiple of batch size. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(22 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : List[Any] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]], ] self.check_batch_sampler_shards(a , a , split_batches=a ) lowerCAmelCase__ : Optional[Any] = BatchSampler(range(22 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Dict = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a ) # Check the shards when the dataset is not a round multiple of batch size or num_processes. lowerCAmelCase__ : Any = BatchSampler(range(21 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]], ] self.check_batch_sampler_shards(a , a , split_batches=a ) lowerCAmelCase__ : Tuple = BatchSampler(range(21 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a ) # Check the shards when the dataset is very small. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(2 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : int = [[[0, 1]], [[0, 1]]] self.check_batch_sampler_shards(a , a , split_batches=a ) lowerCAmelCase__ : Dict = BatchSampler(range(2 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Dict = [[], []] self.check_batch_sampler_shards(a , a , split_batches=a ) def _lowerCamelCase ( self : List[str] ): '''simple docstring''' lowerCAmelCase__ : List[str] = BatchSampler(range(24 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) lowerCAmelCase__ : Any = BatchSampler(range(24 ) , batch_size=3 , drop_last=a ) # Expected shouldn't change self.check_batch_sampler_shards(a , a , even_batches=a ) # Check the shards when the dataset is a round multiple of batch size but not total batch size. lowerCAmelCase__ : Any = BatchSampler(range(21 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : List[str] = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) lowerCAmelCase__ : Optional[Any] = BatchSampler(range(21 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Tuple = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) # Check the shards when the dataset is not a round multiple of batch size but has a multiple of # num_processes batch. lowerCAmelCase__ : str = BatchSampler(range(22 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : str = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]], [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) lowerCAmelCase__ : str = BatchSampler(range(22 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of # num_processes batch. lowerCAmelCase__ : List[Any] = BatchSampler(range(20 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : str = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) lowerCAmelCase__ : Dict = BatchSampler(range(20 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [ [[0, 1, 2], [6, 7, 8], [12, 13, 14]], [[3, 4, 5], [9, 10, 11], [15, 16, 17]], ] self.check_batch_sampler_shards(a , a , even_batches=a ) # Check the shards when the dataset is very small. lowerCAmelCase__ : Union[str, Any] = BatchSampler(range(2 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : int = [[[0, 1]], []] self.check_batch_sampler_shards(a , a , even_batches=a ) lowerCAmelCase__ : Dict = BatchSampler(range(2 ) , batch_size=3 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [[], []] self.check_batch_sampler_shards(a , a , even_batches=a ) def _lowerCamelCase ( self : Union[str, Any] ): '''simple docstring''' lowerCAmelCase__ : str = BatchSampler(range(24 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Any = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]], ] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) lowerCAmelCase__ : Optional[Any] = BatchSampler(range(24 ) , batch_size=4 , drop_last=a ) # Expected shouldn't change self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) # Check the shards when the dataset is not a round multiple of batch size. lowerCAmelCase__ : int = BatchSampler(range(22 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : str = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) lowerCAmelCase__ : List[str] = BatchSampler(range(22 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : str = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) # Check the shards when the dataset is not a round multiple of batch size or num_processes. lowerCAmelCase__ : List[str] = BatchSampler(range(21 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) lowerCAmelCase__ : Any = BatchSampler(range(21 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [ [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]], [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]], ] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) # Check the shards when the dataset is very small. lowerCAmelCase__ : Any = BatchSampler(range(2 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : int = [[[0, 1]], []] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) lowerCAmelCase__ : str = BatchSampler(range(2 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : Optional[int] = [[], []] self.check_batch_sampler_shards(a , a , split_batches=a , even_batches=a ) def _lowerCamelCase ( self : Optional[Any] ): '''simple docstring''' lowerCAmelCase__ : Union[str, Any] = [[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]] lowerCAmelCase__ : List[str] = [BatchSamplerShard(a , 2 , a , even_batches=a ) for i in range(2 )] self.assertEqual(len(batch_sampler_shards[0] ) , 3 ) self.assertEqual(len(batch_sampler_shards[1] ) , 2 ) self.assertListEqual(list(batch_sampler_shards[0] ) , [[0, 1, 2], [5, 6, 7, 8], [12, 13]] ) self.assertListEqual(list(batch_sampler_shards[1] ) , [[3, 4], [9, 10, 11]] ) def _lowerCamelCase ( self : Any , a : Union[str, Any] , a : str , a : List[str] , a : Optional[Any]=False , a : List[Any]=2 , a : str=False ): '''simple docstring''' random.seed(a ) lowerCAmelCase__ : List[str] = list(a ) lowerCAmelCase__ : Optional[int] = [ IterableDatasetShard( a , batch_size=a , drop_last=a , num_processes=a , process_index=a , split_batches=a , ) for i in range(a ) ] lowerCAmelCase__ : Dict = [] for iterable_dataset_shard in iterable_dataset_shards: # Since our random iterable dataset will be... random... we need to use a seed to get reproducible results. random.seed(a ) iterable_dataset_lists.append(list(a ) ) lowerCAmelCase__ : Tuple = batch_size // num_processes if split_batches else batch_size # All iterable dataset shard should have the same length, a round multiple of shard_batch_size lowerCAmelCase__ : str = iterable_dataset_lists[0] for l in iterable_dataset_lists[1:]: self.assertEqual(len(a ) , len(a ) ) self.assertTrue(len(a ) % shard_batch_size == 0 ) lowerCAmelCase__ : Tuple = [] for idx in range(0 , len(a ) , a ): for l in iterable_dataset_lists: observed += l[idx : idx + shard_batch_size] if not drop_last: while len(a ) < len(a ): reference += reference self.assertListEqual(a , reference[: len(a )] ) def _lowerCamelCase ( self : Tuple ): '''simple docstring''' lowerCAmelCase__ : List[Any] = 42 lowerCAmelCase__ : int = RandomIterableDataset() self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) # Edge case with a very small dataset lowerCAmelCase__ : Union[str, Any] = RandomIterableDataset(max_length=2 ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) self.check_iterable_dataset_shards(a , a , batch_size=4 , drop_last=a , split_batches=a ) def _lowerCamelCase ( self : Optional[int] ): '''simple docstring''' lowerCAmelCase__ : List[Any] = BatchSampler(range(16 ) , batch_size=4 , drop_last=a ) lowerCAmelCase__ : str = SkipBatchSampler(a , 2 ) self.assertListEqual(list(a ) , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowerCamelCase ( self : Tuple ): '''simple docstring''' lowerCAmelCase__ : Union[str, Any] = SkipDataLoader(list(range(16 ) ) , batch_size=4 , skip_batches=2 ) self.assertListEqual([t.tolist() for t in dataloader] , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowerCamelCase ( self : int ): '''simple docstring''' lowerCAmelCase__ : Optional[Any] = DataLoader(list(range(16 ) ) , batch_size=4 ) lowerCAmelCase__ : Optional[int] = skip_first_batches(a , num_batches=2 ) self.assertListEqual([t.tolist() for t in new_dataloader] , [[8, 9, 10, 11], [12, 13, 14, 15]] ) def _lowerCamelCase ( self : Union[str, Any] ): '''simple docstring''' lowerCAmelCase__ : Optional[Any] = DataLoaderShard(list(range(16 ) ) , batch_size=4 ) for idx, _ in enumerate(a ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) # Test it also works on the second iteration for idx, _ in enumerate(a ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) def _lowerCamelCase ( self : List[Any] ): '''simple docstring''' Accelerator() lowerCAmelCase__ : Optional[Any] = DataLoaderDispatcher(range(16 ) , batch_size=4 ) for idx, _ in enumerate(a ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 ) # Test it also works on the second iteration for idx, _ in enumerate(a ): self.assertEqual(dataloader.end_of_dataloader , idx == 3 )
212
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
0
from math import loga def lowerCAmelCase__ ( a__: Optional[int] ) -> int: '''simple docstring''' if a < 0: raise ValueError('Input value must be a positive integer' ) elif isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise TypeError('Input value must be a \'int\' type' ) return 0 if (a == 0) else int(loga(a & -a ) ) if __name__ == "__main__": import doctest doctest.testmod()
329
import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" return MobileViTVaConfig( image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_act=self.hidden_act, conv_kernel_size=self.conv_kernel_size, output_stride=self.output_stride, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, width_multiplier=self.width_multiplier, ffn_dropout=self.ffn_dropout_prob, attn_dropout=self.attn_dropout_prob, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): self.assertListEqual( list(hidden_states[i].shape[-2:]), [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor], ) divisor *= 2 self.assertEqual(self.model_tester.output_stride, divisor // 2) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor( [ [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]], [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]], [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]], ], device=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
0
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def lowerCamelCase__ ( _A ): '''simple docstring''' snake_case_ = int(number**0.5 ) return number == sq * sq def lowerCamelCase__ ( _A , _A , _A , _A , _A , _A ): '''simple docstring''' snake_case_ = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den snake_case_ = x_den * y_den * z_den snake_case_ = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def lowerCamelCase__ ( _A = 35 ): '''simple docstring''' snake_case_ = set() snake_case_ = 42 snake_case_ = Fraction(0 ) snake_case_ = 42 for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 snake_case_ = x_num * y_den + x_den * y_num snake_case_ = x_den * y_den snake_case_ = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: snake_case_ = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 snake_case_ = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) snake_case_ = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): snake_case_ = int(sqrt(lowerCamelCase_ ) ) snake_case_ = int(sqrt(lowerCamelCase_ ) ) snake_case_ = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: snake_case_ = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 snake_case_ = x_num * y_num snake_case_ = x_den * y_num + x_num * y_den snake_case_ = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: snake_case_ = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 snake_case_ = x_num * x_num * y_num * y_num snake_case_ = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): snake_case_ = int(sqrt(lowerCamelCase_ ) ) snake_case_ = int(sqrt(lowerCamelCase_ ) ) snake_case_ = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: snake_case_ = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(f'''{solution() = }''')
187
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
0
'''simple docstring''' class lowercase : """simple docstring""" def __init__( self , UpperCamelCase_ ): '''simple docstring''' UpperCamelCase__ :Any = set_counts UpperCamelCase__ :List[Any] = max(UpperCamelCase_ ) UpperCamelCase__ :Dict = len(UpperCamelCase_ ) UpperCamelCase__ :Dict = [1] * num_sets UpperCamelCase__ :Optional[int] = list(range(UpperCamelCase_ ) ) def lowerCAmelCase__ ( self , UpperCamelCase_ , UpperCamelCase_ ): '''simple docstring''' UpperCamelCase__ :List[Any] = self.get_parent(UpperCamelCase_ ) UpperCamelCase__ :int = self.get_parent(UpperCamelCase_ ) if src_parent == dst_parent: return False if self.ranks[dst_parent] >= self.ranks[src_parent]: self.set_counts[dst_parent] += self.set_counts[src_parent] UpperCamelCase__ :Dict = 0 UpperCamelCase__ :List[str] = dst_parent if self.ranks[dst_parent] == self.ranks[src_parent]: self.ranks[dst_parent] += 1 UpperCamelCase__ :str = self.set_counts[dst_parent] else: self.set_counts[src_parent] += self.set_counts[dst_parent] UpperCamelCase__ :int = 0 UpperCamelCase__ :str = src_parent UpperCamelCase__ :List[Any] = self.set_counts[src_parent] UpperCamelCase__ :str = max(self.max_set , UpperCamelCase_ ) return True def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' if self.parents[disj_set] == disj_set: return disj_set UpperCamelCase__ :Union[str, Any] = self.get_parent(self.parents[disj_set] ) return self.parents[disj_set]
97
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
0
"""simple docstring""" import itertools import json import os import unittest from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _lowerCAmelCase ( _a , unittest.TestCase ): """simple docstring""" __magic_name__ :List[str] = RobertaTokenizer __magic_name__ :Any = RobertaTokenizerFast __magic_name__ :Dict = True __magic_name__ :List[Any] = {"""cls_token""": """<s>"""} def snake_case ( self ): '''simple docstring''' super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt lowerCAmelCase__ :Any = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', '\u0120', '\u0120l', '\u0120n', '\u0120lo', '\u0120low', 'er', '\u0120lowest', '\u0120newer', '\u0120wider', '<unk>', ] lowerCAmelCase__ :List[Any] = dict(zip(__UpperCAmelCase , range(len(__UpperCAmelCase ) ) ) ) lowerCAmelCase__ :List[str] = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', ''] lowerCAmelCase__ :Union[str, Any] = {'unk_token': '<unk>'} lowerCAmelCase__ :Union[str, Any] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) lowerCAmelCase__ :Union[str, Any] = 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(__UpperCAmelCase ) + '\n' ) with open(self.merges_file , 'w' , encoding='utf-8' ) as fp: fp.write('\n'.join(__UpperCAmelCase ) ) def snake_case ( self , **__UpperCAmelCase ): '''simple docstring''' kwargs.update(self.special_tokens_map ) return self.tokenizer_class.from_pretrained(self.tmpdirname , **__UpperCAmelCase ) def snake_case ( self , **__UpperCAmelCase ): '''simple docstring''' kwargs.update(self.special_tokens_map ) return RobertaTokenizerFast.from_pretrained(self.tmpdirname , **__UpperCAmelCase ) def snake_case ( self , __UpperCAmelCase ): '''simple docstring''' lowerCAmelCase__ :int = 'lower newer' lowerCAmelCase__ :List[str] = 'lower newer' return input_text, output_text def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Optional[int] = self.tokenizer_class(self.vocab_file , self.merges_file , **self.special_tokens_map ) lowerCAmelCase__ :Any = 'lower newer' lowerCAmelCase__ :Tuple = ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er'] lowerCAmelCase__ :Dict = tokenizer.tokenize(__UpperCAmelCase ) # , add_prefix_space=True) self.assertListEqual(__UpperCAmelCase , __UpperCAmelCase ) lowerCAmelCase__ :List[str] = tokens + [tokenizer.unk_token] lowerCAmelCase__ :Any = [0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9] self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCAmelCase ) , __UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Any = self.get_tokenizer() self.assertListEqual(tokenizer.encode('Hello world!' , add_special_tokens=__UpperCAmelCase ) , [0, 3_1_4_1_4, 2_3_2, 3_2_8, 2] ) self.assertListEqual( tokenizer.encode('Hello world! cécé herlolip 418' , add_special_tokens=__UpperCAmelCase ) , [0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2] , ) @slow def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Any = self.tokenizer_class.from_pretrained('roberta-base' ) lowerCAmelCase__ :Optional[int] = tokenizer.encode('sequence builders' , add_special_tokens=__UpperCAmelCase ) lowerCAmelCase__ :int = tokenizer.encode('multi-sequence build' , add_special_tokens=__UpperCAmelCase ) lowerCAmelCase__ :Optional[Any] = tokenizer.encode( 'sequence builders' , add_special_tokens=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase ) lowerCAmelCase__ :int = tokenizer.encode( 'sequence builders' , 'multi-sequence build' , add_special_tokens=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase ) lowerCAmelCase__ :Union[str, Any] = tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase ) lowerCAmelCase__ :str = tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase , __UpperCAmelCase ) assert encoded_sentence == encoded_text_from_decode assert encoded_pair == encoded_pair_from_decode def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Any = self.get_tokenizer() lowerCAmelCase__ :Any = 'Encode this sequence.' lowerCAmelCase__ :int = tokenizer.byte_encoder[' '.encode('utf-8' )[0]] # Testing encoder arguments lowerCAmelCase__ :Optional[int] = tokenizer.encode(__UpperCAmelCase , add_special_tokens=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase ) lowerCAmelCase__ :Tuple = tokenizer.convert_ids_to_tokens(encoded[0] )[0] self.assertNotEqual(__UpperCAmelCase , __UpperCAmelCase ) lowerCAmelCase__ :Union[str, Any] = tokenizer.encode(__UpperCAmelCase , add_special_tokens=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase ) lowerCAmelCase__ :Dict = tokenizer.convert_ids_to_tokens(encoded[0] )[0] self.assertEqual(__UpperCAmelCase , __UpperCAmelCase ) tokenizer.add_special_tokens({'bos_token': '<s>'} ) lowerCAmelCase__ :Dict = tokenizer.encode(__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) lowerCAmelCase__ :Union[str, Any] = tokenizer.convert_ids_to_tokens(encoded[1] )[0] self.assertNotEqual(__UpperCAmelCase , __UpperCAmelCase ) # Testing spaces after special tokens lowerCAmelCase__ :int = '<mask>' tokenizer.add_special_tokens( {'mask_token': AddedToken(__UpperCAmelCase , lstrip=__UpperCAmelCase , rstrip=__UpperCAmelCase )} ) # mask token has a left space lowerCAmelCase__ :Dict = tokenizer.convert_tokens_to_ids(__UpperCAmelCase ) lowerCAmelCase__ :str = 'Encode <mask> sequence' lowerCAmelCase__ :List[Any] = 'Encode <mask>sequence' lowerCAmelCase__ :Optional[Any] = tokenizer.encode(__UpperCAmelCase ) lowerCAmelCase__ :Tuple = encoded.index(__UpperCAmelCase ) lowerCAmelCase__ :Optional[int] = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1] )[0] self.assertEqual(__UpperCAmelCase , __UpperCAmelCase ) lowerCAmelCase__ :Tuple = tokenizer.encode(__UpperCAmelCase ) lowerCAmelCase__ :List[Any] = encoded.index(__UpperCAmelCase ) lowerCAmelCase__ :Optional[int] = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1] )[0] self.assertNotEqual(__UpperCAmelCase , __UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' pass def snake_case ( self ): '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowerCAmelCase__ :Dict = self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase , **__UpperCAmelCase ) lowerCAmelCase__ :List[str] = self.tokenizer_class.from_pretrained(__UpperCAmelCase , **__UpperCAmelCase ) lowerCAmelCase__ :Optional[int] = 'A, <mask> AllenNLP sentence.' lowerCAmelCase__ :str = tokenizer_r.encode_plus(__UpperCAmelCase , add_special_tokens=__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase ) lowerCAmelCase__ :List[str] = tokenizer_p.encode_plus(__UpperCAmelCase , add_special_tokens=__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase ) # token_type_ids should put 0 everywhere self.assertEqual(sum(tokens_r['token_type_ids'] ) , sum(tokens_p['token_type_ids'] ) ) # attention_mask should put 1 everywhere, so sum over length should be 1 self.assertEqual( sum(tokens_r['attention_mask'] ) / len(tokens_r['attention_mask'] ) , sum(tokens_p['attention_mask'] ) / len(tokens_p['attention_mask'] ) , ) lowerCAmelCase__ :List[str] = tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids'] ) lowerCAmelCase__ :List[str] = tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids'] ) # Rust correctly handles the space before the mask while python doesnt self.assertSequenceEqual(tokens_p['input_ids'] , [0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2] ) self.assertSequenceEqual(tokens_r['input_ids'] , [0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2] ) self.assertSequenceEqual( __UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] ) self.assertSequenceEqual( __UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] ) def snake_case ( self ): '''simple docstring''' for trim_offsets, add_prefix_space in itertools.product([True, False] , repeat=2 ): lowerCAmelCase__ :str = self.rust_tokenizer_class.from_pretrained( self.tmpdirname , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :int = json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__() ) lowerCAmelCase__ :Tuple = json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__() ) self.assertEqual(pre_tokenizer_state['add_prefix_space'] , __UpperCAmelCase ) self.assertEqual(post_processor_state['add_prefix_space'] , __UpperCAmelCase ) self.assertEqual(post_processor_state['trim_offsets'] , __UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowerCAmelCase__ :Optional[int] = 'hello' # `hello` is a token in the vocabulary of `pretrained_name` lowerCAmelCase__ :List[Any] = F"{text_of_1_token} {text_of_1_token}" lowerCAmelCase__ :Tuple = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :Optional[Any] = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(__UpperCAmelCase ) + 1, len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :Optional[Any] = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :Dict = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(__UpperCAmelCase ) + 1, len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :List[str] = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :int = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(__UpperCAmelCase ), len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :Dict = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :int = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(__UpperCAmelCase ), len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :Any = F" {text}" # tokenizer_r = self.rust_tokenizer_class.from_pretrained( # pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True # ) # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False) # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token))) # self.assertEqual( # encoding.offset_mapping[1], # (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)), # ) lowerCAmelCase__ :List[Any] = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :Any = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (1, 1 + len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(__UpperCAmelCase ) + 1, 1 + len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :List[str] = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :Tuple = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(__UpperCAmelCase ), 1 + len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , ) lowerCAmelCase__ :Union[str, Any] = self.rust_tokenizer_class.from_pretrained( __UpperCAmelCase , use_fast=__UpperCAmelCase , add_prefix_space=__UpperCAmelCase , trim_offsets=__UpperCAmelCase ) lowerCAmelCase__ :List[Any] = tokenizer_r(__UpperCAmelCase , return_offsets_mapping=__UpperCAmelCase , add_special_tokens=__UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(__UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(__UpperCAmelCase ), 1 + len(__UpperCAmelCase ) + 1 + len(__UpperCAmelCase )) , )
293
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
0
"""simple docstring""" import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.layers import LSTM, Dense from tensorflow.keras.models import Sequential if __name__ == "__main__": lowerCAmelCase = pd.read_csv("""sample_data.csv""", header=None) lowerCAmelCase = df.shape[:1][0] # If you're using some other dataset input the target column lowerCAmelCase = df.iloc[:, 1:2] lowerCAmelCase = actual_data.values.reshape(len_data, 1) lowerCAmelCase = MinMaxScaler().fit_transform(actual_data) lowerCAmelCase = 10 lowerCAmelCase = 5 lowerCAmelCase = 20 lowerCAmelCase = len_data - periods * look_back lowerCAmelCase = actual_data[:division] lowerCAmelCase = actual_data[division - look_back :] lowerCAmelCase = [], [] lowerCAmelCase = [], [] for i in range(0, len(train_data) - forward_days - look_back + 1): train_x.append(train_data[i : i + look_back]) train_y.append(train_data[i + look_back : i + look_back + forward_days]) for i in range(0, len(test_data) - forward_days - look_back + 1): test_x.append(test_data[i : i + look_back]) test_y.append(test_data[i + look_back : i + look_back + forward_days]) lowerCAmelCase = np.array(train_x) lowerCAmelCase = np.array(test_x) lowerCAmelCase = np.array([list(i.ravel()) for i in train_y]) lowerCAmelCase = np.array([list(i.ravel()) for i in test_y]) lowerCAmelCase = Sequential() model.add(LSTM(1_28, input_shape=(look_back, 1), return_sequences=True)) model.add(LSTM(64, input_shape=(1_28, 1))) model.add(Dense(forward_days)) model.compile(loss="""mean_squared_error""", optimizer="""adam""") lowerCAmelCase = model.fit( x_train, y_train, epochs=1_50, verbose=1, shuffle=True, batch_size=4 ) lowerCAmelCase = model.predict(x_test)
126
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
0
import argparse import torch from transformers import BertForMaskedLM if __name__ == "__main__": _SCREAMING_SNAKE_CASE = argparse.ArgumentParser( description=( """Extraction some layers of the full BertForMaskedLM or RObertaForMaskedLM for Transfer Learned""" """ Distillation""" ) ) parser.add_argument("""--model_type""", default="""bert""", choices=["""bert"""]) parser.add_argument("""--model_name""", default="""bert-base-uncased""", type=str) parser.add_argument("""--dump_checkpoint""", default="""serialization_dir/tf_bert-base-uncased_0247911.pth""", type=str) parser.add_argument("""--vocab_transform""", action="""store_true""") _SCREAMING_SNAKE_CASE = parser.parse_args() if args.model_type == "bert": _SCREAMING_SNAKE_CASE = BertForMaskedLM.from_pretrained(args.model_name) _SCREAMING_SNAKE_CASE = "bert" else: raise ValueError("""args.model_type should be \"bert\".""") _SCREAMING_SNAKE_CASE = model.state_dict() _SCREAMING_SNAKE_CASE = {} for w in ["word_embeddings", "position_embeddings"]: _SCREAMING_SNAKE_CASE = state_dict[F'''{prefix}.embeddings.{w}.weight'''] for w in ["weight", "bias"]: _SCREAMING_SNAKE_CASE = state_dict[F'''{prefix}.embeddings.LayerNorm.{w}'''] _SCREAMING_SNAKE_CASE = 0 for teacher_idx in [0, 2, 4, 7, 9, 1_1]: for w in ["weight", "bias"]: _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.attention.self.query.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.attention.self.key.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.attention.self.value.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.attention.output.dense.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.attention.output.LayerNorm.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.intermediate.dense.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.output.dense.{w}''' ] _SCREAMING_SNAKE_CASE = state_dict[ F'''{prefix}.encoder.layer.{teacher_idx}.output.LayerNorm.{w}''' ] std_idx += 1 _SCREAMING_SNAKE_CASE = state_dict["cls.predictions.decoder.weight"] _SCREAMING_SNAKE_CASE = state_dict["cls.predictions.bias"] if args.vocab_transform: for w in ["weight", "bias"]: _SCREAMING_SNAKE_CASE = state_dict[F'''cls.predictions.transform.dense.{w}'''] _SCREAMING_SNAKE_CASE = state_dict[F'''cls.predictions.transform.LayerNorm.{w}'''] print(F'''N layers selected for distillation: {std_idx}''') print(F'''Number of params transferred for distillation: {len(compressed_sd.keys())}''') print(F'''Save transferred checkpoint to {args.dump_checkpoint}.''') torch.save(compressed_sd, args.dump_checkpoint)
343
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
0
import random from typing import Any def _SCREAMING_SNAKE_CASE ( a ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): __A : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) __A : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) __A : Optional[int] = data[b], data[a] return data if __name__ == "__main__": UpperCAmelCase : str = [0, 1, 2, 3, 4, 5, 6, 7] UpperCAmelCase : int = ["python", "says", "hello", "!"] print('''Fisher-Yates Shuffle:''') print('''List''', integers, strings) print('''FY Shuffle''', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
280
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
0
"""simple docstring""" import argparse import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## _UpperCAmelCase = 1_6 _UpperCAmelCase = 3_2 def __magic_name__ ( lowercase , lowercase = 16 ): SCREAMING_SNAKE_CASE_: Optional[Any] =AutoTokenizer.from_pretrained("""bert-base-cased""" ) SCREAMING_SNAKE_CASE_: Any =load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase ): # max_length=None => use the model max length (it's actually the default) SCREAMING_SNAKE_CASE_: Any =tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowerCamelCase_ , max_length=lowerCamelCase_ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): SCREAMING_SNAKE_CASE_: Union[str, Any] =datasets.map( lowerCamelCase_ , batched=lowerCamelCase_ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library SCREAMING_SNAKE_CASE_: Tuple =tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase ): # On TPU it's best to pad everything to the same length or training will be very slow. SCREAMING_SNAKE_CASE_: str =128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": SCREAMING_SNAKE_CASE_: Union[str, Any] =16 elif accelerator.mixed_precision != "no": SCREAMING_SNAKE_CASE_: Any =8 else: SCREAMING_SNAKE_CASE_: List[Any] =None return tokenizer.pad( lowerCamelCase_ , padding="""longest""" , max_length=lowerCamelCase_ , pad_to_multiple_of=lowerCamelCase_ , return_tensors="""pt""" , ) # Instantiate dataloaders. SCREAMING_SNAKE_CASE_: str =DataLoader( tokenized_datasets["""train"""] , shuffle=lowerCamelCase_ , collate_fn=lowerCamelCase_ , batch_size=lowerCamelCase_ , drop_last=lowerCamelCase_ ) SCREAMING_SNAKE_CASE_: str =DataLoader( tokenized_datasets["""validation"""] , shuffle=lowerCamelCase_ , collate_fn=lowerCamelCase_ , batch_size=lowerCamelCase_ , drop_last=(accelerator.mixed_precision == """fp8""") , ) return train_dataloader, eval_dataloader def __magic_name__ ( lowercase , lowercase ): # Initialize accelerator SCREAMING_SNAKE_CASE_: Union[str, Any] =Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs SCREAMING_SNAKE_CASE_: Tuple =config['lr'] SCREAMING_SNAKE_CASE_: Any =int(config["""num_epochs"""] ) SCREAMING_SNAKE_CASE_: Optional[int] =int(config["""seed"""] ) SCREAMING_SNAKE_CASE_: List[str] =int(config["""batch_size"""] ) SCREAMING_SNAKE_CASE_: List[Any] =evaluate.load("""glue""" , """mrpc""" ) # If the batch size is too big we use gradient accumulation SCREAMING_SNAKE_CASE_: Any =1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: SCREAMING_SNAKE_CASE_: List[str] =batch_size // MAX_GPU_BATCH_SIZE SCREAMING_SNAKE_CASE_: Any =MAX_GPU_BATCH_SIZE set_seed(lowerCamelCase_ ) SCREAMING_SNAKE_CASE_: Optional[int] =get_dataloaders(lowerCamelCase_ , lowerCamelCase_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) SCREAMING_SNAKE_CASE_: List[Any] =AutoModelForSequenceClassification.from_pretrained("""bert-base-cased""" , return_dict=lowerCamelCase_ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). SCREAMING_SNAKE_CASE_: Optional[Any] =model.to(accelerator.device ) # Instantiate optimizer SCREAMING_SNAKE_CASE_: str =AdamW(params=model.parameters() , lr=lowerCamelCase_ ) # Instantiate scheduler SCREAMING_SNAKE_CASE_: Optional[Any] =get_linear_schedule_with_warmup( optimizer=lowerCamelCase_ , num_warmup_steps=100 , num_training_steps=(len(lowerCamelCase_ ) * num_epochs) // gradient_accumulation_steps , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. SCREAMING_SNAKE_CASE_: int =accelerator.prepare( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # Now we train the model for epoch in range(lowerCamelCase_ ): model.train() for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) SCREAMING_SNAKE_CASE_: str =model(**lowerCamelCase_ ) SCREAMING_SNAKE_CASE_: Tuple =outputs.loss SCREAMING_SNAKE_CASE_: str =loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase_ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): SCREAMING_SNAKE_CASE_: List[str] =model(**lowerCamelCase_ ) SCREAMING_SNAKE_CASE_: Dict =outputs.logits.argmax(dim=-1 ) SCREAMING_SNAKE_CASE_: str =accelerator.gather_for_metrics((predictions, batch["""labels"""]) ) metric.add_batch( predictions=lowerCamelCase_ , references=lowerCamelCase_ , ) SCREAMING_SNAKE_CASE_: Any =metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f'''epoch {epoch}:''' , lowerCamelCase_ ) def __magic_name__ ( ): SCREAMING_SNAKE_CASE_: List[Any] =argparse.ArgumentParser(description="""Simple example of training script.""" ) parser.add_argument( """--mixed_precision""" , type=lowerCamelCase_ , default=lowerCamelCase_ , choices=["""no""", """fp16""", """bf16""", """fp8"""] , help="""Whether to use mixed precision. Choose""" """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.""" """and an Nvidia Ampere GPU.""" , ) parser.add_argument("""--cpu""" , action="""store_true""" , help="""If passed, will train on the CPU.""" ) SCREAMING_SNAKE_CASE_: Optional[int] =parser.parse_args() SCREAMING_SNAKE_CASE_: Dict ={'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(lowerCamelCase_ , lowerCamelCase_ ) if __name__ == "__main__": main()
173
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import argparse import os # New Code # import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils import find_executable_batch_size ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to ensure out-of-memory errors never # interrupt training, and builds off the `nlp_example.py` script. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # New additions from the base script can be found quickly by # looking for the # New Code # tags # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## _a = 16 _a = 32 def lowerCAmelCase__(__snake_case ,__snake_case = 16 ) -> Dict: '''simple docstring''' lowerCamelCase__ = AutoTokenizer.from_pretrained('''bert-base-cased''' ) lowerCamelCase__ = load_dataset('''glue''' ,'''mrpc''' ) def tokenize_function(__snake_case ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase__ = tokenizer(examples['''sentence1'''] ,examples['''sentence2'''] ,truncation=lowerCamelCase_ ,max_length=lowerCamelCase_ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): lowerCamelCase__ = datasets.map( lowerCamelCase_ ,batched=lowerCamelCase_ ,remove_columns=['''idx''', '''sentence1''', '''sentence2'''] ,) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCamelCase__ = tokenized_datasets.rename_column('''label''' ,'''labels''' ) def collate_fn(__snake_case ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase__ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase__ = 16 elif accelerator.mixed_precision != "no": lowerCamelCase__ = 8 else: lowerCamelCase__ = None return tokenizer.pad( lowerCamelCase_ ,padding='''longest''' ,max_length=lowerCamelCase_ ,pad_to_multiple_of=lowerCamelCase_ ,return_tensors='''pt''' ,) # Instantiate dataloaders. lowerCamelCase__ = DataLoader( tokenized_datasets['''train'''] ,shuffle=lowerCamelCase_ ,collate_fn=lowerCamelCase_ ,batch_size=lowerCamelCase_ ) lowerCamelCase__ = DataLoader( tokenized_datasets['''validation'''] ,shuffle=lowerCamelCase_ ,collate_fn=lowerCamelCase_ ,batch_size=lowerCamelCase_ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS", None) == "1": from accelerate.test_utils.training import mocked_dataloaders _a = mocked_dataloaders # noqa: F811 def lowerCAmelCase__(__snake_case ,__snake_case ) -> int: '''simple docstring''' if os.environ.get('''TESTING_MOCKED_DATALOADERS''' ,lowerCamelCase_ ) == "1": lowerCamelCase__ = 2 # Initialize accelerator lowerCamelCase__ = Accelerator(cpu=args.cpu ,mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase__ = config['lr'] lowerCamelCase__ = int(config['''num_epochs'''] ) lowerCamelCase__ = int(config['''seed'''] ) lowerCamelCase__ = int(config['''batch_size'''] ) lowerCamelCase__ = evaluate.load('''glue''' ,'''mrpc''' ) # New Code # # We now can define an inner training loop function. It should take a batch size as the only parameter, # and build the dataloaders in there. # It also gets our decorator @find_executable_batch_size(starting_batch_size=lowerCamelCase_ ) def inner_training_loop(__snake_case ): # And now just move everything below under this function # We need to bring in the Accelerator object from earlier nonlocal accelerator # And reset all of its attributes that could hold onto any memory: accelerator.free_memory() # Then we can declare the model, optimizer, and everything else: set_seed(lowerCamelCase_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase__ = AutoModelForSequenceClassification.from_pretrained('''bert-base-cased''' ,return_dict=lowerCamelCase_ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). lowerCamelCase__ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase__ = AdamW(params=model.parameters() ,lr=lowerCamelCase_ ) lowerCamelCase__ = get_dataloaders(lowerCamelCase_ ,lowerCamelCase_ ) # Instantiate scheduler lowerCamelCase__ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase_ ,num_warmup_steps=100 ,num_training_steps=(len(lowerCamelCase_ ) * num_epochs) ,) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCamelCase__ = accelerator.prepare( lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_ ) # Now we train the model for epoch in range(lowerCamelCase_ ): model.train() for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase__ = model(**lowerCamelCase_ ) lowerCamelCase__ = outputs.loss accelerator.backward(lowerCamelCase_ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase__ = model(**lowerCamelCase_ ) lowerCamelCase__ = outputs.logits.argmax(dim=-1 ) lowerCamelCase__ = accelerator.gather_for_metrics((predictions, batch['''labels''']) ) metric.add_batch( predictions=lowerCamelCase_ ,references=lowerCamelCase_ ,) lowerCamelCase__ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' ,lowerCamelCase_ ) # New Code # # And call it at the end with no arguments # Note: You could also refactor this outside of your training loop function inner_training_loop() def lowerCAmelCase__() -> List[Any]: '''simple docstring''' lowerCamelCase__ = argparse.ArgumentParser(description='''Simple example of training script.''' ) parser.add_argument( '''--mixed_precision''' ,type=lowerCamelCase_ ,default=lowerCamelCase_ ,choices=['''no''', '''fp16''', '''bf16''', '''fp8'''] ,help='''Whether to use mixed precision. Choose''' '''between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.''' '''and an Nvidia Ampere GPU.''' ,) parser.add_argument('''--cpu''' ,action='''store_true''' ,help='''If passed, will train on the CPU.''' ) lowerCamelCase__ = parser.parse_args() lowerCamelCase__ = {'lr': 2E-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(lowerCamelCase_ ,lowerCamelCase_ ) if __name__ == "__main__": main()
209
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
0
# Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib __UpperCAmelCase = get_logger() __UpperCAmelCase = None class lowerCamelCase (TensorFormatter[Mapping, '''jax.Array''', Mapping] ): '''simple docstring''' def __init__( self , _UpperCamelCase=None , _UpperCamelCase=None , **_UpperCamelCase ) -> List[Any]: super().__init__(features=_UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(_UpperCamelCase , _UpperCamelCase ): raise ValueError( f"Expected {device} to be a `str` not {type(_UpperCamelCase )}, as `jaxlib.xla_extension.Device` " 'is not serializable neither with `pickle` nor with `dill`. Instead you can surround ' 'the device with `str()` to get its string identifier that will be internally mapped ' 'to the actual `jaxlib.xla_extension.Device`.' ) UpperCAmelCase_ : int = device if isinstance(_UpperCamelCase , _UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: UpperCAmelCase_ : List[Any] = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"Device with string identifier {self.device} not listed among the available " f"devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default " f"device: {str(jax.devices()[0] )}." ) UpperCAmelCase_ : Dict = str(jax.devices()[0] ) UpperCAmelCase_ : str = jnp_array_kwargs @staticmethod def __UpperCAmelCase ( ) -> Dict[str, "jaxlib.xla_extension.Device"]: import jax return {str(_UpperCamelCase ): device for device in jax.devices()} def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: import jax import jax.numpy as jnp if isinstance(_UpperCamelCase , _UpperCamelCase ) and column: if all( isinstance(_UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(_UpperCamelCase , axis=0 ) return column def __UpperCAmelCase ( self , _UpperCamelCase ) -> Union[str, Any]: import jax import jax.numpy as jnp if isinstance(_UpperCamelCase , (str, bytes, type(_UpperCamelCase )) ): return value elif isinstance(_UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() UpperCAmelCase_ : Any = {} if isinstance(_UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: UpperCAmelCase_ : Dict = {'dtype': jnp.intaa} else: UpperCAmelCase_ : List[str] = {'dtype': jnp.intaa} elif isinstance(_UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): UpperCAmelCase_ : Tuple = {'dtype': jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(_UpperCamelCase , PIL.Image.Image ): UpperCAmelCase_ : List[str] = np.asarray(_UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: UpperCAmelCase_ : Any = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(_UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Dict: import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(_UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(_UpperCamelCase , '__array__' ) and not isinstance(_UpperCamelCase , jax.Array ): UpperCAmelCase_ : Any = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(_UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(_UpperCamelCase ) for substruct in data_struct] ) elif isinstance(_UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(_UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> int: return map_nested(self._recursive_tensorize , _UpperCamelCase , map_list=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Mapping: UpperCAmelCase_ : Dict = self.numpy_arrow_extractor().extract_row(_UpperCamelCase ) UpperCAmelCase_ : Tuple = self.python_features_decoder.decode_row(_UpperCamelCase ) return self.recursive_tensorize(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> "jax.Array": UpperCAmelCase_ : Optional[Any] = self.numpy_arrow_extractor().extract_column(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = self.python_features_decoder.decode_column(_UpperCamelCase , pa_table.column_names[0] ) UpperCAmelCase_ : List[str] = self.recursive_tensorize(_UpperCamelCase ) UpperCAmelCase_ : Tuple = self._consolidate(_UpperCamelCase ) return column def __UpperCAmelCase ( self , _UpperCamelCase ) -> Mapping: UpperCAmelCase_ : str = self.numpy_arrow_extractor().extract_batch(_UpperCamelCase ) UpperCAmelCase_ : Dict = self.python_features_decoder.decode_batch(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.recursive_tensorize(_UpperCamelCase ) for column_name in batch: UpperCAmelCase_ : str = self._consolidate(batch[column_name] ) return batch
29
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
0
import mpmath # for roots of unity import numpy as np class A__ : def __init__( self : str , a : Tuple=None , a : Optional[Any]=None ): '''simple docstring''' lowerCAmelCase__ : Optional[int] = list(poly_a or [0] )[:] lowerCAmelCase__ : int = list(poly_b or [0] )[:] # Remove leading zero coefficients while self.polyA[-1] == 0: self.polyA.pop() lowerCAmelCase__ : Optional[Any] = len(self.polyA ) while self.polyB[-1] == 0: self.polyB.pop() lowerCAmelCase__ : Union[str, Any] = len(self.polyB ) # Add 0 to make lengths equal a power of 2 lowerCAmelCase__ : Optional[Any] = int( 2 ** np.ceil(np.loga(len(self.polyA ) + len(self.polyB ) - 1 ) ) ) while len(self.polyA ) < self.c_max_length: self.polyA.append(0 ) while len(self.polyB ) < self.c_max_length: self.polyB.append(0 ) # A complex root used for the fourier transform lowerCAmelCase__ : str = complex(mpmath.root(x=1 , n=self.c_max_length , k=1 ) ) # The product lowerCAmelCase__ : Optional[Any] = self.__multiply() def _lowerCamelCase ( self : int , a : Union[str, Any] ): '''simple docstring''' lowerCAmelCase__ : List[str] = [[x] for x in self.polyA] if which == 'A' else [[x] for x in self.polyB] # Corner case if len(a ) <= 1: return dft[0] # lowerCAmelCase__ : Optional[Any] = self.c_max_length // 2 while next_ncol > 0: lowerCAmelCase__ : Any = [[] for i in range(a )] lowerCAmelCase__ : List[str] = self.root**next_ncol # First half of next step lowerCAmelCase__ : str = 1 for j in range(self.c_max_length // (next_ncol * 2) ): for i in range(a ): new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j] ) current_root *= root # Second half of next step lowerCAmelCase__ : Any = 1 for j in range(self.c_max_length // (next_ncol * 2) ): for i in range(a ): new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j] ) current_root *= root # Update lowerCAmelCase__ : str = new_dft lowerCAmelCase__ : Union[str, Any] = next_ncol // 2 return dft[0] def _lowerCamelCase ( self : Optional[Any] ): '''simple docstring''' lowerCAmelCase__ : List[str] = self.__dft('A' ) lowerCAmelCase__ : str = self.__dft('B' ) lowerCAmelCase__ : int = [[dft_a[i] * dft_b[i] for i in range(self.c_max_length )]] del dft_a del dft_b # Corner Case if len(inverce_c[0] ) <= 1: return inverce_c[0] # Inverse DFT lowerCAmelCase__ : int = 2 while next_ncol <= self.c_max_length: lowerCAmelCase__ : Optional[int] = [[] for i in range(a )] lowerCAmelCase__ : Union[str, Any] = self.root ** (next_ncol // 2) lowerCAmelCase__ : int = 1 # First half of next step for j in range(self.c_max_length // next_ncol ): for i in range(next_ncol // 2 ): # Even positions new_inverse_c[i].append( ( inverce_c[i][j] + inverce_c[i][j + self.c_max_length // next_ncol] ) / 2 ) # Odd positions new_inverse_c[i + next_ncol // 2].append( ( inverce_c[i][j] - inverce_c[i][j + self.c_max_length // next_ncol] ) / (2 * current_root) ) current_root *= root # Update lowerCAmelCase__ : Optional[Any] = new_inverse_c next_ncol *= 2 # Unpack lowerCAmelCase__ : Any = [round(x[0].real , 8 ) + round(x[0].imag , 8 ) * 1J for x in inverce_c] # Remove leading 0's while inverce_c[-1] == 0: inverce_c.pop() return inverce_c def __str__( self : str ): '''simple docstring''' lowerCAmelCase__ : List[str] = 'A = ' + ' + '.join( f'''{coef}*x^{i}''' for coef, i in enumerate(self.polyA[: self.len_A] ) ) lowerCAmelCase__ : int = 'B = ' + ' + '.join( f'''{coef}*x^{i}''' for coef, i in enumerate(self.polyB[: self.len_B] ) ) lowerCAmelCase__ : Optional[int] = 'A*B = ' + ' + '.join( f'''{coef}*x^{i}''' for coef, i in enumerate(self.product ) ) return f'''{a}\n{b}\n{c}''' # Unit tests if __name__ == "__main__": import doctest doctest.testmod()
212
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
0
from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging lowerCAmelCase__ :Optional[int] = logging.get_logger(__name__) def lowerCAmelCase__ ( a__: Union[str, Any] ) -> List[int]: '''simple docstring''' if isinstance(lowerCamelCase_ , np.ndarray ): return list(tensor.shape ) _UpperCAmelCase = tf.shape(lowerCamelCase_ ) if tensor.shape == tf.TensorShape(lowerCamelCase_ ): return dynamic _UpperCAmelCase = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(lowerCamelCase_ )] def lowerCAmelCase__ ( a__: List[Any] , a__: Any = None , a__: Union[str, Any] = None ) -> tf.Tensor: '''simple docstring''' return tf.nn.softmax(logits=logits + 1e-9 , axis=lowerCamelCase_ , name=lowerCamelCase_ ) def lowerCAmelCase__ ( a__: Any , a__: Union[str, Any] , a__: Optional[int] , a__: Union[str, Any]=1e-5 , a__: Optional[int]=-1 ) -> Tuple: '''simple docstring''' if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise NotImplementedError('Only 1D weight and bias tensors are supported for now, with only a single axis.' ) # Get mean and variance on the axis to be normalized _UpperCAmelCase = tf.nn.moments(lowerCamelCase_ , axes=[axis] , keepdims=lowerCamelCase_ ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis _UpperCAmelCase = [1] * inputs.shape.rank _UpperCAmelCase = shape_list(lowerCamelCase_ )[axis] _UpperCAmelCase = tf.reshape(lowerCamelCase_ , lowerCamelCase_ ) _UpperCAmelCase = tf.reshape(lowerCamelCase_ , lowerCamelCase_ ) # Compute layer normalization using the batch_normalization # function. _UpperCAmelCase = tf.nn.batch_normalization( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , offset=lowerCamelCase_ , scale=lowerCamelCase_ , variance_epsilon=lowerCamelCase_ , ) return outputs def lowerCAmelCase__ ( a__: List[Any] , a__: Optional[Any]=0 , a__: Optional[Any]=-1 ) -> Optional[Any]: '''simple docstring''' if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input _UpperCAmelCase = tf.shape(lowerCamelCase_ ) _UpperCAmelCase = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) _UpperCAmelCase = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] , axis=0 ) return tf.reshape(lowerCamelCase_ , lowerCamelCase_ ) def lowerCAmelCase__ ( a__: List[Any] ) -> tf.Tensor: '''simple docstring''' if not isinstance(lowerCamelCase_ , tf.Tensor ): _UpperCAmelCase = tf.convert_to_tensor(lowerCamelCase_ ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: _UpperCAmelCase = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: _UpperCAmelCase = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) _UpperCAmelCase = ( tf.cast(1 , encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def lowerCAmelCase__ ( a__: Union[str, Any] , a__: Optional[Any] , a__: List[str] = "input_ids" ) -> None: '''simple docstring''' tf.debugging.assert_less( lowerCamelCase_ , tf.cast(lowerCamelCase_ , dtype=tensor.dtype ) , message=( F'''The maximum value of {tensor_name} ({tf.math.reduce_max(lowerCamelCase_ )}) must be smaller than the embedding ''' F'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) , ) def lowerCAmelCase__ ( a__: Any , a__: Tuple , a__: List[Any] ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = 6_4_5_1_2 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. _UpperCAmelCase = [x for x in data if len(lowerCamelCase_ ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( 'The following attributes cannot be saved to HDF5 file because ' F'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' F'''bytes: {bad_attributes}''' ) _UpperCAmelCase = np.asarray(lowerCamelCase_ ) _UpperCAmelCase = 1 _UpperCAmelCase = np.array_split(lowerCamelCase_ , lowerCamelCase_ ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 _UpperCAmelCase = np.array_split(lowerCamelCase_ , lowerCamelCase_ ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(lowerCamelCase_ ): _UpperCAmelCase = chunk_data else: _UpperCAmelCase = data def lowerCAmelCase__ ( a__: str , a__: str ) -> List[Any]: '''simple docstring''' if name in group.attrs: _UpperCAmelCase = [n.decode('utf8' ) if hasattr(lowerCamelCase_ , 'decode' ) else n for n in group.attrs[name]] else: _UpperCAmelCase = [] _UpperCAmelCase = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('utf8' ) if hasattr(lowerCamelCase_ , 'decode' ) else n for n in group.attrs['%s%d' % (name, chunk_id)]] ) chunk_id += 1 return data def lowerCAmelCase__ ( a__: Union[str, Any] ) -> Optional[Any]: '''simple docstring''' def _expand_single_ad_tensor(a__: int ): if isinstance(lowerCamelCase_ , tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(lowerCamelCase_ , axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor , lowerCamelCase_ )
329
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
0
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase__ : List[str] = logging.get_logger(__name__) lowercase__ : int = { "snap-research/efficientformer-l1-300": ( "https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json" ), } class UpperCAmelCase ( _a ): '''simple docstring''' lowerCAmelCase_ = """efficientformer""" def __init__( self : Any , __lowercase : Any = [3, 2, 6, 4] , __lowercase : Tuple = [48, 96, 2_24, 4_48] , __lowercase : str = [True, True, True, True] , __lowercase : Tuple = 4_48 , __lowercase : str = 32 , __lowercase : List[str] = 4 , __lowercase : List[str] = 7 , __lowercase : List[Any] = 5 , __lowercase : Tuple = 8 , __lowercase : Optional[Any] = 4 , __lowercase : Optional[Any] = 0.0 , __lowercase : Any = 16 , __lowercase : Dict = 3 , __lowercase : Any = 3 , __lowercase : Union[str, Any] = 3 , __lowercase : str = 2 , __lowercase : Tuple = 1 , __lowercase : Dict = 0.0 , __lowercase : int = 1 , __lowercase : Any = True , __lowercase : str = True , __lowercase : List[Any] = 1E-5 , __lowercase : Tuple = "gelu" , __lowercase : Union[str, Any] = 0.02 , __lowercase : Union[str, Any] = 1E-12 , __lowercase : List[Any] = 2_24 , __lowercase : Optional[Any] = 1E-05 , **__lowercase : Optional[Any] , ): """simple docstring""" super().__init__(**__lowercase ) snake_case_ = hidden_act snake_case_ = hidden_dropout_prob snake_case_ = hidden_sizes snake_case_ = num_hidden_layers snake_case_ = num_attention_heads snake_case_ = initializer_range snake_case_ = layer_norm_eps snake_case_ = patch_size snake_case_ = num_channels snake_case_ = depths snake_case_ = mlp_expansion_ratio snake_case_ = downsamples snake_case_ = dim snake_case_ = key_dim snake_case_ = attention_ratio snake_case_ = resolution snake_case_ = pool_size snake_case_ = downsample_patch_size snake_case_ = downsample_stride snake_case_ = downsample_pad snake_case_ = drop_path_rate snake_case_ = num_metaad_blocks snake_case_ = distillation snake_case_ = use_layer_scale snake_case_ = layer_scale_init_value snake_case_ = image_size snake_case_ = batch_norm_eps
187
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """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.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available __snake_case = { "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"], "configuration_data2vec_text": [ "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecTextConfig", "Data2VecTextOnnxConfig", ], "configuration_data2vec_vision": [ "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecVisionConfig", "Data2VecVisionOnnxConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __snake_case = [ "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecAudioForAudioFrameClassification", "Data2VecAudioForCTC", "Data2VecAudioForSequenceClassification", "Data2VecAudioForXVector", "Data2VecAudioModel", "Data2VecAudioPreTrainedModel", ] __snake_case = [ "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecTextForCausalLM", "Data2VecTextForMaskedLM", "Data2VecTextForMultipleChoice", "Data2VecTextForQuestionAnswering", "Data2VecTextForSequenceClassification", "Data2VecTextForTokenClassification", "Data2VecTextModel", "Data2VecTextPreTrainedModel", ] __snake_case = [ "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST", "Data2VecVisionForImageClassification", "Data2VecVisionForMaskedImageModeling", "Data2VecVisionForSemanticSegmentation", "Data2VecVisionModel", "Data2VecVisionPreTrainedModel", ] if is_tf_available(): __snake_case = [ "TFData2VecVisionForImageClassification", "TFData2VecVisionForSemanticSegmentation", "TFData2VecVisionModel", "TFData2VecVisionPreTrainedModel", ] if TYPE_CHECKING: from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig from .configuration_dataavec_text import ( DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecTextConfig, DataaVecTextOnnxConfig, ) from .configuration_dataavec_vision import ( DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecVisionConfig, DataaVecVisionOnnxConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_dataavec_audio import ( DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecAudioForAudioFrameClassification, DataaVecAudioForCTC, DataaVecAudioForSequenceClassification, DataaVecAudioForXVector, DataaVecAudioModel, DataaVecAudioPreTrainedModel, ) from .modeling_dataavec_text import ( DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecTextForCausalLM, DataaVecTextForMaskedLM, DataaVecTextForMultipleChoice, DataaVecTextForQuestionAnswering, DataaVecTextForSequenceClassification, DataaVecTextForTokenClassification, DataaVecTextModel, DataaVecTextPreTrainedModel, ) from .modeling_dataavec_vision import ( DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST, DataaVecVisionForImageClassification, DataaVecVisionForMaskedImageModeling, DataaVecVisionForSemanticSegmentation, DataaVecVisionModel, DataaVecVisionPreTrainedModel, ) if is_tf_available(): from .modeling_tf_dataavec_vision import ( TFDataaVecVisionForImageClassification, TFDataaVecVisionForSemanticSegmentation, TFDataaVecVisionModel, TFDataaVecVisionPreTrainedModel, ) else: import sys __snake_case = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
97
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class _lowerCAmelCase ( _a ): """simple docstring""" def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Tuple = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(__UpperCAmelCase , 'width_multiplier' ) ) class _lowerCAmelCase : """simple docstring""" def __init__( self , __UpperCAmelCase , __UpperCAmelCase=1_3 , __UpperCAmelCase=6_4 , __UpperCAmelCase=2 , __UpperCAmelCase=3 , __UpperCAmelCase="swish" , __UpperCAmelCase=3 , __UpperCAmelCase=3_2 , __UpperCAmelCase=0.1 , __UpperCAmelCase=0.02 , __UpperCAmelCase=True , __UpperCAmelCase=True , __UpperCAmelCase=1_0 , __UpperCAmelCase=None , __UpperCAmelCase=0.25 , __UpperCAmelCase=0.0 , __UpperCAmelCase=0.0 , ): '''simple docstring''' lowerCAmelCase__ :Any = parent lowerCAmelCase__ :Optional[int] = batch_size lowerCAmelCase__ :Dict = image_size lowerCAmelCase__ :str = patch_size lowerCAmelCase__ :Optional[int] = num_channels lowerCAmelCase__ :Optional[Any] = make_divisible(5_1_2 * width_multiplier , divisor=8 ) lowerCAmelCase__ :str = hidden_act lowerCAmelCase__ :Dict = conv_kernel_size lowerCAmelCase__ :int = output_stride lowerCAmelCase__ :Optional[Any] = classifier_dropout_prob lowerCAmelCase__ :Tuple = use_labels lowerCAmelCase__ :int = is_training lowerCAmelCase__ :Optional[Any] = num_labels lowerCAmelCase__ :Dict = initializer_range lowerCAmelCase__ :List[str] = scope lowerCAmelCase__ :Tuple = width_multiplier lowerCAmelCase__ :List[str] = ffn_dropout lowerCAmelCase__ :Dict = attn_dropout def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) lowerCAmelCase__ :Dict = None lowerCAmelCase__ :Optional[int] = None if self.use_labels: lowerCAmelCase__ :Optional[Any] = ids_tensor([self.batch_size] , self.num_labels ) lowerCAmelCase__ :str = ids_tensor([self.batch_size, self.image_size, self.image_size] , self.num_labels ) lowerCAmelCase__ :Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def snake_case ( self ): '''simple docstring''' return MobileViTVaConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_act=self.hidden_act , conv_kernel_size=self.conv_kernel_size , output_stride=self.output_stride , classifier_dropout_prob=self.classifier_dropout_prob , initializer_range=self.initializer_range , width_multiplier=self.width_multiplier , ffn_dropout=self.ffn_dropout_prob , attn_dropout=self.attn_dropout_prob , ) def snake_case ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ): '''simple docstring''' lowerCAmelCase__ :Optional[int] = MobileViTVaModel(config=__UpperCAmelCase ) model.to(__UpperCAmelCase ) model.eval() lowerCAmelCase__ :Optional[int] = model(__UpperCAmelCase ) self.parent.assertEqual( result.last_hidden_state.shape , ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) def snake_case ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ): '''simple docstring''' lowerCAmelCase__ :int = self.num_labels lowerCAmelCase__ :Optional[int] = MobileViTVaForImageClassification(__UpperCAmelCase ) model.to(__UpperCAmelCase ) model.eval() lowerCAmelCase__ :Optional[Any] = model(__UpperCAmelCase , labels=__UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def snake_case ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ): '''simple docstring''' lowerCAmelCase__ :Any = self.num_labels lowerCAmelCase__ :Union[str, Any] = MobileViTVaForSemanticSegmentation(__UpperCAmelCase ) model.to(__UpperCAmelCase ) model.eval() lowerCAmelCase__ :Optional[int] = model(__UpperCAmelCase ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) lowerCAmelCase__ :List[Any] = model(__UpperCAmelCase , labels=__UpperCAmelCase ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :str = self.prepare_config_and_inputs() lowerCAmelCase__ :int = config_and_inputs lowerCAmelCase__ :List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCAmelCase ( _a , _a , unittest.TestCase ): """simple docstring""" __magic_name__ :List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) __magic_name__ :Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) __magic_name__ :List[Any] = False __magic_name__ :Optional[int] = False __magic_name__ :List[Any] = False __magic_name__ :Tuple = False def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Union[str, Any] = MobileViTVaModelTester(self ) lowerCAmelCase__ :Tuple = MobileViTVaConfigTester(self , config_class=__UpperCAmelCase , has_text_modality=__UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds' ) def snake_case ( self ): '''simple docstring''' pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings' ) def snake_case ( self ): '''simple docstring''' pass @unittest.skip(reason='MobileViTV2 does not output attentions' ) def snake_case ( self ): '''simple docstring''' pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.' ) def snake_case ( self ): '''simple docstring''' pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def snake_case ( self ): '''simple docstring''' pass def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCAmelCase__ :List[Any] = model_class(__UpperCAmelCase ) lowerCAmelCase__ :Tuple = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic lowerCAmelCase__ :Any = [*signature.parameters.keys()] lowerCAmelCase__ :Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1] , __UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' def check_hidden_states_output(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ): lowerCAmelCase__ :Optional[Any] = model_class(__UpperCAmelCase ) model.to(__UpperCAmelCase ) model.eval() with torch.no_grad(): lowerCAmelCase__ :Optional[int] = model(**self._prepare_for_class(__UpperCAmelCase , __UpperCAmelCase ) ) lowerCAmelCase__ :List[Any] = outputs.hidden_states lowerCAmelCase__ :Tuple = 5 self.assertEqual(len(__UpperCAmelCase ) , __UpperCAmelCase ) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. lowerCAmelCase__ :Optional[int] = 2 for i in range(len(__UpperCAmelCase ) ): self.assertListEqual( list(hidden_states[i].shape[-2:] ) , [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor] , ) divisor *= 2 self.assertEqual(self.model_tester.output_stride , divisor // 2 ) lowerCAmelCase__ :Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCAmelCase__ :Tuple = True check_hidden_states_output(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] lowerCAmelCase__ :Optional[Any] = True check_hidden_states_output(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase ) def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCAmelCase ) @slow def snake_case ( self ): '''simple docstring''' for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCAmelCase__ :str = MobileViTVaModel.from_pretrained(__UpperCAmelCase ) self.assertIsNotNone(__UpperCAmelCase ) def __A () ->Dict: """simple docstring""" lowerCAmelCase__ :Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCAmelCase ( unittest.TestCase ): """simple docstring""" @cached_property def snake_case ( self ): '''simple docstring''' return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256' ) if is_vision_available() else None ) @slow def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256' ).to( __UpperCAmelCase ) lowerCAmelCase__ :Dict = self.default_image_processor lowerCAmelCase__ :Union[str, Any] = prepare_img() lowerCAmelCase__ :Dict = image_processor(images=__UpperCAmelCase , return_tensors='pt' ).to(__UpperCAmelCase ) # forward pass with torch.no_grad(): lowerCAmelCase__ :Tuple = model(**__UpperCAmelCase ) # verify the logits lowerCAmelCase__ :Optional[int] = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , __UpperCAmelCase ) lowerCAmelCase__ :Union[str, Any] = torch.tensor([-1.6336E00, -7.3204E-02, -5.1883E-01] ).to(__UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , __UpperCAmelCase , atol=1E-4 ) ) @slow def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' ) lowerCAmelCase__ :Optional[int] = model.to(__UpperCAmelCase ) lowerCAmelCase__ :Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' ) lowerCAmelCase__ :Union[str, Any] = prepare_img() lowerCAmelCase__ :Tuple = image_processor(images=__UpperCAmelCase , return_tensors='pt' ).to(__UpperCAmelCase ) # forward pass with torch.no_grad(): lowerCAmelCase__ :List[Any] = model(**__UpperCAmelCase ) lowerCAmelCase__ :str = outputs.logits # verify the logits lowerCAmelCase__ :Tuple = torch.Size((1, 2_1, 3_2, 3_2) ) self.assertEqual(logits.shape , __UpperCAmelCase ) lowerCAmelCase__ :Union[str, Any] = torch.tensor( [ [[7.08_63, 7.15_25, 6.82_01], [6.69_31, 6.87_70, 6.89_33], [6.29_78, 7.03_66, 6.96_36]], [[-3.71_34, -3.67_12, -3.66_75], [-3.58_25, -3.35_49, -3.47_77], [-3.34_35, -3.39_79, -3.28_57]], [[-2.93_29, -2.80_03, -2.73_69], [-3.05_64, -2.47_80, -2.02_07], [-2.68_89, -1.92_98, -1.76_40]], ] , device=__UpperCAmelCase , ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3] , __UpperCAmelCase , atol=1E-4 ) ) @slow def snake_case ( self ): '''simple docstring''' lowerCAmelCase__ :List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' ) lowerCAmelCase__ :Tuple = model.to(__UpperCAmelCase ) lowerCAmelCase__ :str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3' ) lowerCAmelCase__ :int = prepare_img() lowerCAmelCase__ :Dict = image_processor(images=__UpperCAmelCase , return_tensors='pt' ).to(__UpperCAmelCase ) # forward pass with torch.no_grad(): lowerCAmelCase__ :Union[str, Any] = model(**__UpperCAmelCase ) lowerCAmelCase__ :Any = outputs.logits.detach().cpu() lowerCAmelCase__ :Optional[int] = image_processor.post_process_semantic_segmentation(outputs=__UpperCAmelCase , target_sizes=[(5_0, 6_0)] ) lowerCAmelCase__ :Any = torch.Size((5_0, 6_0) ) self.assertEqual(segmentation[0].shape , __UpperCAmelCase ) lowerCAmelCase__ :Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=__UpperCAmelCase ) lowerCAmelCase__ :Optional[int] = torch.Size((3_2, 3_2) ) self.assertEqual(segmentation[0].shape , __UpperCAmelCase )
293
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
"""simple docstring""" import os from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen, xsplitext from ..table import array_cast from ..utils.py_utils import no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: from .features import FeatureType lowerCAmelCase = False, False, False @dataclass class A_ : """simple docstring""" SCREAMING_SNAKE_CASE_ = None SCREAMING_SNAKE_CASE_ = True SCREAMING_SNAKE_CASE_ = True SCREAMING_SNAKE_CASE_ = None # Automatically constructed SCREAMING_SNAKE_CASE_ = "dict" SCREAMING_SNAKE_CASE_ = pa.struct({"""bytes""": pa.binary(), """path""": pa.string()} ) SCREAMING_SNAKE_CASE_ = field(default="""Audio""" , init=_a , repr=_a ) def __call__( self :Dict ): """simple docstring""" return self.pa_type def UpperCAmelCase__ ( self :Union[str, Any] , lowerCamelCase_ :Union[str, Any] ): """simple docstring""" try: import soundfile as sf # soundfile is a dependency of librosa, needed to decode audio files. except ImportError as err: raise ImportError('To support encoding audio data, please install \'soundfile\'.' ) from err if isinstance(lowerCamelCase_ , lowerCamelCase_ ): return {"bytes": None, "path": value} elif isinstance(lowerCamelCase_ , lowerCamelCase_ ): return {"bytes": value, "path": None} elif "array" in value: # convert the audio array to wav bytes lowerCamelCase__ : Optional[Any] =BytesIO() sf.write(lowerCamelCase_ , value['array'] , value['sampling_rate'] , format='wav' ) return {"bytes": buffer.getvalue(), "path": None} elif value.get('path' ) is not None and os.path.isfile(value['path'] ): # we set "bytes": None to not duplicate the data if they're already available locally if value["path"].endswith('pcm' ): # "PCM" only has raw audio bytes if value.get('sampling_rate' ) is None: # At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate raise KeyError('To use PCM files, please specify a \'sampling_rate\' in Audio object' ) if value.get('bytes' ): # If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!) lowerCamelCase__ : List[Any] =np.frombuffer(value['bytes'] , dtype=np.intaa ).astype(np.floataa ) / 32_767 else: lowerCamelCase__ : Dict =np.memmap(value['path'] , dtype='h' , mode='r' ).astype(np.floataa ) / 32_767 lowerCamelCase__ : List[str] =BytesIO(bytes() ) sf.write(lowerCamelCase_ , lowerCamelCase_ , value['sampling_rate'] , format='wav' ) return {"bytes": buffer.getvalue(), "path": None} else: return {"bytes": None, "path": value.get('path' )} elif value.get('bytes' ) is not None or value.get('path' ) is not None: # store the audio bytes, and path is used to infer the audio format using the file extension return {"bytes": value.get('bytes' ), "path": value.get('path' )} else: raise ValueError( f"""An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.""" ) def UpperCAmelCase__ ( self :int , lowerCamelCase_ :int , lowerCamelCase_ :Any = None ): """simple docstring""" if not self.decode: raise RuntimeError('Decoding is disabled for this feature. Please use Audio(decode=True) instead.' ) lowerCamelCase__ : List[Any] =(value['path'], BytesIO(value['bytes'] )) if value['bytes'] is not None else (value['path'], None) if path is None and file is None: raise ValueError(f"""An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.""" ) try: import librosa import soundfile as sf except ImportError as err: raise ImportError('To support decoding audio files, please install \'librosa\' and \'soundfile\'.' ) from err lowerCamelCase__ : Optional[Any] =xsplitext(lowerCamelCase_ )[1][1:].lower() if path is not None else None if not config.IS_OPUS_SUPPORTED and audio_format == "opus": raise RuntimeError( 'Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, ' 'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ' ) elif not config.IS_MP3_SUPPORTED and audio_format == "mp3": raise RuntimeError( 'Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, ' 'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ' ) if file is None: lowerCamelCase__ : int =token_per_repo_id or {} lowerCamelCase__ : Optional[int] =path.split('::' )[-1] try: lowerCamelCase__ : Any =string_to_dict(lowerCamelCase_ , config.HUB_DATASETS_URL )['repo_id'] lowerCamelCase__ : Optional[Any] =token_per_repo_id[repo_id] except (ValueError, KeyError): lowerCamelCase__ : int =None with xopen(lowerCamelCase_ , 'rb' , use_auth_token=lowerCamelCase_ ) as f: lowerCamelCase__ : int =sf.read(lowerCamelCase_ ) else: lowerCamelCase__ : Union[str, Any] =sf.read(lowerCamelCase_ ) lowerCamelCase__ : Any =array.T if self.mono: lowerCamelCase__ : List[str] =librosa.to_mono(lowerCamelCase_ ) if self.sampling_rate and self.sampling_rate != sampling_rate: lowerCamelCase__ : Tuple =librosa.resample(lowerCamelCase_ , orig_sr=lowerCamelCase_ , target_sr=self.sampling_rate ) lowerCamelCase__ : List[str] =self.sampling_rate return {"path": path, "array": array, "sampling_rate": sampling_rate} def UpperCAmelCase__ ( self :Any ): """simple docstring""" from .features import Value if self.decode: raise ValueError('Cannot flatten a decoded Audio feature.' ) return { "bytes": Value('binary' ), "path": Value('string' ), } def UpperCAmelCase__ ( self :List[Any] , lowerCamelCase_ :Tuple ): """simple docstring""" if pa.types.is_string(storage.type ): lowerCamelCase__ : List[Any] =pa.array([None] * len(lowerCamelCase_ ) , type=pa.binary() ) lowerCamelCase__ : Union[str, Any] =pa.StructArray.from_arrays([bytes_array, storage] , ['bytes', 'path'] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): lowerCamelCase__ : Tuple =pa.array([None] * len(lowerCamelCase_ ) , type=pa.string() ) lowerCamelCase__ : Dict =pa.StructArray.from_arrays([storage, path_array] , ['bytes', 'path'] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ) and storage.type.get_all_field_indices('array' ): lowerCamelCase__ : int =pa.array([Audio().encode_example(lowerCamelCase_ ) if x is not None else None for x in storage.to_pylist()] ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index('bytes' ) >= 0: lowerCamelCase__ : Optional[int] =storage.field('bytes' ) else: lowerCamelCase__ : str =pa.array([None] * len(lowerCamelCase_ ) , type=pa.binary() ) if storage.type.get_field_index('path' ) >= 0: lowerCamelCase__ : Union[str, Any] =storage.field('path' ) else: lowerCamelCase__ : List[Any] =pa.array([None] * len(lowerCamelCase_ ) , type=pa.string() ) lowerCamelCase__ : Any =pa.StructArray.from_arrays([bytes_array, path_array] , ['bytes', 'path'] , mask=storage.is_null() ) return array_cast(lowerCamelCase_ , self.pa_type ) def UpperCAmelCase__ ( self :Any , lowerCamelCase_ :int ): """simple docstring""" @no_op_if_value_is_null def path_to_bytes(lowerCamelCase_ :int ): with xopen(lowerCamelCase_ , 'rb' ) as f: lowerCamelCase__ : int =f.read() return bytes_ lowerCamelCase__ : Optional[Any] =pa.array( [ (path_to_bytes(x['path'] ) if x['bytes'] is None else x['bytes']) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) lowerCamelCase__ : int =pa.array( [os.path.basename(lowerCamelCase_ ) if path is not None else None for path in storage.field('path' ).to_pylist()] , type=pa.string() , ) lowerCamelCase__ : Dict =pa.StructArray.from_arrays([bytes_array, path_array] , ['bytes', 'path'] , mask=bytes_array.is_null() ) return array_cast(lowerCamelCase_ , self.pa_type )
126
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
from torch import nn class SCREAMING_SNAKE_CASE_ ( nn.Module ): def __init__( self : Any , lowerCamelCase_ : Tuple , lowerCamelCase_ : Tuple ): """simple docstring""" super().__init__() UpperCamelCase = class_size UpperCamelCase = embed_size # self.mlp1 = nn.Linear(embed_size, embed_size) # self.mlp2 = (nn.Linear(embed_size, class_size)) UpperCamelCase = nn.Linear(lowerCamelCase_ , lowerCamelCase_ ) def lowerCamelCase_ ( self : Optional[Any] , lowerCamelCase_ : int ): """simple docstring""" UpperCamelCase = self.mlp(lowerCamelCase_ ) return logits
343
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
from sklearn.metrics import fa_score import datasets UpperCAmelCase : Any = "\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n" UpperCAmelCase : List[Any] = "\nArgs:\n predictions (`list` of `int`): Predicted labels.\n references (`list` of `int`): Ground truth labels.\n labels (`list` of `int`): The set of labels to include when `average` is not set to `'binary'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.\n\n - 'binary': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n - 'micro': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n - 'macro': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - 'weighted': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n - 'samples': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n Example 1-A simple binary example\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n >>> print(results)\n {'f1': 0.5}\n\n Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n >>> print(round(results['f1'], 2))\n 0.67\n\n Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n >>> print(round(results['f1'], 2))\n 0.35\n\n Example 4-A multiclass example, with different values for the `average` input.\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"macro\")\n >>> print(round(results['f1'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"micro\")\n >>> print(round(results['f1'], 2))\n 0.33\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"weighted\")\n >>> print(round(results['f1'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {'f1': array([0.8, 0. , 0. ])}\n" UpperCAmelCase : List[Any] = "\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _A( datasets.Metric ): """simple docstring""" def UpperCAmelCase_ ( self ): return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('int32' ) ), 'references': datasets.Sequence(datasets.Value('int32' ) ), } if self.config_name == 'multilabel' else { 'predictions': datasets.Value('int32' ), 'references': datasets.Value('int32' ), } ) , reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html'] , ) def UpperCAmelCase_ ( self , _A , _A , _A=None , _A=1 , _A="binary" , _A=None ): __A : int = fa_score( _A , _A , labels=_A , pos_label=_A , average=_A , sample_weight=_A ) return {"f1": float(_A ) if score.size == 1 else score}
280
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" def __magic_name__ ( lowercase , lowercase ): while second != 0: SCREAMING_SNAKE_CASE_: Tuple =first & second first ^= second SCREAMING_SNAKE_CASE_: Tuple =c << 1 return first if __name__ == "__main__": import doctest doctest.testmod() _UpperCAmelCase = int(input("""Enter the first number: """).strip()) _UpperCAmelCase = int(input("""Enter the second number: """).strip()) print(f"""{add(first, second) = }""")
173
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
from __future__ import annotations from collections.abc import Generator def lowerCAmelCase__() -> Generator[int, None, None]: '''simple docstring''' lowerCamelCase__ = {} lowerCamelCase__ = 2 while True: lowerCamelCase__ = factor_map.pop(lowerCamelCase_ ,lowerCamelCase_ ) if factor: lowerCamelCase__ = factor + prime while x in factor_map: x += factor lowerCamelCase__ = factor else: lowerCamelCase__ = prime yield prime prime += 1 def lowerCAmelCase__(__snake_case = 1E10 ) -> int: '''simple docstring''' lowerCamelCase__ = sieve() lowerCamelCase__ = 1 while True: lowerCamelCase__ = next(lowerCamelCase_ ) if (2 * prime * n) > limit: return n # Ignore the next prime as the reminder will be 2. next(lowerCamelCase_ ) n += 2 if __name__ == "__main__": print(solution())
209
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class lowerCamelCase (_a , unittest.TestCase ): '''simple docstring''' _snake_case : Any = KandinskyImgaImgPipeline _snake_case : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] _snake_case : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] _snake_case : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] _snake_case : Union[str, Any] = False @property def __UpperCAmelCase ( self ) -> str: return 3_2 @property def __UpperCAmelCase ( self ) -> int: return 3_2 @property def __UpperCAmelCase ( self ) -> Tuple: return self.time_input_dim @property def __UpperCAmelCase ( self ) -> Optional[Any]: return self.time_input_dim * 4 @property def __UpperCAmelCase ( self ) -> List[str]: return 1_0_0 @property def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base' ) return tokenizer @property def __UpperCAmelCase ( self ) -> int: torch.manual_seed(0 ) UpperCAmelCase_ : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim , transformerDimensions=self.text_embedder_hidden_size , hidden_size=self.text_embedder_hidden_size , intermediate_size=3_7 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=1_0_0_5 , ) UpperCAmelCase_ : Optional[int] = MultilingualCLIP(_UpperCamelCase ) UpperCAmelCase_ : List[str] = text_encoder.eval() return text_encoder @property def __UpperCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) UpperCAmelCase_ : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } UpperCAmelCase_ : Optional[Any] = UNetaDConditionModel(**_UpperCamelCase ) return model @property def __UpperCAmelCase ( self ) -> str: return { "block_out_channels": [3_2, 6_4], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 1_2, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def __UpperCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) UpperCAmelCase_ : Dict = VQModel(**self.dummy_movq_kwargs ) return model def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Any = self.dummy_text_encoder UpperCAmelCase_ : List[Any] = self.dummy_tokenizer UpperCAmelCase_ : int = self.dummy_unet UpperCAmelCase_ : int = self.dummy_movq UpperCAmelCase_ : Optional[int] = { 'num_train_timesteps': 1_0_0_0, 'beta_schedule': 'linear', 'beta_start': 0.0_00_85, 'beta_end': 0.0_12, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } UpperCAmelCase_ : List[Any] = DDIMScheduler(**_UpperCamelCase ) UpperCAmelCase_ : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=0 ) -> Dict: UpperCAmelCase_ : List[str] = floats_tensor((1, self.cross_attention_dim) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = floats_tensor((1, self.cross_attention_dim) , rng=random.Random(seed + 1 ) ).to(_UpperCamelCase ) # create init_image UpperCAmelCase_ : Tuple = floats_tensor((1, 3, 6_4, 6_4) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = image.cpu().permute(0 , 2 , 3 , 1 )[0] UpperCAmelCase_ : Tuple = Image.fromarray(np.uinta(_UpperCamelCase ) ).convert('RGB' ).resize((2_5_6, 2_5_6) ) if str(_UpperCamelCase ).startswith('mps' ): UpperCAmelCase_ : List[str] = torch.manual_seed(_UpperCamelCase ) else: UpperCAmelCase_ : Optional[Any] = torch.Generator(device=_UpperCamelCase ).manual_seed(_UpperCamelCase ) UpperCAmelCase_ : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 6_4, 'width': 6_4, 'num_inference_steps': 1_0, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : Dict = 'cpu' UpperCAmelCase_ : Tuple = self.get_dummy_components() UpperCAmelCase_ : str = self.pipeline_class(**_UpperCamelCase ) UpperCAmelCase_ : str = pipe.to(_UpperCamelCase ) pipe.set_progress_bar_config(disable=_UpperCamelCase ) UpperCAmelCase_ : List[str] = pipe(**self.get_dummy_inputs(_UpperCamelCase ) ) UpperCAmelCase_ : Optional[int] = output.images UpperCAmelCase_ : List[Any] = pipe( **self.get_dummy_inputs(_UpperCamelCase ) , return_dict=_UpperCamelCase , )[0] UpperCAmelCase_ : List[str] = image[0, -3:, -3:, -1] UpperCAmelCase_ : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 6_4, 6_4, 3) UpperCAmelCase_ : Tuple = np.array( [0.61_47_49_43, 0.6_07_35_39, 0.43_30_85_44, 0.5_92_82_69, 0.47_49_35_95, 0.46_75_59_73, 0.4_61_38_38, 0.45_36_87_97, 0.50_11_92_33] ) assert ( np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 ), f" expected_slice {expected_slice}, but got {image_slice.flatten()}" assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 ), f" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}" @slow @require_torch_gpu class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Tuple: super().tearDown() gc.collect() torch.cuda.empty_cache() def __UpperCAmelCase ( self ) -> Union[str, Any]: UpperCAmelCase_ : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy' ) UpperCAmelCase_ : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png' ) UpperCAmelCase_ : Optional[int] = 'A red cartoon frog, 4k' UpperCAmelCase_ : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior' , torch_dtype=torch.floataa ) pipe_prior.to(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1' , torch_dtype=torch.floataa ) UpperCAmelCase_ : List[Any] = pipeline.to(_UpperCamelCase ) pipeline.set_progress_bar_config(disable=_UpperCamelCase ) UpperCAmelCase_ : str = torch.Generator(device='cpu' ).manual_seed(0 ) UpperCAmelCase_ : List[Any] = pipe_prior( _UpperCamelCase , generator=_UpperCamelCase , num_inference_steps=5 , negative_prompt='' , ).to_tuple() UpperCAmelCase_ : Union[str, Any] = pipeline( _UpperCamelCase , image=_UpperCamelCase , image_embeds=_UpperCamelCase , negative_image_embeds=_UpperCamelCase , generator=_UpperCamelCase , num_inference_steps=1_0_0 , height=7_6_8 , width=7_6_8 , strength=0.2 , output_type='np' , ) UpperCAmelCase_ : Dict = output.images[0] assert image.shape == (7_6_8, 7_6_8, 3) assert_mean_pixel_difference(_UpperCamelCase , _UpperCamelCase )
29
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowerCamelCase__ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = ["ViTFeatureExtractor"] lowerCamelCase__ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowerCamelCase__ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
212
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
0
import os from typing import List, Optional, Union from ...image_processing_utils import BatchFeature from ...image_utils import ImageInput from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType from ..auto import AutoTokenizer class __a ( _a ): _a : Optional[int] = ["""image_processor""", """tokenizer"""] _a : Dict = """BlipImageProcessor""" _a : List[str] = """AutoTokenizer""" def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) -> List[Any]: """simple docstring""" super().__init__(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) # add QFormer tokenizer _UpperCAmelCase = qformer_tokenizer def __call__( self , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = True , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = 0 , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = True , _SCREAMING_SNAKE_CASE = None , **_SCREAMING_SNAKE_CASE , ) -> BatchFeature: """simple docstring""" if images is None and text is None: raise ValueError('You have to specify at least images or text.' ) _UpperCAmelCase = BatchFeature() if text is not None: _UpperCAmelCase = self.tokenizer( text=_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , pad_to_multiple_of=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , return_overflowing_tokens=_SCREAMING_SNAKE_CASE , return_special_tokens_mask=_SCREAMING_SNAKE_CASE , return_offsets_mapping=_SCREAMING_SNAKE_CASE , return_token_type_ids=_SCREAMING_SNAKE_CASE , return_length=_SCREAMING_SNAKE_CASE , verbose=_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE , ) encoding.update(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = self.qformer_tokenizer( text=_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE , padding=_SCREAMING_SNAKE_CASE , truncation=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE , stride=_SCREAMING_SNAKE_CASE , pad_to_multiple_of=_SCREAMING_SNAKE_CASE , return_attention_mask=_SCREAMING_SNAKE_CASE , return_overflowing_tokens=_SCREAMING_SNAKE_CASE , return_special_tokens_mask=_SCREAMING_SNAKE_CASE , return_offsets_mapping=_SCREAMING_SNAKE_CASE , return_token_type_ids=_SCREAMING_SNAKE_CASE , return_length=_SCREAMING_SNAKE_CASE , verbose=_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE , ) _UpperCAmelCase = qformer_text_encoding.pop('input_ids' ) _UpperCAmelCase = qformer_text_encoding.pop('attention_mask' ) if images is not None: _UpperCAmelCase = self.image_processor(_SCREAMING_SNAKE_CASE , return_tensors=_SCREAMING_SNAKE_CASE ) encoding.update(_SCREAMING_SNAKE_CASE ) return encoding def UpperCAmelCase__ ( self , *_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) -> int: """simple docstring""" return self.tokenizer.batch_decode(*_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self , *_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) -> int: """simple docstring""" return self.tokenizer.decode(*_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) @property # Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names def UpperCAmelCase__ ( self ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.tokenizer.model_input_names _UpperCAmelCase = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) -> Optional[Any]: """simple docstring""" if os.path.isfile(_SCREAMING_SNAKE_CASE ): raise ValueError(f'''Provided path ({save_directory}) should be a directory, not a file''' ) os.makedirs(_SCREAMING_SNAKE_CASE , exist_ok=_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = os.path.join(_SCREAMING_SNAKE_CASE , 'qformer_tokenizer' ) self.qformer_tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE ) return super().save_pretrained(_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) @classmethod def UpperCAmelCase__ ( cls , _SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) -> str: """simple docstring""" _UpperCAmelCase = AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE , subfolder='qformer_tokenizer' ) _UpperCAmelCase = cls._get_arguments_from_pretrained(_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE ) args.append(_SCREAMING_SNAKE_CASE ) return cls(*_SCREAMING_SNAKE_CASE )
329
import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" return MobileViTVaConfig( image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_act=self.hidden_act, conv_kernel_size=self.conv_kernel_size, output_stride=self.output_stride, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, width_multiplier=self.width_multiplier, ffn_dropout=self.ffn_dropout_prob, attn_dropout=self.attn_dropout_prob, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): self.assertListEqual( list(hidden_states[i].shape[-2:]), [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor], ) divisor *= 2 self.assertEqual(self.model_tester.output_stride, divisor // 2) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor( [ [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]], [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]], [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]], ], device=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
0
from ...utils import is_note_seq_available, is_transformers_available, is_torch_available from ...utils import OptionalDependencyNotAvailable try: if not (is_transformers_available() and is_torch_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .notes_encoder import SpectrogramNotesEncoder from .continous_encoder import SpectrogramContEncoder from .pipeline_spectrogram_diffusion import ( SpectrogramContEncoder, SpectrogramDiffusionPipeline, TaFilmDecoder, ) try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .midi_utils import MidiProcessor
187
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
0
'''simple docstring''' import itertools import random import unittest import numpy as np from transformers import BatchFeature, SpeechTaFeatureExtractor from transformers.testing_utils import require_torch from transformers.utils.import_utils import is_torch_available from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin if is_torch_available(): import torch __snake_case = random.Random() def a ( __a , __a=1.0 , __a=None , __a=None ) -> Any: '''simple docstring''' if rng is None: UpperCamelCase__ :Any = global_rng UpperCamelCase__ :Optional[Any] = [] for batch_idx in range(shape[0] ): values.append([] ) for _ in range(shape[1] ): values[-1].append(rng.random() * scale ) return values @require_torch class lowercase ( unittest.TestCase ): """simple docstring""" def __init__( self , UpperCamelCase_ , UpperCamelCase_=7 , UpperCamelCase_=400 , UpperCamelCase_=2000 , UpperCamelCase_=1 , UpperCamelCase_=0.0 , UpperCamelCase_=16000 , UpperCamelCase_=True , UpperCamelCase_=80 , UpperCamelCase_=16 , UpperCamelCase_=64 , UpperCamelCase_="hann_window" , UpperCamelCase_=80 , UpperCamelCase_=7600 , UpperCamelCase_=1e-10 , UpperCamelCase_=True , ): '''simple docstring''' UpperCamelCase__ :str = parent UpperCamelCase__ :List[Any] = batch_size UpperCamelCase__ :str = min_seq_length UpperCamelCase__ :Optional[Any] = max_seq_length UpperCamelCase__ :Dict = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1) UpperCamelCase__ :List[Any] = feature_size UpperCamelCase__ :Union[str, Any] = padding_value UpperCamelCase__ :Any = sampling_rate UpperCamelCase__ :Tuple = do_normalize UpperCamelCase__ :int = num_mel_bins UpperCamelCase__ :Tuple = hop_length UpperCamelCase__ :Any = win_length UpperCamelCase__ :int = win_function UpperCamelCase__ :Optional[Any] = fmin UpperCamelCase__ :List[str] = fmax UpperCamelCase__ :Tuple = mel_floor UpperCamelCase__ :Dict = return_attention_mask def lowerCAmelCase__ ( self ): '''simple docstring''' return { "feature_size": self.feature_size, "padding_value": self.padding_value, "sampling_rate": self.sampling_rate, "do_normalize": self.do_normalize, "num_mel_bins": self.num_mel_bins, "hop_length": self.hop_length, "win_length": self.win_length, "win_function": self.win_function, "fmin": self.fmin, "fmax": self.fmax, "mel_floor": self.mel_floor, "return_attention_mask": self.return_attention_mask, } def lowerCAmelCase__ ( self , UpperCamelCase_=False , UpperCamelCase_=False ): '''simple docstring''' def _flatten(UpperCamelCase_ ): return list(itertools.chain(*UpperCamelCase_ ) ) if equal_length: UpperCamelCase__ :Optional[int] = floats_list((self.batch_size, self.max_seq_length) ) else: # make sure that inputs increase in size UpperCamelCase__ :List[str] = [ _flatten(floats_list((x, self.feature_size) ) ) for x in range(self.min_seq_length , self.max_seq_length , self.seq_length_diff ) ] if numpify: UpperCamelCase__ :int = [np.asarray(UpperCamelCase_ ) for x in speech_inputs] return speech_inputs def lowerCAmelCase__ ( self , UpperCamelCase_=False , UpperCamelCase_=False ): '''simple docstring''' if equal_length: UpperCamelCase__ :int = [floats_list((self.max_seq_length, self.num_mel_bins) ) for _ in range(self.batch_size )] else: # make sure that inputs increase in size UpperCamelCase__ :Dict = [ floats_list((x, self.num_mel_bins) ) for x in range(self.min_seq_length , self.max_seq_length , self.seq_length_diff ) ] if numpify: UpperCamelCase__ :Optional[Any] = [np.asarray(UpperCamelCase_ ) for x in speech_inputs] return speech_inputs @require_torch class lowercase ( _a , unittest.TestCase ): """simple docstring""" _a = SpeechTaFeatureExtractor def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :str = SpeechTaFeatureExtractionTester(self ) def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' self.assertTrue(np.all(np.mean(UpperCamelCase_ , axis=0 ) < 1e-3 ) ) self.assertTrue(np.all(np.abs(np.var(UpperCamelCase_ , axis=0 ) - 1 ) < 1e-3 ) ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Tuple = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) # create three inputs of length 800, 1000, and 1200 UpperCamelCase__ :Dict = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :Any = [np.asarray(UpperCamelCase_ ) for speech_input in speech_inputs] # Test not batched input UpperCamelCase__ :Optional[Any] = feat_extract(speech_inputs[0] , return_tensors='''np''' ).input_values UpperCamelCase__ :Union[str, Any] = feat_extract(np_speech_inputs[0] , return_tensors='''np''' ).input_values self.assertTrue(np.allclose(UpperCamelCase_ , UpperCamelCase_ , atol=1e-3 ) ) # Test batched UpperCamelCase__ :int = feat_extract(UpperCamelCase_ , return_tensors='''np''' ).input_values UpperCamelCase__ :Tuple = feat_extract(UpperCamelCase_ , return_tensors='''np''' ).input_values for enc_seq_a, enc_seq_a in zip(UpperCamelCase_ , UpperCamelCase_ ): self.assertTrue(np.allclose(UpperCamelCase_ , UpperCamelCase_ , atol=1e-3 ) ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Tuple = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCamelCase__ :Union[str, Any] = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :str = ['longest', 'max_length', 'do_not_pad'] UpperCamelCase__ :List[str] = [None, 1600, None] for max_length, padding in zip(UpperCamelCase_ , UpperCamelCase_ ): UpperCamelCase__ :Any = feat_extract(UpperCamelCase_ , padding=UpperCamelCase_ , max_length=UpperCamelCase_ , return_tensors='''np''' ) UpperCamelCase__ :Optional[Any] = processed.input_values self._check_zero_mean_unit_variance(input_values[0][:800] ) self.assertTrue(input_values[0][800:].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_values[1][:1000] ) self.assertTrue(input_values[0][1000:].sum() < 1e-6 ) self._check_zero_mean_unit_variance(input_values[2][:1200] ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCamelCase__ :Tuple = range(800 , 1400 , 200 ) UpperCamelCase__ :Optional[int] = [floats_list((1, x) )[0] for x in lengths] UpperCamelCase__ :Optional[Any] = ['longest', 'max_length', 'do_not_pad'] UpperCamelCase__ :Optional[int] = [None, 1600, None] for max_length, padding in zip(UpperCamelCase_ , UpperCamelCase_ ): UpperCamelCase__ :Union[str, Any] = feat_extract(UpperCamelCase_ , max_length=UpperCamelCase_ , padding=UpperCamelCase_ ) UpperCamelCase__ :List[Any] = processed.input_values self._check_zero_mean_unit_variance(input_values[0][:800] ) self._check_zero_mean_unit_variance(input_values[1][:1000] ) self._check_zero_mean_unit_variance(input_values[2][:1200] ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCamelCase__ :Dict = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :Union[str, Any] = feat_extract( UpperCamelCase_ , truncation=UpperCamelCase_ , max_length=1000 , padding='''max_length''' , return_tensors='''np''' ) UpperCamelCase__ :List[str] = processed.input_values self._check_zero_mean_unit_variance(input_values[0, :800] ) self._check_zero_mean_unit_variance(input_values[1] ) self._check_zero_mean_unit_variance(input_values[2] ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[int] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCamelCase__ :Optional[Any] = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :int = feat_extract( UpperCamelCase_ , truncation=UpperCamelCase_ , max_length=1000 , padding='''longest''' , return_tensors='''np''' ) UpperCamelCase__ :Dict = processed.input_values self._check_zero_mean_unit_variance(input_values[0, :800] ) self._check_zero_mean_unit_variance(input_values[1, :1000] ) self._check_zero_mean_unit_variance(input_values[2] ) # make sure that if max_length < longest -> then pad to max_length self.assertTrue(input_values.shape == (3, 1000) ) UpperCamelCase__ :Optional[int] = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :Any = feat_extract( UpperCamelCase_ , truncation=UpperCamelCase_ , max_length=2000 , padding='''longest''' , return_tensors='''np''' ) UpperCamelCase__ :List[str] = processed.input_values self._check_zero_mean_unit_variance(input_values[0, :800] ) self._check_zero_mean_unit_variance(input_values[1, :1000] ) self._check_zero_mean_unit_variance(input_values[2] ) # make sure that if max_length > longest -> then pad to longest self.assertTrue(input_values.shape == (3, 1200) ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) UpperCamelCase__ :Optional[Any] = np.random.rand(100 ).astype(np.floataa ) UpperCamelCase__ :Any = np_speech_inputs.tolist() for inputs in [py_speech_inputs, np_speech_inputs]: UpperCamelCase__ :List[str] = feature_extractor.pad([{'''input_values''': inputs}] , return_tensors='''np''' ) self.assertTrue(np_processed.input_values.dtype == np.floataa ) UpperCamelCase__ :List[str] = feature_extractor.pad([{'''input_values''': inputs}] , return_tensors='''pt''' ) self.assertTrue(pt_processed.input_values.dtype == torch.floataa ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() ) # create three inputs of length 800, 1000, and 1200 UpperCamelCase__ :List[str] = [floats_list((1, x) )[0] for x in range(800 , 1400 , 200 )] UpperCamelCase__ :Optional[int] = [np.asarray(UpperCamelCase_ ) for speech_input in speech_inputs] # Test feature size UpperCamelCase__ :Optional[int] = feature_extractor(audio_target=UpperCamelCase_ , padding=UpperCamelCase_ , return_tensors='''np''' ).input_values self.assertTrue(input_values.ndim == 3 ) self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins ) # Test not batched input UpperCamelCase__ :Union[str, Any] = feature_extractor(speech_inputs[0] , return_tensors='''np''' ).input_values UpperCamelCase__ :Tuple = feature_extractor(np_speech_inputs[0] , return_tensors='''np''' ).input_values self.assertTrue(np.allclose(UpperCamelCase_ , UpperCamelCase_ , atol=1e-3 ) ) # Test batched UpperCamelCase__ :int = feature_extractor(UpperCamelCase_ , return_tensors='''np''' ).input_values UpperCamelCase__ :Union[str, Any] = feature_extractor(UpperCamelCase_ , return_tensors='''np''' ).input_values for enc_seq_a, enc_seq_a in zip(UpperCamelCase_ , UpperCamelCase_ ): self.assertTrue(np.allclose(UpperCamelCase_ , UpperCamelCase_ , atol=1e-3 ) ) # Test 2-D numpy arrays are batched. UpperCamelCase__ :List[Any] = [floats_list((1, x) )[0] for x in (800, 800, 800)] UpperCamelCase__ :Tuple = np.asarray(UpperCamelCase_ ) UpperCamelCase__ :int = feature_extractor(UpperCamelCase_ , return_tensors='''np''' ).input_values UpperCamelCase__ :List[str] = feature_extractor(UpperCamelCase_ , return_tensors='''np''' ).input_values for enc_seq_a, enc_seq_a in zip(UpperCamelCase_ , UpperCamelCase_ ): self.assertTrue(np.allclose(UpperCamelCase_ , UpperCamelCase_ , atol=1e-3 ) ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Tuple = self.feat_extract_tester.prepare_inputs_for_target() UpperCamelCase__ :str = self.feature_extraction_class(**self.feat_extract_dict ) UpperCamelCase__ :str = feat_extract.model_input_names[0] UpperCamelCase__ :int = BatchFeature({input_name: speech_inputs} ) self.assertTrue(all(len(UpperCamelCase_ ) == len(UpperCamelCase_ ) for x, y in zip(UpperCamelCase_ , processed_features[input_name] ) ) ) UpperCamelCase__ :List[str] = self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase_ ) UpperCamelCase__ :Dict = BatchFeature({input_name: speech_inputs} , tensor_type='''np''' ) UpperCamelCase__ :List[str] = processed_features[input_name] if len(batch_features_input.shape ) < 3: UpperCamelCase__ :Optional[int] = batch_features_input[:, :, None] self.assertTrue( batch_features_input.shape == (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.num_mel_bins) ) @require_torch def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[int] = self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCamelCase_ ) UpperCamelCase__ :str = self.feature_extraction_class(**self.feat_extract_dict ) UpperCamelCase__ :Optional[int] = feat_extract.model_input_names[0] UpperCamelCase__ :str = BatchFeature({input_name: speech_inputs} , tensor_type='''pt''' ) UpperCamelCase__ :str = processed_features[input_name] if len(batch_features_input.shape ) < 3: UpperCamelCase__ :Tuple = batch_features_input[:, :, None] self.assertTrue( batch_features_input.shape == (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.num_mel_bins) ) @require_torch def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = self.feature_extraction_class(**self.feat_extract_dict ) UpperCamelCase__ :str = self.feat_extract_tester.prepare_inputs_for_target() UpperCamelCase__ :Any = feat_extract.model_input_names[0] UpperCamelCase__ :Union[str, Any] = BatchFeature({input_name: speech_inputs} ) UpperCamelCase__ :List[str] = feat_extract.num_mel_bins # hack! UpperCamelCase__ :int = feat_extract.pad(UpperCamelCase_ , padding='''longest''' , return_tensors='''np''' )[input_name] UpperCamelCase__ :List[str] = feat_extract.pad(UpperCamelCase_ , padding='''longest''' , return_tensors='''pt''' )[input_name] self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_pt.numpy().astype(np.floataa ).sum() ) < 1e-2 ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = self.feat_extract_dict UpperCamelCase__ :int = True UpperCamelCase__ :Optional[int] = self.feature_extraction_class(**UpperCamelCase_ ) UpperCamelCase__ :int = self.feat_extract_tester.prepare_inputs_for_target() UpperCamelCase__ :List[str] = [len(UpperCamelCase_ ) for x in speech_inputs] UpperCamelCase__ :Dict = feat_extract.model_input_names[0] UpperCamelCase__ :Tuple = BatchFeature({input_name: speech_inputs} ) UpperCamelCase__ :Tuple = feat_extract.num_mel_bins # hack! UpperCamelCase__ :Union[str, Any] = feat_extract.pad(UpperCamelCase_ , padding='''longest''' , return_tensors='''np''' ) self.assertIn('''attention_mask''' , UpperCamelCase_ ) self.assertListEqual(list(processed.attention_mask.shape ) , list(processed[input_name].shape[:2] ) ) self.assertListEqual(processed.attention_mask.sum(-1 ).tolist() , UpperCamelCase_ ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :int = self.feat_extract_dict UpperCamelCase__ :int = True UpperCamelCase__ :Dict = self.feature_extraction_class(**UpperCamelCase_ ) UpperCamelCase__ :Union[str, Any] = self.feat_extract_tester.prepare_inputs_for_target() UpperCamelCase__ :List[Any] = [len(UpperCamelCase_ ) for x in speech_inputs] UpperCamelCase__ :List[str] = feat_extract.model_input_names[0] UpperCamelCase__ :Optional[Any] = BatchFeature({input_name: speech_inputs} ) UpperCamelCase__ :Dict = min(UpperCamelCase_ ) UpperCamelCase__ :Optional[int] = feat_extract.num_mel_bins # hack! UpperCamelCase__ :Optional[int] = feat_extract.pad( UpperCamelCase_ , padding='''max_length''' , max_length=UpperCamelCase_ , truncation=UpperCamelCase_ , return_tensors='''np''' ) self.assertIn('''attention_mask''' , UpperCamelCase_ ) self.assertListEqual( list(processed_pad.attention_mask.shape ) , [processed_pad[input_name].shape[0], max_length] ) self.assertListEqual( processed_pad.attention_mask[:, :max_length].sum(-1 ).tolist() , [max_length for x in speech_inputs] ) def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' from datasets import load_dataset UpperCamelCase__ :Union[str, Any] = load_dataset('''hf-internal-testing/librispeech_asr_dummy''' , '''clean''' , split='''validation''' ) # automatic decoding with librispeech UpperCamelCase__ :List[Any] = ds.sort('''id''' ).select(range(UpperCamelCase_ ) )[:num_samples]['audio'] return [x["array"] for x in speech_samples] def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = torch.tensor( [2.38_04e-03, 2.07_52e-03, 1.98_36e-03, 2.10_57e-03, 1.61_74e-03, 3.05_18e-04, 9.15_53e-05, 3.35_69e-04, 9.76_56e-04, 1.83_11e-03, 2.01_42e-03, 2.10_57e-03, 1.73_95e-03, 4.57_76e-04, -3.96_73e-04, 4.57_76e-04, 1.00_71e-03, 9.15_53e-05, 4.88_28e-04, 1.15_97e-03, 7.32_42e-04, 9.46_04e-04, 1.80_05e-03, 1.83_11e-03, 8.85_01e-04, 4.27_25e-04, 4.88_28e-04, 7.32_42e-04, 1.09_86e-03, 2.10_57e-03] ) # fmt: on UpperCamelCase__ :List[str] = self._load_datasamples(1 ) UpperCamelCase__ :Any = SpeechTaFeatureExtractor() UpperCamelCase__ :Union[str, Any] = feature_extractor(UpperCamelCase_ , return_tensors='''pt''' ).input_values self.assertEquals(input_values.shape , (1, 93680) ) self.assertTrue(torch.allclose(input_values[0, :30] , UpperCamelCase_ , atol=1e-6 ) ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[Any] = torch.tensor( [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777, -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386, -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571, -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998] ) # fmt: on UpperCamelCase__ :Optional[int] = self._load_datasamples(1 ) UpperCamelCase__ :str = SpeechTaFeatureExtractor() UpperCamelCase__ :Any = feature_extractor(audio_target=UpperCamelCase_ , return_tensors='''pt''' ).input_values self.assertEquals(input_values.shape , (1, 366, 80) ) self.assertTrue(torch.allclose(input_values[0, 0, :30] , UpperCamelCase_ , atol=1e-4 ) )
97
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
0
"""simple docstring""" def __A (_SCREAMING_SNAKE_CASE ) ->list[int]: """simple docstring""" if length <= 0 or not isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise ValueError('Length must be a positive integer.' ) return [n * (2 * n - 1) for n in range(lowerCamelCase_ )] if __name__ == "__main__": print(hexagonal_numbers(length=5)) print(hexagonal_numbers(length=10))
293
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowerCAmelCase = { "configuration_blenderbot": [ "BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP", "BlenderbotConfig", "BlenderbotOnnxConfig", ], "tokenization_blenderbot": ["BlenderbotTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase = ["BlenderbotTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase = [ "BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotForCausalLM", "BlenderbotForConditionalGeneration", "BlenderbotModel", "BlenderbotPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase = [ "TFBlenderbotForConditionalGeneration", "TFBlenderbotModel", "TFBlenderbotPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase = [ "FlaxBlenderbotForConditionalGeneration", "FlaxBlenderbotModel", "FlaxBlenderbotPreTrainedModel", ] if TYPE_CHECKING: from .configuration_blenderbot import ( BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotConfig, BlenderbotOnnxConfig, ) from .tokenization_blenderbot import BlenderbotTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_fast import BlenderbotTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot import ( BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel, BlenderbotPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot import ( TFBlenderbotForConditionalGeneration, TFBlenderbotModel, TFBlenderbotPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, FlaxBlenderbotPreTrainedModel, ) else: import sys lowerCAmelCase = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
126
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
0
from typing import List, Optional, Tuple, Union import torch from ...utils import logging, randn_tensor from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) # pylint: disable=invalid-name class SCREAMING_SNAKE_CASE_ ( _a ): def __init__( self : int , lowerCamelCase_ : str , lowerCamelCase_ : Dict ): """simple docstring""" super().__init__() self.register_modules(unet=lowerCamelCase_ , scheduler=lowerCamelCase_ ) @torch.no_grad() def __call__( self : Tuple , lowerCamelCase_ : Optional[int] = 1 , lowerCamelCase_ : Optional[Any] = 100 , lowerCamelCase_ : Tuple = None , lowerCamelCase_ : Any = None , lowerCamelCase_ : Tuple = True , ): """simple docstring""" if audio_length_in_s is None: UpperCamelCase = self.unet.config.sample_size / self.unet.config.sample_rate UpperCamelCase = audio_length_in_s * self.unet.config.sample_rate UpperCamelCase = 2 ** len(self.unet.up_blocks ) if sample_size < 3 * down_scale_factor: raise ValueError( f"""{audio_length_in_s} is too small. Make sure it\'s bigger or equal to""" f""" {3 * down_scale_factor / self.unet.config.sample_rate}.""" ) UpperCamelCase = int(lowerCamelCase_ ) if sample_size % down_scale_factor != 0: UpperCamelCase = ( (audio_length_in_s * self.unet.config.sample_rate) // down_scale_factor + 1 ) * down_scale_factor logger.info( f"""{audio_length_in_s} is increased to {sample_size / self.unet.config.sample_rate} so that it can be handled""" f""" by the model. It will be cut to {original_sample_size / self.unet.config.sample_rate} after the denoising""" """ process.""" ) UpperCamelCase = int(lowerCamelCase_ ) UpperCamelCase = next(iter(self.unet.parameters() ) ).dtype UpperCamelCase = (batch_size, self.unet.config.in_channels, sample_size) if isinstance(lowerCamelCase_ , lowerCamelCase_ ) and len(lowerCamelCase_ ) != batch_size: raise ValueError( f"""You have passed a list of generators of length {len(lowerCamelCase_ )}, but requested an effective batch""" f""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) UpperCamelCase = randn_tensor(lowerCamelCase_ , generator=lowerCamelCase_ , device=self.device , dtype=lowerCamelCase_ ) # set step values self.scheduler.set_timesteps(lowerCamelCase_ , device=audio.device ) UpperCamelCase = self.scheduler.timesteps.to(lowerCamelCase_ ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output UpperCamelCase = self.unet(lowerCamelCase_ , lowerCamelCase_ ).sample # 2. compute previous image: x_t -> t_t-1 UpperCamelCase = self.scheduler.step(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ).prev_sample UpperCamelCase = audio.clamp(-1 , 1 ).float().cpu().numpy() UpperCamelCase = audio[:, :, :original_sample_size] if not return_dict: return (audio,) return AudioPipelineOutput(audios=lowerCamelCase_ )
343
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
0
import inspect import math import tempfile import unittest import numpy as np from transformers import ViTMAEConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTMAEForPreTraining, ViTMAEModel from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class _A: """simple docstring""" def __init__( self , _A , _A=13 , _A=30 , _A=2 , _A=3 , _A=True , _A=True , _A=32 , _A=5 , _A=4 , _A=37 , _A="gelu" , _A=0.1 , _A=0.1 , _A=10 , _A=0.0_2 , _A=3 , _A=0.6 , _A=None , ): __A : str = parent __A : Union[str, Any] = batch_size __A : Dict = image_size __A : Optional[Any] = patch_size __A : List[Any] = num_channels __A : Union[str, Any] = is_training __A : Dict = use_labels __A : List[str] = hidden_size __A : Union[str, Any] = num_hidden_layers __A : List[str] = num_attention_heads __A : Tuple = intermediate_size __A : List[str] = hidden_act __A : Dict = hidden_dropout_prob __A : str = attention_probs_dropout_prob __A : List[str] = type_sequence_label_size __A : Union[str, Any] = initializer_range __A : int = mask_ratio __A : List[str] = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) __A : str = (image_size // patch_size) ** 2 __A : List[str] = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) ) def UpperCAmelCase_ ( self ): __A : Union[str, Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __A : int = None if self.use_labels: __A : List[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __A : Optional[int] = self.get_config() return config, pixel_values, labels def UpperCAmelCase_ ( self ): return ViTMAEConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=_A , initializer_range=self.initializer_range , mask_ratio=self.mask_ratio , ) def UpperCAmelCase_ ( self , _A , _A , _A ): __A : Tuple = ViTMAEModel(config=_A ) model.to(_A ) model.eval() __A : Tuple = model(_A ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCAmelCase_ ( self , _A , _A , _A ): __A : List[Any] = ViTMAEForPreTraining(_A ) model.to(_A ) model.eval() __A : Optional[int] = model(_A ) __A : int = (self.image_size // self.patch_size) ** 2 __A : List[str] = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape , (self.batch_size, num_patches, expected_num_channels) ) # test greyscale images __A : Tuple = 1 __A : Any = ViTMAEForPreTraining(_A ) model.to(_A ) model.eval() __A : Optional[Any] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) __A : Dict = model(_A ) __A : List[str] = self.patch_size**2 self.parent.assertEqual(result.logits.shape , (self.batch_size, num_patches, expected_num_channels) ) def UpperCAmelCase_ ( self ): __A : Dict = self.prepare_config_and_inputs() __A : Tuple = config_and_inputs __A : Any = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _A( _a , _a , unittest.TestCase ): """simple docstring""" UpperCamelCase : Optional[Any] = (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else () UpperCamelCase : str = {"""feature-extraction""": ViTMAEModel} if is_torch_available() else {} UpperCamelCase : Optional[int] = False UpperCamelCase : List[str] = False UpperCamelCase : Dict = False UpperCamelCase : List[str] = False def UpperCAmelCase_ ( self ): __A : List[Any] = ViTMAEModelTester(self ) __A : Union[str, Any] = ConfigTester(self , config_class=_A , has_text_modality=_A , hidden_size=37 ) def UpperCAmelCase_ ( self ): self.config_tester.run_common_tests() @unittest.skip(reason='ViTMAE does not use inputs_embeds' ) def UpperCAmelCase_ ( self ): pass def UpperCAmelCase_ ( self ): __A : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __A : Union[str, Any] = model_class(_A ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) __A : str = model.get_output_embeddings() self.assertTrue(x is None or isinstance(_A , nn.Linear ) ) def UpperCAmelCase_ ( self ): __A : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __A : Optional[int] = model_class(_A ) __A : Union[str, Any] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __A : Optional[Any] = [*signature.parameters.keys()] __A : Optional[Any] = ['pixel_values'] self.assertListEqual(arg_names[:1] , _A ) def UpperCAmelCase_ ( self ): __A : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_A ) def UpperCAmelCase_ ( self ): __A : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*_A ) def UpperCAmelCase_ ( self , _A , _A , _A ): np.random.seed(2 ) __A : Optional[Any] = int((pt_model.config.image_size // pt_model.config.patch_size) ** 2 ) __A : Optional[int] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) __A : List[str] = torch.from_numpy(_A ) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument __A : List[str] = pt_noise super().check_pt_tf_models(_A , _A , _A ) def UpperCAmelCase_ ( self ): __A : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __A : Any = model_class(_A ) model.to(_A ) model.eval() # make random mask reproducible torch.manual_seed(2 ) with torch.no_grad(): __A : List[str] = model(**self._prepare_for_class(_A , _A ) ) __A : str = outputs[0].cpu().numpy() __A : List[str] = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(_A ) __A : Tuple = model_class.from_pretrained(_A ) model.to(_A ) # make random mask reproducible torch.manual_seed(2 ) with torch.no_grad(): __A : Optional[int] = model(**self._prepare_for_class(_A , _A ) ) # Make sure we don't have nans __A : Tuple = after_outputs[0].cpu().numpy() __A : List[Any] = 0 __A : Any = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(_A , 1e-5 ) @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def UpperCAmelCase_ ( self ): pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def UpperCAmelCase_ ( self ): pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def UpperCAmelCase_ ( self ): pass @unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load' ) def UpperCAmelCase_ ( self ): pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def UpperCAmelCase_ ( self ): pass @slow def UpperCAmelCase_ ( self ): for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __A : Tuple = ViTMAEModel.from_pretrained(_A ) self.assertIsNotNone(_A ) def _SCREAMING_SNAKE_CASE ( ) -> Tuple: __A : int = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _A( unittest.TestCase ): """simple docstring""" @cached_property def UpperCAmelCase_ ( self ): return ViTImageProcessor.from_pretrained('facebook/vit-mae-base' ) if is_vision_available() else None @slow def UpperCAmelCase_ ( self ): np.random.seed(2 ) __A : Dict = ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base' ).to(_A ) __A : int = self.default_image_processor __A : List[Any] = prepare_img() __A : List[Any] = image_processor(images=_A , return_tensors='pt' ).to(_A ) # prepare a noise vector that will be also used for testing the TF model # (this way we can ensure that the PT and TF models operate on the same inputs) __A : Optional[Any] = ViTMAEConfig() __A : Dict = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 ) __A : Dict = np.random.uniform(size=(1, num_patches) ) # forward pass with torch.no_grad(): __A : List[Any] = model(**_A , noise=torch.from_numpy(_A ).to(device=_A ) ) # verify the logits __A : Optional[Any] = torch.Size((1, 196, 768) ) self.assertEqual(outputs.logits.shape , _A ) __A : Any = torch.tensor( [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]] ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , expected_slice.to(_A ) , atol=1e-4 ) )
280
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
0
"""simple docstring""" import json import os import sys import tempfile import unittest from pathlib import Path from shutil import copyfile from huggingface_hub import HfFolder, Repository, create_repo, delete_repo from requests.exceptions import HTTPError import transformers from transformers import ( CONFIG_MAPPING, FEATURE_EXTRACTOR_MAPPING, PROCESSOR_MAPPING, TOKENIZER_MAPPING, AutoConfig, AutoFeatureExtractor, AutoProcessor, AutoTokenizer, BertTokenizer, ProcessorMixin, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaProcessor, ) from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils""")) from test_module.custom_configuration import CustomConfig # noqa E402 from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 from test_module.custom_processing import CustomProcessor # noqa E402 from test_module.custom_tokenization import CustomTokenizer # noqa E402 _UpperCAmelCase = get_tests_dir("""fixtures/dummy_feature_extractor_config.json""") _UpperCAmelCase = get_tests_dir("""fixtures/vocab.json""") _UpperCAmelCase = get_tests_dir("""fixtures""") class a ( unittest.TestCase ): UpperCamelCase : Optional[int] = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""] def lowerCamelCase__ ( self : str ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Optional[int] =0 def lowerCamelCase__ ( self : int ) -> List[str]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Optional[int] =AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : Tuple ) -> Union[str, Any]: '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE_: Union[str, Any] =WavaVecaConfig() SCREAMING_SNAKE_CASE_: int =AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) # save in new folder model_config.save_pretrained(lowerCAmelCase ) processor.save_pretrained(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Optional[int] =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : Optional[Any] ) -> Any: '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: # copy relevant files copyfile(lowerCAmelCase , os.path.join(lowerCAmelCase , lowerCAmelCase ) ) copyfile(lowerCAmelCase , os.path.join(lowerCAmelCase , """vocab.json""" ) ) SCREAMING_SNAKE_CASE_: Optional[Any] =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : Tuple ) -> Optional[Any]: '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE_: Any =WavaVecaFeatureExtractor() SCREAMING_SNAKE_CASE_: int =AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) SCREAMING_SNAKE_CASE_: List[Any] =WavaVecaProcessor(lowerCAmelCase , lowerCAmelCase ) # save in new folder processor.save_pretrained(lowerCAmelCase ) # drop `processor_class` in tokenizer with open(os.path.join(lowerCAmelCase , lowerCAmelCase ) , """r""" ) as f: SCREAMING_SNAKE_CASE_: Union[str, Any] =json.load(lowerCAmelCase ) config_dict.pop("""processor_class""" ) with open(os.path.join(lowerCAmelCase , lowerCAmelCase ) , """w""" ) as f: f.write(json.dumps(lowerCAmelCase ) ) SCREAMING_SNAKE_CASE_: Any =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : int ) -> int: '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE_: List[str] =WavaVecaFeatureExtractor() SCREAMING_SNAKE_CASE_: int =AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) SCREAMING_SNAKE_CASE_: Optional[Any] =WavaVecaProcessor(lowerCAmelCase , lowerCAmelCase ) # save in new folder processor.save_pretrained(lowerCAmelCase ) # drop `processor_class` in feature extractor with open(os.path.join(lowerCAmelCase , lowerCAmelCase ) , """r""" ) as f: SCREAMING_SNAKE_CASE_: Optional[Any] =json.load(lowerCAmelCase ) config_dict.pop("""processor_class""" ) with open(os.path.join(lowerCAmelCase , lowerCAmelCase ) , """w""" ) as f: f.write(json.dumps(lowerCAmelCase ) ) SCREAMING_SNAKE_CASE_: Optional[Any] =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : Tuple ) -> Optional[Any]: '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE_: str =WavaVecaConfig(processor_class="""Wav2Vec2Processor""" ) model_config.save_pretrained(lowerCAmelCase ) # copy relevant files copyfile(lowerCAmelCase , os.path.join(lowerCAmelCase , """vocab.json""" ) ) # create emtpy sample processor with open(os.path.join(lowerCAmelCase , lowerCAmelCase ) , """w""" ) as f: f.write("""{}""" ) SCREAMING_SNAKE_CASE_: Optional[Any] =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) def lowerCamelCase__ ( self : Union[str, Any] ) -> Optional[int]: '''simple docstring''' with self.assertRaises(lowerCAmelCase ): SCREAMING_SNAKE_CASE_: Dict =AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(lowerCAmelCase ): SCREAMING_SNAKE_CASE_: str =AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Optional[Any] =AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" , trust_remote_code=lowerCAmelCase ) self.assertTrue(processor.special_attribute_present ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) SCREAMING_SNAKE_CASE_: int =processor.feature_extractor self.assertTrue(feature_extractor.special_attribute_present ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) SCREAMING_SNAKE_CASE_: Union[str, Any] =processor.tokenizer self.assertTrue(tokenizer.special_attribute_present ) if is_tokenizers_available(): self.assertEqual(tokenizer.__class__.__name__ , """NewTokenizerFast""" ) # Test we can also load the slow version SCREAMING_SNAKE_CASE_: str =AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=lowerCAmelCase , use_fast=lowerCAmelCase ) SCREAMING_SNAKE_CASE_: int =new_processor.tokenizer self.assertTrue(new_tokenizer.special_attribute_present ) self.assertEqual(new_tokenizer.__class__.__name__ , """NewTokenizer""" ) else: self.assertEqual(tokenizer.__class__.__name__ , """NewTokenizer""" ) def lowerCamelCase__ ( self : Union[str, Any] ) -> List[str]: '''simple docstring''' try: AutoConfig.register("""custom""" , lowerCAmelCase ) AutoFeatureExtractor.register(lowerCAmelCase , lowerCAmelCase ) AutoTokenizer.register(lowerCAmelCase , slow_tokenizer_class=lowerCAmelCase ) AutoProcessor.register(lowerCAmelCase , lowerCAmelCase ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(lowerCAmelCase ): AutoProcessor.register(lowerCAmelCase , lowerCAmelCase ) # Now that the config is registered, it can be used as any other config with the auto-API SCREAMING_SNAKE_CASE_: Union[str, Any] =CustomFeatureExtractor.from_pretrained(lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE_: List[str] =os.path.join(lowerCAmelCase , """vocab.txt""" ) with open(lowerCAmelCase , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE_: Optional[int] =CustomTokenizer(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: int =CustomProcessor(lowerCAmelCase , lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Optional[int] =AutoProcessor.from_pretrained(lowerCAmelCase ) self.assertIsInstance(lowerCAmelCase , lowerCAmelCase ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def lowerCamelCase__ ( self : Tuple ) -> Dict: '''simple docstring''' class a ( _a ): UpperCamelCase : List[str] = False class a ( _a ): UpperCamelCase : Optional[Any] = False class a ( _a ): UpperCamelCase : Any = """AutoFeatureExtractor""" UpperCamelCase : Tuple = """AutoTokenizer""" UpperCamelCase : int = False try: AutoConfig.register("""custom""" , lowerCAmelCase ) AutoFeatureExtractor.register(lowerCAmelCase , lowerCAmelCase ) AutoTokenizer.register(lowerCAmelCase , slow_tokenizer_class=lowerCAmelCase ) AutoProcessor.register(lowerCAmelCase , lowerCAmelCase ) # If remote code is not set, the default is to use local classes. SCREAMING_SNAKE_CASE_: int =AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote code is disabled, we load the local ones. SCREAMING_SNAKE_CASE_: Tuple =AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=lowerCAmelCase ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote is enabled, we load from the Hub. SCREAMING_SNAKE_CASE_: int =AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=lowerCAmelCase ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertTrue(processor.special_attribute_present ) self.assertTrue(processor.feature_extractor.special_attribute_present ) self.assertTrue(processor.tokenizer.special_attribute_present ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def lowerCamelCase__ ( self : Tuple ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Any =AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-bert""" ) self.assertEqual(processor.__class__.__name__ , """BertTokenizerFast""" ) def lowerCamelCase__ ( self : List[Any] ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE_: List[str] =AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-convnext""" ) self.assertEqual(processor.__class__.__name__ , """ConvNextImageProcessor""" ) @is_staging_test class a ( unittest.TestCase ): UpperCamelCase : Optional[int] = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""] @classmethod def lowerCamelCase__ ( cls : Optional[Any] ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE_: int =TOKEN HfFolder.save_token(lowerCAmelCase ) @classmethod def lowerCamelCase__ ( cls : Dict ) -> Optional[int]: '''simple docstring''' try: delete_repo(token=cls._token , repo_id="""test-processor""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""valid_org/test-processor-org""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""test-dynamic-processor""" ) except HTTPError: pass def lowerCamelCase__ ( self : Dict ) -> Tuple: '''simple docstring''' SCREAMING_SNAKE_CASE_: Tuple =WavaVecaProcessor.from_pretrained(lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(lowerCAmelCase , """test-processor""" ) , push_to_hub=lowerCAmelCase , use_auth_token=self._token ) SCREAMING_SNAKE_CASE_: Tuple =WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor''' ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(lowerCAmelCase , getattr(new_processor.feature_extractor , lowerCAmelCase ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() , processor.tokenizer.get_vocab() ) def lowerCamelCase__ ( self : List[Any] ) -> int: '''simple docstring''' SCREAMING_SNAKE_CASE_: List[Any] =WavaVecaProcessor.from_pretrained(lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(lowerCAmelCase , """test-processor-org""" ) , push_to_hub=lowerCAmelCase , use_auth_token=self._token , organization="""valid_org""" , ) SCREAMING_SNAKE_CASE_: Union[str, Any] =WavaVecaProcessor.from_pretrained("""valid_org/test-processor-org""" ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(lowerCAmelCase , getattr(new_processor.feature_extractor , lowerCAmelCase ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() , processor.tokenizer.get_vocab() ) def lowerCamelCase__ ( self : Optional[int] ) -> Any: '''simple docstring''' CustomFeatureExtractor.register_for_auto_class() CustomTokenizer.register_for_auto_class() CustomProcessor.register_for_auto_class() SCREAMING_SNAKE_CASE_: int =CustomFeatureExtractor.from_pretrained(lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE_: Optional[int] =os.path.join(lowerCAmelCase , """vocab.txt""" ) with open(lowerCAmelCase , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE_: Tuple =CustomTokenizer(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Union[str, Any] =CustomProcessor(lowerCAmelCase , lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: create_repo(f'''{USER}/test-dynamic-processor''' , token=self._token ) SCREAMING_SNAKE_CASE_: Dict =Repository(lowerCAmelCase , clone_from=f'''{USER}/test-dynamic-processor''' , token=self._token ) processor.save_pretrained(lowerCAmelCase ) # This has added the proper auto_map field to the feature extractor config self.assertDictEqual( processor.feature_extractor.auto_map , { """AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor""", """AutoProcessor""": """custom_processing.CustomProcessor""", } , ) # This has added the proper auto_map field to the tokenizer config with open(os.path.join(lowerCAmelCase , """tokenizer_config.json""" ) ) as f: SCREAMING_SNAKE_CASE_: int =json.load(lowerCAmelCase ) self.assertDictEqual( tokenizer_config["""auto_map"""] , { """AutoTokenizer""": ["""custom_tokenization.CustomTokenizer""", None], """AutoProcessor""": """custom_processing.CustomProcessor""", } , ) # The code has been copied from fixtures self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase , """custom_feature_extraction.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase , """custom_tokenization.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase , """custom_processing.py""" ) ) ) repo.push_to_hub() SCREAMING_SNAKE_CASE_: List[str] =AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor''' , trust_remote_code=lowerCAmelCase ) # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module self.assertEqual(new_processor.__class__.__name__ , """CustomProcessor""" )
173
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import warnings from typing import List, Optional, Union from ...image_utils import ImageInput from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType class __A ( _a ): '''simple docstring''' lowerCAmelCase_ = ["""image_processor""", """tokenizer"""] lowerCAmelCase_ = """FlavaImageProcessor""" lowerCAmelCase_ = ("""BertTokenizer""", """BertTokenizerFast""") def __init__( self , __lowerCAmelCase=None , __lowerCAmelCase=None , **__lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = None if "feature_extractor" in kwargs: warnings.warn( '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`''' ''' instead.''' , __lowerCAmelCase , ) lowerCamelCase__ = kwargs.pop('''feature_extractor''' ) lowerCamelCase__ = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError('''You need to specify an `image_processor`.''' ) if tokenizer is None: raise ValueError('''You need to specify a `tokenizer`.''' ) super().__init__(__lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = self.image_processor def __call__( self , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = True , __lowerCAmelCase = False , __lowerCAmelCase = False , __lowerCAmelCase = None , __lowerCAmelCase = 0 , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = False , __lowerCAmelCase = False , __lowerCAmelCase = False , __lowerCAmelCase = False , __lowerCAmelCase = True , __lowerCAmelCase = None , **__lowerCAmelCase , ): '''simple docstring''' if text is None and images is None: raise ValueError('''You have to specify either text or images. Both cannot be none.''' ) if text is not None: lowerCamelCase__ = self.tokenizer( text=__lowerCAmelCase , add_special_tokens=__lowerCAmelCase , padding=__lowerCAmelCase , truncation=__lowerCAmelCase , max_length=__lowerCAmelCase , stride=__lowerCAmelCase , pad_to_multiple_of=__lowerCAmelCase , return_token_type_ids=__lowerCAmelCase , return_attention_mask=__lowerCAmelCase , return_overflowing_tokens=__lowerCAmelCase , return_special_tokens_mask=__lowerCAmelCase , return_offsets_mapping=__lowerCAmelCase , return_length=__lowerCAmelCase , verbose=__lowerCAmelCase , return_tensors=__lowerCAmelCase , **__lowerCAmelCase , ) if images is not None: lowerCamelCase__ = self.image_processor( __lowerCAmelCase , return_image_mask=__lowerCAmelCase , return_codebook_pixels=__lowerCAmelCase , return_tensors=__lowerCAmelCase , **__lowerCAmelCase , ) if text is not None and images is not None: encoding.update(__lowerCAmelCase ) return encoding elif text is not None: return encoding else: return BatchEncoding(data=dict(**__lowerCAmelCase ) , tensor_type=__lowerCAmelCase ) def __lowerCamelCase ( self , *__lowerCAmelCase , **__lowerCAmelCase ): '''simple docstring''' return self.tokenizer.batch_decode(*__lowerCAmelCase , **__lowerCAmelCase ) def __lowerCamelCase ( self , *__lowerCAmelCase , **__lowerCAmelCase ): '''simple docstring''' return self.tokenizer.decode(*__lowerCAmelCase , **__lowerCAmelCase ) @property def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.tokenizer.model_input_names lowerCamelCase__ = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) @property def __lowerCamelCase ( self ): '''simple docstring''' warnings.warn( '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.''' , __lowerCAmelCase , ) return self.image_processor_class @property def __lowerCamelCase ( self ): '''simple docstring''' warnings.warn( '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.''' , __lowerCAmelCase , ) return self.image_processor
209
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
0
def lowercase__ ( __snake_case : Optional[Any] = 1_000 ): '''simple docstring''' UpperCAmelCase_ : Tuple = -1 UpperCAmelCase_ : List[str] = 0 for a in range(1 , n // 3 ): # Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c UpperCAmelCase_ : Optional[int] = (n * n - 2 * a * n) // (2 * n - 2 * a) UpperCAmelCase_ : Tuple = n - a - b if c * c == (a * a + b * b): UpperCAmelCase_ : str = a * b * c if candidate >= product: UpperCAmelCase_ : Any = candidate return product if __name__ == "__main__": print(F'{solution() = }')
29
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
0
from sklearn.metrics import recall_score import datasets lowerCamelCase__ = "\nRecall is the fraction of the positive examples that were correctly labeled by the model as positive. It can be computed with the equation:\nRecall = TP / (TP + FN)\nWhere TP is the true positives and FN is the false negatives.\n" lowerCamelCase__ = "\nArgs:\n- **predictions** (`list` of `int`): The predicted labels.\n- **references** (`list` of `int`): The ground truth labels.\n- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `binary`, and their order when average is `None`. Labels present in the data can be excluded in this input, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in y_true and y_pred are used in sorted order. Defaults to None.\n- **pos_label** (`int`): The class label to use as the 'positive class' when calculating the recall. Defaults to `1`.\n- **average** (`string`): This parameter is required for multiclass/multilabel targets. If None, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.\n - `'binary'`: Only report results for the class specified by `pos_label`. This is applicable only if the target labels and predictions are binary.\n - `'micro'`: Calculate metrics globally by counting the total true positives, false negatives, and false positives.\n - `'macro'`: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - `'weighted'`: Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. Note that it can result in an F-score that is not between precision and recall.\n - `'samples'`: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n- **sample_weight** (`list` of `float`): Sample weights Defaults to `None`.\n- **zero_division** (): Sets the value to return when there is a zero division. Defaults to .\n - `'warn'`: If there is a zero division, the return value is `0`, but warnings are also raised.\n - `0`: If there is a zero division, the return value is `0`.\n - `1`: If there is a zero division, the return value is `1`.\n\nReturns:\n- **recall** (`float`, or `array` of `float`): Either the general recall score, or the recall scores for individual classes, depending on the values input to `labels` and `average`. Minimum possible value is 0. Maximum possible value is 1. A higher recall means that more of the positive examples have been labeled correctly. Therefore, a higher recall is generally considered better.\n\nExamples:\n\n Example 1-A simple example with some errors\n >>> recall_metric = datasets.load_metric('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1])\n >>> print(results)\n {'recall': 0.6666666666666666}\n\n Example 2-The same example as Example 1, but with `pos_label=0` instead of the default `pos_label=1`.\n >>> recall_metric = datasets.load_metric('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], pos_label=0)\n >>> print(results)\n {'recall': 0.5}\n\n Example 3-The same example as Example 1, but with `sample_weight` included.\n >>> recall_metric = datasets.load_metric('recall')\n >>> sample_weight = [0.9, 0.2, 0.9, 0.3, 0.8]\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], sample_weight=sample_weight)\n >>> print(results)\n {'recall': 0.55}\n\n Example 4-A multiclass example, using different averages.\n >>> recall_metric = datasets.load_metric('recall')\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='macro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='micro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='weighted')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {'recall': array([1., 0., 0.])}\n" lowerCamelCase__ = "\n@article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011}\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class A__ ( datasets.Metric ): def _lowerCamelCase ( self : str ): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('int32' ) ), 'references': datasets.Sequence(datasets.Value('int32' ) ), } if self.config_name == 'multilabel' else { 'predictions': datasets.Value('int32' ), 'references': datasets.Value('int32' ), } ) , reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html'] , ) def _lowerCamelCase ( self : Any , a : List[str] , a : str , a : int=None , a : str=1 , a : Union[str, Any]="binary" , a : Dict=None , a : Tuple="warn" , ): '''simple docstring''' lowerCAmelCase__ : Tuple = recall_score( a , a , labels=a , pos_label=a , average=a , sample_weight=a , zero_division=a , ) return {"recall": float(a ) if score.size == 1 else score}
212
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
0
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowerCAmelCase__ :Optional[Any] = "▁" lowerCAmelCase__ :Dict = {"vocab_file": "spiece.model"} lowerCAmelCase__ :int = { "vocab_file": {"google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"} } lowerCAmelCase__ :Optional[Any] = { "google/pegasus-xsum": 5_1_2, } lowerCAmelCase__ :Tuple = logging.get_logger(__name__) class __a ( _a ): _a : List[Any] = VOCAB_FILES_NAMES _a : Any = VOCAB_FILES_NAMES _a : List[Any] = PRETRAINED_VOCAB_FILES_MAP _a : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : int = ["""input_ids""", """attention_mask"""] def __init__( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE="<pad>" , _SCREAMING_SNAKE_CASE="</s>" , _SCREAMING_SNAKE_CASE="<unk>" , _SCREAMING_SNAKE_CASE="<mask_2>" , _SCREAMING_SNAKE_CASE="<mask_1>" , _SCREAMING_SNAKE_CASE=None , _SCREAMING_SNAKE_CASE=103 , _SCREAMING_SNAKE_CASE = None , **_SCREAMING_SNAKE_CASE , ) -> None: """simple docstring""" _UpperCAmelCase = offset if additional_special_tokens is not None: if not isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): raise TypeError( f'''additional_special_tokens should be of type {type(_SCREAMING_SNAKE_CASE )}, but is''' f''' {type(_SCREAMING_SNAKE_CASE )}''' ) _UpperCAmelCase = ( ([mask_token_sent] + additional_special_tokens) if mask_token_sent not in additional_special_tokens and mask_token_sent is not None else additional_special_tokens ) # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken additional_special_tokens_extended += [ f'''<unk_{i}>''' for i in range(len(_SCREAMING_SNAKE_CASE ) , self.offset - 1 ) ] if len(set(_SCREAMING_SNAKE_CASE ) ) != len(_SCREAMING_SNAKE_CASE ): raise ValueError( 'Please make sure that the provided additional_special_tokens do not contain an incorrectly' f''' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.''' ) _UpperCAmelCase = additional_special_tokens_extended else: _UpperCAmelCase = [mask_token_sent] if mask_token_sent is not None else [] additional_special_tokens += [f'''<unk_{i}>''' for i in range(2 , self.offset )] _UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( eos_token=_SCREAMING_SNAKE_CASE , unk_token=_SCREAMING_SNAKE_CASE , mask_token=_SCREAMING_SNAKE_CASE , pad_token=_SCREAMING_SNAKE_CASE , mask_token_sent=_SCREAMING_SNAKE_CASE , offset=_SCREAMING_SNAKE_CASE , additional_special_tokens=_SCREAMING_SNAKE_CASE , sp_model_kwargs=self.sp_model_kwargs , **_SCREAMING_SNAKE_CASE , ) _UpperCAmelCase = mask_token_sent _UpperCAmelCase = vocab_file _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_SCREAMING_SNAKE_CASE ) # add special tokens to encoder dict _UpperCAmelCase = { 0: self.pad_token, 1: self.eos_token, } if self.mask_token_sent is not None: self.encoder.update( { 2: self.mask_token_sent, 3: self.mask_token, } ) if self.offset > 0: # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102 # mask_token_sent is already added to list -> so start at 1 self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1 , self.offset - 1 )} ) _UpperCAmelCase = {v: k for k, v in self.encoder.items()} @property def UpperCAmelCase__ ( self ) -> int: """simple docstring""" return len(self.sp_model ) + self.offset def UpperCAmelCase__ ( self ) -> Dict[str, int]: """simple docstring""" _UpperCAmelCase = {self.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None return state def __setstate__( self , _SCREAMING_SNAKE_CASE ) -> Dict: """simple docstring""" _UpperCAmelCase = d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): _UpperCAmelCase = {} _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE ) -> List[str]: """simple docstring""" return self.sp_model.encode(_SCREAMING_SNAKE_CASE , out_type=_SCREAMING_SNAKE_CASE ) def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE ) -> int: """simple docstring""" if token in self.decoder: return self.decoder[token] elif token in self.added_tokens_decoder: return self.added_tokens_decoder[token] _UpperCAmelCase = self.sp_model.piece_to_id(_SCREAMING_SNAKE_CASE ) return sp_id + self.offset def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE ) -> str: """simple docstring""" if index in self.encoder: return self.encoder[index] elif index in self.added_tokens_encoder: return self.added_tokens_encoder[index] else: _UpperCAmelCase = self.sp_model.IdToPiece(index - self.offset ) return token def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE ) -> Any: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = '' for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE ) + token _UpperCAmelCase = [] else: current_sub_tokens.append(_SCREAMING_SNAKE_CASE ) out_string += self.sp_model.decode(_SCREAMING_SNAKE_CASE ) return out_string.strip() def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE=False ) -> Dict: """simple docstring""" return 1 def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE ) -> str: """simple docstring""" _UpperCAmelCase = set(self.all_special_ids ) # call it once instead of inside list comp all_special_ids.remove(self.unk_token_id ) # <unk> is only sometimes special return [1 if x in all_special_ids else 0 for x in seq] def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = None , _SCREAMING_SNAKE_CASE = False ) -> List[int]: """simple docstring""" if already_has_special_tokens: return self._special_token_mask(_SCREAMING_SNAKE_CASE ) elif token_ids_a is None: return self._special_token_mask(_SCREAMING_SNAKE_CASE ) + [1] else: return self._special_token_mask(token_ids_a + token_ids_a ) + [1] def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE=None ) -> List[int]: """simple docstring""" if token_ids_a is None: return token_ids_a + [self.eos_token_id] # We don't expect to process pairs, but leave the pair logic for API consistency return token_ids_a + token_ids_a + [self.eos_token_id] def UpperCAmelCase__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = None ) -> Tuple[str]: """simple docstring""" if not os.path.isdir(_SCREAMING_SNAKE_CASE ): logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' ) return _UpperCAmelCase = os.path.join( _SCREAMING_SNAKE_CASE , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_SCREAMING_SNAKE_CASE ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _SCREAMING_SNAKE_CASE ) elif not os.path.isfile(self.vocab_file ): with open(_SCREAMING_SNAKE_CASE , 'wb' ) as fi: _UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(_SCREAMING_SNAKE_CASE ) return (out_vocab_file,)
329
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
0
import heapq def lowerCamelCase__ ( _A ): '''simple docstring''' snake_case_ = [] # for each node and his adjacency list add them and the rank of the node to queue # using heapq module the queue will be filled like a Priority Queue # heapq works with a min priority queue, so I used -1*len(v) to build it for key, value in graph.items(): # O(log(n)) heapq.heappush(lowerCamelCase_ , [-1 * len(lowerCamelCase_ ), (key, value)] ) # chosen_vertices = set of chosen vertices snake_case_ = set() # while queue isn't empty and there are still edges # (queue[0][0] is the rank of the node with max rank) while queue and queue[0][0] != 0: # extract vertex with max rank from queue and add it to chosen_vertices snake_case_ = heapq.heappop(lowerCamelCase_ )[1][0] chosen_vertices.add(lowerCamelCase_ ) # Remove all arcs adjacent to argmax for elem in queue: # if v haven't adjacent node, skip if elem[0] == 0: continue # if argmax is reachable from elem # remove argmax from elem's adjacent list and update his rank if argmax in elem[1][1]: snake_case_ = elem[1][1].index(lowerCamelCase_ ) del elem[1][1][index] elem[0] += 1 # re-order the queue heapq.heapify(lowerCamelCase_ ) return chosen_vertices if __name__ == "__main__": import doctest doctest.testmod() lowercase__ : Dict = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]} print(f'''Minimum vertex cover:\n{greedy_min_vertex_cover(graph)}''')
187
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """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.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
'''simple docstring''' import argparse import os import re import tensorflow as tf import torch from transformers import BertConfig, BertModel from transformers.utils import logging logging.set_verbosity_info() __snake_case = logging.get_logger(__name__) def a ( __a , __a , __a ) -> Tuple: '''simple docstring''' UpperCamelCase__ :Union[str, Any] = os.path.abspath(lowerCamelCase_ ) logger.info(f'''Converting TensorFlow checkpoint from {tf_path}''' ) # Load weights from TF model UpperCamelCase__ :Optional[Any] = tf.train.list_variables(lowerCamelCase_ ) UpperCamelCase__ :Optional[Any] = [] UpperCamelCase__ :List[str] = [] UpperCamelCase__ :str = [] for full_name, shape in init_vars: # logger.info(f"Loading TF weight {name} with shape {shape}") UpperCamelCase__ :List[Any] = full_name.split('''/''' ) if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]: logger.info(f'''Skipping non-model layer {full_name}''' ) continue if "optimizer" in full_name: logger.info(f'''Skipping optimization layer {full_name}''' ) continue if name[0] == "model": # ignore initial 'model' UpperCamelCase__ :Union[str, Any] = name[1:] # figure out how many levels deep the name is UpperCamelCase__ :str = 0 for _name in name: if _name.startswith('''layer_with_weights''' ): depth += 1 else: break layer_depth.append(lowerCamelCase_ ) # read data UpperCamelCase__ :Union[str, Any] = tf.train.load_variable(lowerCamelCase_ , lowerCamelCase_ ) names.append('''/'''.join(lowerCamelCase_ ) ) arrays.append(lowerCamelCase_ ) logger.info(f'''Read a total of {len(lowerCamelCase_ ):,} layers''' ) # Sanity check if len(set(lowerCamelCase_ ) ) != 1: raise ValueError(f'''Found layer names with different depths (layer depth {list(set(lowerCamelCase_ ) )})''' ) UpperCamelCase__ :Any = list(set(lowerCamelCase_ ) )[0] if layer_depth != 1: raise ValueError( '''The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP''' ''' heads.''' ) # convert layers logger.info('''Converting weights...''' ) for full_name, array in zip(lowerCamelCase_ , lowerCamelCase_ ): UpperCamelCase__ :Tuple = full_name.split('''/''' ) UpperCamelCase__ :Optional[int] = model UpperCamelCase__ :str = [] for i, m_name in enumerate(lowerCamelCase_ ): if m_name == ".ATTRIBUTES": # variable names end with .ATTRIBUTES/VARIABLE_VALUE break if m_name.startswith('''layer_with_weights''' ): UpperCamelCase__ :Optional[Any] = int(m_name.split('''-''' )[-1] ) if layer_num <= 2: # embedding layers # layer_num 0: word_embeddings # layer_num 1: position_embeddings # layer_num 2: token_type_embeddings continue elif layer_num == 3: # embedding LayerNorm trace.extend(['''embeddings''', '''LayerNorm'''] ) UpperCamelCase__ :Union[str, Any] = getattr(lowerCamelCase_ , '''embeddings''' ) UpperCamelCase__ :Optional[int] = getattr(lowerCamelCase_ , '''LayerNorm''' ) elif layer_num > 3 and layer_num < config.num_hidden_layers + 4: # encoder layers trace.extend(['''encoder''', '''layer''', str(layer_num - 4 )] ) UpperCamelCase__ :List[str] = getattr(lowerCamelCase_ , '''encoder''' ) UpperCamelCase__ :Optional[int] = getattr(lowerCamelCase_ , '''layer''' ) UpperCamelCase__ :Dict = pointer[layer_num - 4] elif layer_num == config.num_hidden_layers + 4: # pooler layer trace.extend(['''pooler''', '''dense'''] ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''pooler''' ) UpperCamelCase__ :Tuple = getattr(lowerCamelCase_ , '''dense''' ) elif m_name == "embeddings": trace.append('''embeddings''' ) UpperCamelCase__ :Dict = getattr(lowerCamelCase_ , '''embeddings''' ) if layer_num == 0: trace.append('''word_embeddings''' ) UpperCamelCase__ :str = getattr(lowerCamelCase_ , '''word_embeddings''' ) elif layer_num == 1: trace.append('''position_embeddings''' ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''position_embeddings''' ) elif layer_num == 2: trace.append('''token_type_embeddings''' ) UpperCamelCase__ :List[Any] = getattr(lowerCamelCase_ , '''token_type_embeddings''' ) else: raise ValueError(f'''Unknown embedding layer with name {full_name}''' ) trace.append('''weight''' ) UpperCamelCase__ :List[Any] = getattr(lowerCamelCase_ , '''weight''' ) elif m_name == "_attention_layer": # self-attention layer trace.extend(['''attention''', '''self'''] ) UpperCamelCase__ :Tuple = getattr(lowerCamelCase_ , '''attention''' ) UpperCamelCase__ :Tuple = getattr(lowerCamelCase_ , '''self''' ) elif m_name == "_attention_layer_norm": # output attention norm trace.extend(['''attention''', '''output''', '''LayerNorm'''] ) UpperCamelCase__ :Dict = getattr(lowerCamelCase_ , '''attention''' ) UpperCamelCase__ :int = getattr(lowerCamelCase_ , '''output''' ) UpperCamelCase__ :Dict = getattr(lowerCamelCase_ , '''LayerNorm''' ) elif m_name == "_attention_output_dense": # output attention dense trace.extend(['''attention''', '''output''', '''dense'''] ) UpperCamelCase__ :Union[str, Any] = getattr(lowerCamelCase_ , '''attention''' ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''output''' ) UpperCamelCase__ :Dict = getattr(lowerCamelCase_ , '''dense''' ) elif m_name == "_output_dense": # output dense trace.extend(['''output''', '''dense'''] ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''output''' ) UpperCamelCase__ :Any = getattr(lowerCamelCase_ , '''dense''' ) elif m_name == "_output_layer_norm": # output dense trace.extend(['''output''', '''LayerNorm'''] ) UpperCamelCase__ :List[Any] = getattr(lowerCamelCase_ , '''output''' ) UpperCamelCase__ :Dict = getattr(lowerCamelCase_ , '''LayerNorm''' ) elif m_name == "_key_dense": # attention key trace.append('''key''' ) UpperCamelCase__ :List[Any] = getattr(lowerCamelCase_ , '''key''' ) elif m_name == "_query_dense": # attention query trace.append('''query''' ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''query''' ) elif m_name == "_value_dense": # attention value trace.append('''value''' ) UpperCamelCase__ :Any = getattr(lowerCamelCase_ , '''value''' ) elif m_name == "_intermediate_dense": # attention intermediate dense trace.extend(['''intermediate''', '''dense'''] ) UpperCamelCase__ :int = getattr(lowerCamelCase_ , '''intermediate''' ) UpperCamelCase__ :Optional[int] = getattr(lowerCamelCase_ , '''dense''' ) elif m_name == "_output_layer_norm": # output layer norm trace.append('''output''' ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''output''' ) # weights & biases elif m_name in ["bias", "beta"]: trace.append('''bias''' ) UpperCamelCase__ :Optional[Any] = getattr(lowerCamelCase_ , '''bias''' ) elif m_name in ["kernel", "gamma"]: trace.append('''weight''' ) UpperCamelCase__ :Optional[int] = getattr(lowerCamelCase_ , '''weight''' ) else: logger.warning(f'''Ignored {m_name}''' ) # for certain layers reshape is necessary UpperCamelCase__ :Any = '.'.join(lowerCamelCase_ ) if re.match(R'''(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)''' , lowerCamelCase_ ) or re.match( R'''(\S+)\.attention\.output\.dense\.weight''' , lowerCamelCase_ ): UpperCamelCase__ :Any = array.reshape(pointer.data.shape ) if "kernel" in full_name: UpperCamelCase__ :Union[str, Any] = array.transpose() if pointer.shape == array.shape: UpperCamelCase__ :Optional[int] = torch.from_numpy(lowerCamelCase_ ) else: raise ValueError( f'''Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:''' f''' {array.shape}''' ) logger.info(f'''Successfully set variable {full_name} to PyTorch layer {trace}''' ) return model def a ( __a , __a , __a ) -> Optional[int]: '''simple docstring''' logger.info(f'''Loading model based on config from {config_path}...''' ) UpperCamelCase__ :Union[str, Any] = BertConfig.from_json_file(lowerCamelCase_ ) UpperCamelCase__ :Union[str, Any] = BertModel(lowerCamelCase_ ) # Load weights from checkpoint logger.info(f'''Loading weights from checkpoint {tf_checkpoint_path}...''' ) load_tfa_weights_in_bert(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # Save pytorch-model logger.info(f'''Saving PyTorch model to {pytorch_dump_path}...''' ) torch.save(model.state_dict() , lowerCamelCase_ ) if __name__ == "__main__": __snake_case = argparse.ArgumentParser() parser.add_argument( '''--tf_checkpoint_path''', type=str, required=True, help='''Path to the TensorFlow 2.x checkpoint path.''' ) parser.add_argument( '''--bert_config_file''', type=str, required=True, help='''The config json file corresponding to the BERT model. This specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', type=str, required=True, help='''Path to the output PyTorch model (must include filename).''', ) __snake_case = parser.parse_args() convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
97
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" from collections import defaultdict from math import gcd def __A (_SCREAMING_SNAKE_CASE = 150_0000 ) ->int: """simple docstring""" lowerCAmelCase__ :defaultdict = defaultdict(lowerCamelCase_ ) lowerCAmelCase__ :Tuple = 2 while 2 * euclid_m * (euclid_m + 1) <= limit: for euclid_n in range((euclid_m % 2) + 1 , lowerCamelCase_ , 2 ): if gcd(lowerCamelCase_ , lowerCamelCase_ ) > 1: continue lowerCAmelCase__ :Union[str, Any] = 2 * euclid_m * (euclid_m + euclid_n) for perimeter in range(lowerCamelCase_ , limit + 1 , lowerCamelCase_ ): frequencies[perimeter] += 1 euclid_m += 1 return sum(1 for frequency in frequencies.values() if frequency == 1 ) if __name__ == "__main__": print(F'''{solution() = }''')
293
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
"""simple docstring""" import math import os import unittest from transformers import MegatronBertConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, MegatronBertForCausalLM, MegatronBertForMaskedLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, MegatronBertModel, ) class A_ : """simple docstring""" def __init__( self :Any , lowerCamelCase_ :List[str] , lowerCamelCase_ :int=13 , lowerCamelCase_ :Union[str, Any]=7 , lowerCamelCase_ :Any=True , lowerCamelCase_ :Union[str, Any]=True , lowerCamelCase_ :Tuple=True , lowerCamelCase_ :str=True , lowerCamelCase_ :List[str]=99 , lowerCamelCase_ :str=64 , lowerCamelCase_ :Optional[Any]=32 , lowerCamelCase_ :Tuple=5 , lowerCamelCase_ :Optional[int]=4 , lowerCamelCase_ :Union[str, Any]=37 , lowerCamelCase_ :Optional[int]="gelu" , lowerCamelCase_ :Optional[int]=0.1 , lowerCamelCase_ :Union[str, Any]=0.1 , lowerCamelCase_ :Optional[Any]=512 , lowerCamelCase_ :int=16 , lowerCamelCase_ :str=2 , lowerCamelCase_ :str=0.02 , lowerCamelCase_ :List[str]=3 , lowerCamelCase_ :List[str]=4 , lowerCamelCase_ :int=None , ): """simple docstring""" lowerCamelCase__ : Optional[Any] =parent lowerCamelCase__ : Tuple =batch_size lowerCamelCase__ : str =seq_length lowerCamelCase__ : str =is_training lowerCamelCase__ : Dict =use_input_mask lowerCamelCase__ : Optional[int] =use_token_type_ids lowerCamelCase__ : Optional[Any] =use_labels lowerCamelCase__ : Any =vocab_size lowerCamelCase__ : Tuple =hidden_size lowerCamelCase__ : List[Any] =embedding_size lowerCamelCase__ : Dict =num_hidden_layers lowerCamelCase__ : Tuple =num_attention_heads lowerCamelCase__ : Optional[int] =intermediate_size lowerCamelCase__ : Optional[int] =hidden_act lowerCamelCase__ : Any =hidden_dropout_prob lowerCamelCase__ : Union[str, Any] =attention_probs_dropout_prob lowerCamelCase__ : List[Any] =max_position_embeddings lowerCamelCase__ : Optional[Any] =type_vocab_size lowerCamelCase__ : List[str] =type_sequence_label_size lowerCamelCase__ : Any =initializer_range lowerCamelCase__ : Dict =num_labels lowerCamelCase__ : List[Any] =num_choices lowerCamelCase__ : Tuple =scope def UpperCAmelCase__ ( self :Any ): """simple docstring""" lowerCamelCase__ : str =ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase__ : List[str] =None if self.use_input_mask: lowerCamelCase__ : Optional[Any] =random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase__ : Any =None if self.use_token_type_ids: lowerCamelCase__ : List[Any] =ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCamelCase__ : Dict =None lowerCamelCase__ : Optional[int] =None lowerCamelCase__ : str =None if self.use_labels: lowerCamelCase__ : List[str] =ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase__ : Optional[Any] =ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase__ : List[str] =ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase__ : Any =self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCAmelCase__ ( self :Tuple ): """simple docstring""" return MegatronBertConfig( 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 , embedding_size=self.embedding_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=lowerCamelCase_ , initializer_range=self.initializer_range , ) def UpperCAmelCase__ ( self :Union[str, Any] , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Tuple , lowerCamelCase_ :List[str] , lowerCamelCase_ :List[str] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :List[str] , lowerCamelCase_ :Tuple ): """simple docstring""" lowerCamelCase__ : Any =MegatronBertModel(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : Any =model(lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ ) lowerCamelCase__ : List[Any] =model(lowerCamelCase_ , token_type_ids=lowerCamelCase_ ) lowerCamelCase__ : Dict =model(lowerCamelCase_ ) 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 , lowerCamelCase_ :Tuple , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Any , lowerCamelCase_ :Dict , lowerCamelCase_ :int , lowerCamelCase_ :Any , lowerCamelCase_ :int ): """simple docstring""" lowerCamelCase__ : Optional[int] =MegatronBertForMaskedLM(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : str =model(lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCAmelCase__ ( self :Any , lowerCamelCase_ :Any , lowerCamelCase_ :int , lowerCamelCase_ :Any , lowerCamelCase_ :List[str] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :int ): """simple docstring""" lowerCamelCase__ : Any =MegatronBertForCausalLM(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : List[Any] =model(lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def UpperCAmelCase__ ( self :int , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Tuple , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :List[Any] ): """simple docstring""" lowerCamelCase__ : Dict =MegatronBertForNextSentencePrediction(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : Optional[int] =model( lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) ) def UpperCAmelCase__ ( self :Any , lowerCamelCase_ :List[str] , lowerCamelCase_ :Union[str, Any] , lowerCamelCase_ :int , lowerCamelCase_ :List[str] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :Union[str, Any] ): """simple docstring""" lowerCamelCase__ : int =MegatronBertForPreTraining(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : List[Any] =model( lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ , next_sentence_label=lowerCamelCase_ , ) self.parent.assertEqual(result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) ) def UpperCAmelCase__ ( self :Any , lowerCamelCase_ :Union[str, Any] , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :Union[str, Any] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :List[str] , lowerCamelCase_ :int , lowerCamelCase_ :int ): """simple docstring""" lowerCamelCase__ : Tuple =MegatronBertForQuestionAnswering(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : List[str] =model( lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , start_positions=lowerCamelCase_ , end_positions=lowerCamelCase_ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def UpperCAmelCase__ ( self :Optional[int] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :str , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :str , lowerCamelCase_ :List[str] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :str ): """simple docstring""" lowerCamelCase__ : Dict =self.num_labels lowerCamelCase__ : Tuple =MegatronBertForSequenceClassification(lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : Union[str, Any] =model(lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def UpperCAmelCase__ ( self :List[Any] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :Optional[Any] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :List[str] , lowerCamelCase_ :Union[str, Any] , lowerCamelCase_ :Tuple ): """simple docstring""" lowerCamelCase__ : int =self.num_labels lowerCamelCase__ : Optional[int] =MegatronBertForTokenClassification(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : Union[str, Any] =model(lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def UpperCAmelCase__ ( self :Tuple , lowerCamelCase_ :Dict , lowerCamelCase_ :str , lowerCamelCase_ :List[Any] , lowerCamelCase_ :List[Any] , lowerCamelCase_ :str , lowerCamelCase_ :Any , lowerCamelCase_ :str ): """simple docstring""" lowerCamelCase__ : Union[str, Any] =self.num_choices lowerCamelCase__ : Optional[int] =MegatronBertForMultipleChoice(config=lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.eval() lowerCamelCase__ : Tuple =input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCamelCase__ : int =token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCamelCase__ : List[Any] =input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCamelCase__ : Optional[int] =model( lowerCamelCase_ , attention_mask=lowerCamelCase_ , token_type_ids=lowerCamelCase_ , labels=lowerCamelCase_ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def UpperCAmelCase__ ( self :int ): """simple docstring""" lowerCamelCase__ : List[Any] =self.prepare_config_and_inputs() ( lowerCamelCase__ ) : List[str] =config_and_inputs lowerCamelCase__ : Optional[int] ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class A_ ( _a , _a , unittest.TestCase ): """simple docstring""" SCREAMING_SNAKE_CASE_ = ( ( MegatronBertModel, MegatronBertForMaskedLM, MegatronBertForCausalLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, ) if is_torch_available() else () ) SCREAMING_SNAKE_CASE_ = ( { """feature-extraction""": MegatronBertModel, """fill-mask""": MegatronBertForMaskedLM, """question-answering""": MegatronBertForQuestionAnswering, """text-classification""": MegatronBertForSequenceClassification, """text-generation""": MegatronBertForCausalLM, """token-classification""": MegatronBertForTokenClassification, """zero-shot""": MegatronBertForSequenceClassification, } if is_torch_available() else {} ) SCREAMING_SNAKE_CASE_ = True # test_resize_embeddings = False SCREAMING_SNAKE_CASE_ = False def UpperCAmelCase__ ( self :Dict , lowerCamelCase_ :int , lowerCamelCase_ :Optional[int] , lowerCamelCase_ :Any=False ): """simple docstring""" lowerCamelCase__ : int =super()._prepare_for_class(lowerCamelCase_ , lowerCamelCase_ , return_labels=lowerCamelCase_ ) if return_labels: if model_class in get_values(lowerCamelCase_ ): lowerCamelCase__ : Union[str, Any] =torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=lowerCamelCase_ ) lowerCamelCase__ : Any =torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCamelCase_ ) return inputs_dict def UpperCAmelCase__ ( self :List[str] ): """simple docstring""" lowerCamelCase__ : List[Any] =MegatronBertModelTester(self ) lowerCamelCase__ : List[Any] =ConfigTester(self , config_class=lowerCamelCase_ , hidden_size=37 ) def UpperCAmelCase__ ( self :Union[str, Any] ): """simple docstring""" self.config_tester.run_common_tests() def UpperCAmelCase__ ( self :List[Any] ): """simple docstring""" lowerCamelCase__ : Dict =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_model(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :str ): """simple docstring""" lowerCamelCase__ : List[str] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_masked_lm(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :str ): """simple docstring""" lowerCamelCase__ : Dict =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_multiple_choice(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :Any ): """simple docstring""" lowerCamelCase__ : Tuple =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_next_sequence_prediction(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :Any ): """simple docstring""" lowerCamelCase__ : List[str] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_pretraining(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :Dict ): """simple docstring""" lowerCamelCase__ : Optional[Any] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_question_answering(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :Dict ): """simple docstring""" lowerCamelCase__ : List[Any] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_sequence_classification(*lowerCamelCase_ ) def UpperCAmelCase__ ( self :Dict ): """simple docstring""" lowerCamelCase__ : Tuple =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_token_classification(*lowerCamelCase_ ) def lowerCAmelCase_ ( snake_case_ : Union[str, Any] ) ->Optional[Any]: return torch.tensor( lowerCamelCase_ , dtype=torch.long , device=lowerCamelCase_ , ) lowerCAmelCase = 1E-4 @require_torch @require_sentencepiece @require_tokenizers class A_ ( unittest.TestCase ): """simple docstring""" @slow @unittest.skip('Model is not available.' ) def UpperCAmelCase__ ( self :Optional[Any] ): """simple docstring""" lowerCamelCase__ : int ='nvidia/megatron-bert-uncased-345m' if "MYDIR" in os.environ: lowerCamelCase__ : Optional[int] =os.path.join(os.environ['MYDIR'] , lowerCamelCase_ ) lowerCamelCase__ : Optional[Any] =MegatronBertModel.from_pretrained(lowerCamelCase_ ) model.to(lowerCamelCase_ ) model.half() lowerCamelCase__ : List[Any] =_long_tensor([[101, 7_110, 1_005, 1_056, 2_023, 11_333, 17_413, 1_029, 102]] ) with torch.no_grad(): lowerCamelCase__ : Tuple =model(lowerCamelCase_ )[0] lowerCamelCase__ : Optional[Any] =torch.Size((1, 9, 1_024) ) self.assertEqual(output.shape , lowerCamelCase_ ) lowerCamelCase__ : List[Any] =[-0.60_40, -0.25_17, -0.10_25, 0.34_20, -0.67_58, -0.00_17, -0.10_89, -0.19_90, 0.57_28] for ii in range(3 ): for jj in range(3 ): lowerCamelCase__ : List[Any] =output[0, ii, jj] lowerCamelCase__ : Dict =expected[3 * ii + jj] lowerCamelCase__ : List[str] ='ii={} jj={} a={} b={}'.format(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) self.assertTrue(math.isclose(lowerCamelCase_ , lowerCamelCase_ , rel_tol=lowerCamelCase_ , abs_tol=lowerCamelCase_ ) , msg=lowerCamelCase_ )
126
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
import colorsys from PIL import Image # type: ignore def lowercase( UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ ) -> float: '''simple docstring''' UpperCamelCase = x UpperCamelCase = y for step in range(lowerCamelCase_ ): # noqa: B007 UpperCamelCase = a * a - b * b + x UpperCamelCase = 2 * a * b + y UpperCamelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def lowercase( UpperCamelCase_ ) -> tuple: '''simple docstring''' if distance == 1: return (0, 0, 0) else: return (255, 255, 255) def lowercase( UpperCamelCase_ ) -> tuple: '''simple docstring''' if distance == 1: return (0, 0, 0) else: return tuple(round(i * 255 ) for i in colorsys.hsv_to_rgb(lowerCamelCase_ , 1 , 1 ) ) def lowercase( UpperCamelCase_ = 800 , UpperCamelCase_ = 600 , UpperCamelCase_ = -0.6 , UpperCamelCase_ = 0 , UpperCamelCase_ = 3.2 , UpperCamelCase_ = 50 , UpperCamelCase_ = True , ) -> Image.Image: '''simple docstring''' UpperCamelCase = Image.new("""RGB""" , (image_width, image_height) ) UpperCamelCase = img.load() # loop through the image-coordinates for image_x in range(lowerCamelCase_ ): for image_y in range(lowerCamelCase_ ): # determine the figure-coordinates based on the image-coordinates UpperCamelCase = figure_width / image_width * image_height UpperCamelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width UpperCamelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height UpperCamelCase = get_distance(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: UpperCamelCase = get_color_coded_rgb(lowerCamelCase_ ) else: UpperCamelCase = get_black_and_white_rgb(lowerCamelCase_ ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure _SCREAMING_SNAKE_CASE = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
343
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
def _SCREAMING_SNAKE_CASE ( a , a ) -> str: if not isinstance(lowerCamelCase_ , lowerCamelCase_ ): raise ValueError('iterations must be defined as integers' ) if not isinstance(lowerCamelCase_ , lowerCamelCase_ ) or not number >= 1: raise ValueError( 'starting number must be\n and integer and be more than 0' ) if not iterations >= 1: raise ValueError('Iterations must be done more than 0 times to play FizzBuzz' ) __A : Tuple = '' while number <= iterations: if number % 3 == 0: out += "Fizz" if number % 5 == 0: out += "Buzz" if 0 not in (number % 3, number % 5): out += str(lowerCamelCase_ ) # print(out) number += 1 out += " " return out if __name__ == "__main__": import doctest doctest.testmod()
280
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class a ( _a , _a , unittest.TestCase ): UpperCamelCase : Dict = StableDiffusionSAGPipeline UpperCamelCase : List[Any] = TEXT_TO_IMAGE_PARAMS UpperCamelCase : List[Any] = TEXT_TO_IMAGE_BATCH_PARAMS UpperCamelCase : Any = TEXT_TO_IMAGE_IMAGE_PARAMS UpperCamelCase : Optional[Any] = TEXT_TO_IMAGE_IMAGE_PARAMS UpperCamelCase : List[str] = False def lowerCamelCase__ ( self : Optional[Any] ) -> Dict: '''simple docstring''' torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: int =UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) SCREAMING_SNAKE_CASE_: Tuple =DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=lowerCAmelCase , set_alpha_to_one=lowerCAmelCase , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: str =AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: List[str] =CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) SCREAMING_SNAKE_CASE_: Dict =CLIPTextModel(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Optional[int] =CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) SCREAMING_SNAKE_CASE_: Optional[Any] ={ 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def lowerCamelCase__ ( self : List[Any] , lowerCAmelCase : Optional[int] , lowerCAmelCase : List[Any]=0 ) -> Dict: '''simple docstring''' if str(lowerCAmelCase ).startswith("""mps""" ): SCREAMING_SNAKE_CASE_: str =torch.manual_seed(lowerCAmelCase ) else: SCREAMING_SNAKE_CASE_: List[Any] =torch.Generator(device=lowerCAmelCase ).manual_seed(lowerCAmelCase ) SCREAMING_SNAKE_CASE_: List[Any] ={ 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def lowerCamelCase__ ( self : List[Any] ) -> List[str]: '''simple docstring''' super().test_inference_batch_single_identical(expected_max_diff=3E-3 ) @slow @require_torch_gpu class a ( unittest.TestCase ): def lowerCamelCase__ ( self : Any ) -> Dict: '''simple docstring''' super().tearDown() gc.collect() torch.cuda.empty_cache() def lowerCamelCase__ ( self : Dict ) -> Optional[int]: '''simple docstring''' SCREAMING_SNAKE_CASE_: Dict =StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4""" ) SCREAMING_SNAKE_CASE_: Optional[Any] =sag_pipe.to(lowerCAmelCase ) sag_pipe.set_progress_bar_config(disable=lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Tuple ='.' SCREAMING_SNAKE_CASE_: int =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: Optional[Any] =sag_pipe( [prompt] , generator=lowerCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type="""np""" ) SCREAMING_SNAKE_CASE_: Tuple =output.images SCREAMING_SNAKE_CASE_: Union[str, Any] =image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_: Tuple =np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5E-2 def lowerCamelCase__ ( self : List[Any] ) -> Union[str, Any]: '''simple docstring''' SCREAMING_SNAKE_CASE_: List[Any] =StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""" ) SCREAMING_SNAKE_CASE_: Dict =sag_pipe.to(lowerCAmelCase ) sag_pipe.set_progress_bar_config(disable=lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Union[str, Any] ='.' SCREAMING_SNAKE_CASE_: str =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: Any =sag_pipe( [prompt] , generator=lowerCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type="""np""" ) SCREAMING_SNAKE_CASE_: List[str] =output.images SCREAMING_SNAKE_CASE_: List[str] =image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) SCREAMING_SNAKE_CASE_: int =np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5E-2 def lowerCamelCase__ ( self : str ) -> Dict: '''simple docstring''' SCREAMING_SNAKE_CASE_: Optional[Any] =StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""" ) SCREAMING_SNAKE_CASE_: List[str] =sag_pipe.to(lowerCAmelCase ) sag_pipe.set_progress_bar_config(disable=lowerCAmelCase ) SCREAMING_SNAKE_CASE_: Union[str, Any] ='.' SCREAMING_SNAKE_CASE_: Tuple =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE_: List[Any] =sag_pipe( [prompt] , width=768 , height=512 , generator=lowerCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type="""np""" , ) SCREAMING_SNAKE_CASE_: Tuple =output.images assert image.shape == (1, 512, 768, 3)
173
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ) -> List[Any]: '''simple docstring''' if isinstance(lowerCamelCase_ ,torch.Tensor ): return image elif isinstance(lowerCamelCase_ ,PIL.Image.Image ): lowerCamelCase__ = [image] if isinstance(image[0] ,PIL.Image.Image ): lowerCamelCase__ = [np.array(i.resize((w, h) ,resample=PIL_INTERPOLATION['''lanczos'''] ) )[None, :] for i in image] lowerCamelCase__ = np.concatenate(lowerCamelCase_ ,axis=0 ) lowerCamelCase__ = np.array(lowerCamelCase_ ).astype(np.floataa ) / 255.0 lowerCamelCase__ = image.transpose(0 ,3 ,1 ,2 ) lowerCamelCase__ = 2.0 * image - 1.0 lowerCamelCase__ = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] ,torch.Tensor ): lowerCamelCase__ = torch.cat(lowerCamelCase_ ,dim=0 ) return image def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,__snake_case=0.9_9_9_5 ) -> Tuple: '''simple docstring''' if not isinstance(lowerCamelCase_ ,np.ndarray ): lowerCamelCase__ = True lowerCamelCase__ = va.device lowerCamelCase__ = va.cpu().numpy() lowerCamelCase__ = va.cpu().numpy() lowerCamelCase__ = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: lowerCamelCase__ = (1 - t) * va + t * va else: lowerCamelCase__ = np.arccos(lowerCamelCase_ ) lowerCamelCase__ = np.sin(lowerCamelCase_ ) lowerCamelCase__ = theta_a * t lowerCamelCase__ = np.sin(lowerCamelCase_ ) lowerCamelCase__ = np.sin(theta_a - theta_t ) / sin_theta_a lowerCamelCase__ = sin_theta_t / sin_theta_a lowerCamelCase__ = sa * va + sa * va if inputs_are_torch: lowerCamelCase__ = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def lowerCAmelCase__(__snake_case ,__snake_case ) -> List[Any]: '''simple docstring''' lowerCamelCase__ = F.normalize(lowerCamelCase_ ,dim=-1 ) lowerCamelCase__ = F.normalize(lowerCamelCase_ ,dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def lowerCAmelCase__(__snake_case ,__snake_case ) -> Optional[int]: '''simple docstring''' for param in model.parameters(): lowerCamelCase__ = value class __A ( _a ): '''simple docstring''' def __init__( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase=None , __lowerCAmelCase=None , __lowerCAmelCase=None , ): '''simple docstring''' super().__init__() self.register_modules( vae=__lowerCAmelCase , text_encoder=__lowerCAmelCase , clip_model=__lowerCAmelCase , tokenizer=__lowerCAmelCase , unet=__lowerCAmelCase , scheduler=__lowerCAmelCase , feature_extractor=__lowerCAmelCase , coca_model=__lowerCAmelCase , coca_tokenizer=__lowerCAmelCase , coca_transform=__lowerCAmelCase , ) lowerCamelCase__ = ( feature_extractor.size if isinstance(feature_extractor.size , __lowerCAmelCase ) else feature_extractor.size['shortest_edge'] ) lowerCamelCase__ = transforms.Normalize(mean=feature_extractor.image_mean , std=feature_extractor.image_std ) set_requires_grad(self.text_encoder , __lowerCAmelCase ) set_requires_grad(self.clip_model , __lowerCAmelCase ) def __lowerCamelCase ( self , __lowerCAmelCase = "auto" ): '''simple docstring''' if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase__ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' self.enable_attention_slicing(__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' set_requires_grad(self.vae , __lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' set_requires_grad(self.vae , __lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' set_requires_grad(self.unet , __lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' set_requires_grad(self.unet , __lowerCAmelCase ) def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = min(int(num_inference_steps * strength ) , __lowerCAmelCase ) lowerCamelCase__ = max(num_inference_steps - init_timestep , 0 ) lowerCamelCase__ = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase=None ): '''simple docstring''' if not isinstance(__lowerCAmelCase , torch.Tensor ): raise ValueError(F'`image` has to be of type `torch.Tensor` but is {type(__lowerCAmelCase )}' ) lowerCamelCase__ = image.to(device=__lowerCAmelCase , dtype=__lowerCAmelCase ) if isinstance(__lowerCAmelCase , __lowerCAmelCase ): lowerCamelCase__ = [ self.vae.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(__lowerCAmelCase ) ] lowerCamelCase__ = torch.cat(__lowerCAmelCase , dim=0 ) else: lowerCamelCase__ = self.vae.encode(__lowerCAmelCase ).latent_dist.sample(__lowerCAmelCase ) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor lowerCamelCase__ = 0.1_8215 * init_latents lowerCamelCase__ = init_latents.repeat_interleave(__lowerCAmelCase , dim=0 ) lowerCamelCase__ = randn_tensor(init_latents.shape , generator=__lowerCAmelCase , device=__lowerCAmelCase , dtype=__lowerCAmelCase ) # get latents lowerCamelCase__ = self.scheduler.add_noise(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = init_latents return latents def __lowerCamelCase ( self , __lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = self.coca_transform(__lowerCAmelCase ).unsqueeze(0 ) with torch.no_grad(), torch.cuda.amp.autocast(): lowerCamelCase__ = self.coca_model.generate(transformed_image.to(device=self.device , dtype=self.coca_model.dtype ) ) lowerCamelCase__ = self.coca_tokenizer.decode(generated[0].cpu().numpy() ) return generated.split('''<end_of_text>''' )[0].replace('''<start_of_text>''' , '''''' ).rstrip(''' .,''' ) def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = self.feature_extractor.preprocess(__lowerCAmelCase ) lowerCamelCase__ = torch.from_numpy(clip_image_input['''pixel_values'''][0] ).unsqueeze(0 ).to(self.device ).half() lowerCamelCase__ = self.clip_model.get_image_features(__lowerCAmelCase ) lowerCamelCase__ = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=__lowerCAmelCase ) lowerCamelCase__ = image_embeddings_clip.repeat_interleave(__lowerCAmelCase , dim=0 ) return image_embeddings_clip @torch.enable_grad() def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , ): '''simple docstring''' lowerCamelCase__ = latents.detach().requires_grad_() lowerCamelCase__ = self.scheduler.scale_model_input(__lowerCAmelCase , __lowerCAmelCase ) # predict the noise residual lowerCamelCase__ = self.unet(__lowerCAmelCase , __lowerCAmelCase , encoder_hidden_states=__lowerCAmelCase ).sample if isinstance(self.scheduler , (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler) ): lowerCamelCase__ = self.scheduler.alphas_cumprod[timestep] lowerCamelCase__ = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf lowerCamelCase__ = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 lowerCamelCase__ = torch.sqrt(__lowerCAmelCase ) lowerCamelCase__ = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler , __lowerCAmelCase ): lowerCamelCase__ = self.scheduler.sigmas[index] lowerCamelCase__ = latents - sigma * noise_pred else: raise ValueError(F'scheduler type {type(self.scheduler )} not supported' ) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor lowerCamelCase__ = 1 / 0.1_8215 * sample lowerCamelCase__ = self.vae.decode(__lowerCAmelCase ).sample lowerCamelCase__ = (image / 2 + 0.5).clamp(0 , 1 ) lowerCamelCase__ = transforms.Resize(self.feature_extractor_size )(__lowerCAmelCase ) lowerCamelCase__ = self.normalize(__lowerCAmelCase ).to(latents.dtype ) lowerCamelCase__ = self.clip_model.get_image_features(__lowerCAmelCase ) lowerCamelCase__ = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=__lowerCAmelCase ) lowerCamelCase__ = spherical_dist_loss(__lowerCAmelCase , __lowerCAmelCase ).mean() * clip_guidance_scale lowerCamelCase__ = -torch.autograd.grad(__lowerCAmelCase , __lowerCAmelCase )[0] if isinstance(self.scheduler , __lowerCAmelCase ): lowerCamelCase__ = latents.detach() + grads * (sigma**2) lowerCamelCase__ = noise_pred_original else: lowerCamelCase__ = noise_pred_original - torch.sqrt(__lowerCAmelCase ) * grads return noise_pred, latents @torch.no_grad() def __call__( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = None , __lowerCAmelCase = None , __lowerCAmelCase = 5_1_2 , __lowerCAmelCase = 5_1_2 , __lowerCAmelCase = 0.6 , __lowerCAmelCase = 5_0 , __lowerCAmelCase = 7.5 , __lowerCAmelCase = 1 , __lowerCAmelCase = 0.0 , __lowerCAmelCase = 1_0_0 , __lowerCAmelCase = None , __lowerCAmelCase = "pil" , __lowerCAmelCase = True , __lowerCAmelCase = 0.8 , __lowerCAmelCase = 0.1 , __lowerCAmelCase = 0.1 , ): '''simple docstring''' if isinstance(__lowerCAmelCase , __lowerCAmelCase ) and len(__lowerCAmelCase ) != batch_size: raise ValueError(F'You have passed {batch_size} batch_size, but only {len(__lowerCAmelCase )} generators.' ) if height % 8 != 0 or width % 8 != 0: raise ValueError(F'`height` and `width` have to be divisible by 8 but are {height} and {width}.' ) if isinstance(__lowerCAmelCase , torch.Generator ) and batch_size > 1: lowerCamelCase__ = [generator] + [None] * (batch_size - 1) lowerCamelCase__ = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] lowerCamelCase__ = [x[0] for x in coca_is_none if x[1]] lowerCamelCase__ = ', '.join(__lowerCAmelCase ) # generate prompts with coca model if prompt is None if content_prompt is None: if len(__lowerCAmelCase ): raise ValueError( F'Content prompt is None and CoCa [{coca_is_none_str}] is None.' F'Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.' ) lowerCamelCase__ = self.get_image_description(__lowerCAmelCase ) if style_prompt is None: if len(__lowerCAmelCase ): raise ValueError( F'Style prompt is None and CoCa [{coca_is_none_str}] is None.' F' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.' ) lowerCamelCase__ = self.get_image_description(__lowerCAmelCase ) # get prompt text embeddings for content and style lowerCamelCase__ = self.tokenizer( __lowerCAmelCase , padding='''max_length''' , max_length=self.tokenizer.model_max_length , truncation=__lowerCAmelCase , return_tensors='''pt''' , ) lowerCamelCase__ = self.text_encoder(content_text_input.input_ids.to(self.device ) )[0] lowerCamelCase__ = self.tokenizer( __lowerCAmelCase , padding='''max_length''' , max_length=self.tokenizer.model_max_length , truncation=__lowerCAmelCase , return_tensors='''pt''' , ) lowerCamelCase__ = self.text_encoder(style_text_input.input_ids.to(self.device ) )[0] lowerCamelCase__ = slerp(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) # duplicate text embeddings for each generation per prompt lowerCamelCase__ = text_embeddings.repeat_interleave(__lowerCAmelCase , dim=0 ) # set timesteps lowerCamelCase__ = 'offset' in set(inspect.signature(self.scheduler.set_timesteps ).parameters.keys() ) lowerCamelCase__ = {} if accepts_offset: lowerCamelCase__ = 1 self.scheduler.set_timesteps(__lowerCAmelCase , **__lowerCAmelCase ) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device ) lowerCamelCase__ = self.get_timesteps(__lowerCAmelCase , __lowerCAmelCase , self.device ) lowerCamelCase__ = timesteps[:1].repeat(__lowerCAmelCase ) # Preprocess image lowerCamelCase__ = preprocess(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = self.prepare_latents( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , text_embeddings.dtype , self.device , __lowerCAmelCase ) lowerCamelCase__ = preprocess(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = self.prepare_latents( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , text_embeddings.dtype , self.device , __lowerCAmelCase ) lowerCamelCase__ = slerp(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) if clip_guidance_scale > 0: lowerCamelCase__ = self.get_clip_image_embeddings(__lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = self.get_clip_image_embeddings(__lowerCAmelCase , __lowerCAmelCase ) lowerCamelCase__ = slerp( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. lowerCamelCase__ = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: lowerCamelCase__ = content_text_input.input_ids.shape[-1] lowerCamelCase__ = self.tokenizer([''''''] , padding='''max_length''' , max_length=__lowerCAmelCase , return_tensors='''pt''' ) lowerCamelCase__ = self.text_encoder(uncond_input.input_ids.to(self.device ) )[0] # duplicate unconditional embeddings for each generation per prompt lowerCamelCase__ = uncond_embeddings.repeat_interleave(__lowerCAmelCase , dim=0 ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase__ = torch.cat([uncond_embeddings, text_embeddings] ) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. lowerCamelCase__ = (batch_size, self.unet.config.in_channels, height // 8, width // 8) lowerCamelCase__ = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps lowerCamelCase__ = torch.randn(__lowerCAmelCase , generator=__lowerCAmelCase , device='''cpu''' , dtype=__lowerCAmelCase ).to( self.device ) else: lowerCamelCase__ = torch.randn(__lowerCAmelCase , generator=__lowerCAmelCase , device=self.device , dtype=__lowerCAmelCase ) else: if latents.shape != latents_shape: raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {latents_shape}' ) lowerCamelCase__ = latents.to(self.device ) # scale the initial noise by the standard deviation required by the scheduler lowerCamelCase__ = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] lowerCamelCase__ = 'eta' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) lowerCamelCase__ = {} if accepts_eta: lowerCamelCase__ = eta # check if the scheduler accepts generator lowerCamelCase__ = 'generator' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) if accepts_generator: lowerCamelCase__ = generator with self.progress_bar(total=__lowerCAmelCase ): for i, t in enumerate(__lowerCAmelCase ): # expand the latents if we are doing classifier free guidance lowerCamelCase__ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase__ = self.scheduler.scale_model_input(__lowerCAmelCase , __lowerCAmelCase ) # predict the noise residual lowerCamelCase__ = self.unet(__lowerCAmelCase , __lowerCAmelCase , encoder_hidden_states=__lowerCAmelCase ).sample # perform classifier free guidance if do_classifier_free_guidance: lowerCamelCase__ = noise_pred.chunk(2 ) lowerCamelCase__ = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: lowerCamelCase__ = ( text_embeddings.chunk(2 )[1] if do_classifier_free_guidance else text_embeddings ) lowerCamelCase__ = self.cond_fn( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , ) # compute the previous noisy sample x_t -> x_t-1 lowerCamelCase__ = self.scheduler.step(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , **__lowerCAmelCase ).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor lowerCamelCase__ = 1 / 0.1_8215 * latents lowerCamelCase__ = self.vae.decode(__lowerCAmelCase ).sample lowerCamelCase__ = (image / 2 + 0.5).clamp(0 , 1 ) lowerCamelCase__ = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": lowerCamelCase__ = self.numpy_to_pil(__lowerCAmelCase ) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=__lowerCAmelCase , nsfw_content_detected=__lowerCAmelCase )
209
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
import re from filelock import FileLock try: import nltk __UpperCAmelCase = True except (ImportError, ModuleNotFoundError): __UpperCAmelCase = False if NLTK_AVAILABLE: with FileLock('.lock') as lock: nltk.download('punkt', quiet=True) def lowercase__ ( __snake_case : Optional[int] ): '''simple docstring''' re.sub('<n>' , '' , lowerCamelCase_ ) # 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(lowerCamelCase_ ) )
29
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
from typing import Dict import numpy as np import torch from . import residue_constants as rc from .tensor_utils import tensor_tree_map, tree_map def lowerCAmelCase__ ( SCREAMING_SNAKE_CASE_ ) -> Dict[str, torch.Tensor]: lowerCAmelCase__ : str = [] lowerCAmelCase__ : Any = [] lowerCAmelCase__ : Union[str, Any] = [] for rt in rc.restypes: lowerCAmelCase__ : int = rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]] restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names] ) lowerCAmelCase__ : List[str] = {name: i for i, name in enumerate(lowerCamelCase_ )} restype_atomaa_to_atomaa_list.append( [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types] ) restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names] ) # Add dummy mapping for restype 'UNK' restype_atomaa_to_atomaa_list.append([0] * 14 ) restype_atomaa_to_atomaa_list.append([0] * 37 ) restype_atomaa_mask_list.append([0.0] * 14 ) lowerCAmelCase__ : Any = torch.tensor( lowerCamelCase_ , dtype=torch.intaa , device=protein['aatype'].device , ) lowerCAmelCase__ : List[str] = torch.tensor( lowerCamelCase_ , dtype=torch.intaa , device=protein['aatype'].device , ) lowerCAmelCase__ : List[Any] = torch.tensor( lowerCamelCase_ , dtype=torch.floataa , device=protein['aatype'].device , ) lowerCAmelCase__ : Optional[Any] = protein['aatype'].to(torch.long ) # create the mapping for (residx, atom14) --> atom37, i.e. an array # with shape (num_res, 14) containing the atom37 indices for this protein lowerCAmelCase__ : Union[str, Any] = restype_atomaa_to_atomaa[protein_aatype] lowerCAmelCase__ : Any = restype_atomaa_mask[protein_aatype] lowerCAmelCase__ : int = residx_atomaa_mask lowerCAmelCase__ : List[str] = residx_atomaa_to_atomaa.long() # create the gather indices for mapping back lowerCAmelCase__ : Any = restype_atomaa_to_atomaa[protein_aatype] lowerCAmelCase__ : int = residx_atomaa_to_atomaa.long() # create the corresponding mask lowerCAmelCase__ : str = torch.zeros([21, 37] , dtype=torch.floataa , device=protein['aatype'].device ) for restype, restype_letter in enumerate(rc.restypes ): lowerCAmelCase__ : int = rc.restype_atoa[restype_letter] lowerCAmelCase__ : List[str] = rc.residue_atoms[restype_name] for atom_name in atom_names: lowerCAmelCase__ : List[str] = rc.atom_order[atom_name] lowerCAmelCase__ : List[Any] = 1 lowerCAmelCase__ : Tuple = restype_atomaa_mask[protein_aatype] lowerCAmelCase__ : str = residx_atomaa_mask return protein def lowerCAmelCase__ ( SCREAMING_SNAKE_CASE_ ) -> Dict[str, np.ndarray]: lowerCAmelCase__ : Union[str, Any] = tree_map(lambda SCREAMING_SNAKE_CASE_ : torch.tensor(lowerCamelCase_ , device=batch['aatype'].device ) , lowerCamelCase_ , np.ndarray ) lowerCAmelCase__ : List[str] = tensor_tree_map(lambda SCREAMING_SNAKE_CASE_ : np.array(lowerCamelCase_ ) , make_atomaa_masks(lowerCamelCase_ ) ) return out
212
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
0
from __future__ import annotations import requests def lowerCAmelCase__ ( a__: Any ) -> dict: '''simple docstring''' _UpperCAmelCase = F'''https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty''' return requests.get(lowerCamelCase_ ).json() def lowerCAmelCase__ ( a__: Optional[int] = 1_0 ) -> list[dict]: '''simple docstring''' _UpperCAmelCase = 'https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty' _UpperCAmelCase = requests.get(lowerCamelCase_ ).json()[:max_stories] return [get_hackernews_story(lowerCamelCase_ ) for story_id in story_ids] def lowerCAmelCase__ ( a__: int = 1_0 ) -> str: '''simple docstring''' _UpperCAmelCase = hackernews_top_stories(lowerCamelCase_ ) return "\n".join('* [{title}]({url})'.format(**lowerCamelCase_ ) for story in stories ) if __name__ == "__main__": print(hackernews_top_stories_as_markdown())
329
import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" return MobileViTVaConfig( image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_act=self.hidden_act, conv_kernel_size=self.conv_kernel_size, output_stride=self.output_stride, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, width_multiplier=self.width_multiplier, ffn_dropout=self.ffn_dropout_prob, attn_dropout=self.attn_dropout_prob, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): self.assertListEqual( list(hidden_states[i].shape[-2:]), [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor], ) divisor *= 2 self.assertEqual(self.model_tester.output_stride, divisor // 2) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor( [ [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]], [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]], [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]], ], device=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
0
import os import re import shutil from argparse import ArgumentParser, Namespace from datasets.commands import BaseDatasetsCLICommand from datasets.utils.logging import get_logger lowercase__ : Union[str, Any] = "<<<<<<< This should probably be modified because it mentions: " lowercase__ : Optional[int] = "=======\n>>>>>>>\n" lowercase__ : str = [ "TextEncoderConfig", "ByteTextEncoder", "SubwordTextEncoder", "encoder_config", "maybe_build_from_corpus", "manual_dir", ] lowercase__ : List[Any] = [ # (pattern, replacement) # Order is important here for some replacements (r"tfds\.core", r"datasets"), (r"tf\.io\.gfile\.GFile", r"open"), (r"tf\.([\w\d]+)", r"datasets.Value('\1')"), (r"tfds\.features\.Text\(\)", r"datasets.Value('string')"), (r"tfds\.features\.Text\(", r"datasets.Value('string'),"), (r"features\s*=\s*tfds.features.FeaturesDict\(", r"features=datasets.Features("), (r"tfds\.features\.FeaturesDict\(", r"dict("), (r"The TensorFlow Datasets Authors", r"The TensorFlow Datasets Authors and the HuggingFace Datasets Authors"), (r"tfds\.", r"datasets."), (r"dl_manager\.manual_dir", r"self.config.data_dir"), (r"self\.builder_config", r"self.config"), ] def lowerCamelCase__ ( _A ): '''simple docstring''' return ConvertCommand(args.tfds_path , args.datasets_directory ) class UpperCAmelCase ( _a ): '''simple docstring''' @staticmethod def snake_case__ ( __lowercase : Any ): """simple docstring""" snake_case_ = parser.add_parser( "convert" , help="Convert a TensorFlow Datasets dataset to a HuggingFace Datasets dataset." , ) train_parser.add_argument( "--tfds_path" , type=__lowercase , required=__lowercase , help="Path to a TensorFlow Datasets folder to convert or a single tfds file to convert." , ) train_parser.add_argument( "--datasets_directory" , type=__lowercase , required=__lowercase , help="Path to the HuggingFace Datasets folder." ) train_parser.set_defaults(func=__lowercase ) def __init__( self : str , __lowercase : int , __lowercase : str , *__lowercase : Dict ): """simple docstring""" snake_case_ = get_logger("datasets-cli/converting" ) snake_case_ = tfds_path snake_case_ = datasets_directory def snake_case__ ( self : Union[str, Any] ): """simple docstring""" if os.path.isdir(self._tfds_path ): snake_case_ = os.path.abspath(self._tfds_path ) elif os.path.isfile(self._tfds_path ): snake_case_ = os.path.dirname(self._tfds_path ) else: raise ValueError("--tfds_path is neither a directory nor a file. Please check path." ) snake_case_ = os.path.abspath(self._datasets_directory ) self._logger.info(f"Converting datasets from {abs_tfds_path} to {abs_datasets_path}" ) snake_case_ = [] snake_case_ = [] snake_case_ = {} if os.path.isdir(self._tfds_path ): snake_case_ = os.listdir(__lowercase ) else: snake_case_ = [os.path.basename(self._tfds_path )] for f_name in file_names: self._logger.info(f"Looking at file {f_name}" ) snake_case_ = os.path.join(__lowercase , __lowercase ) snake_case_ = os.path.join(__lowercase , __lowercase ) if not os.path.isfile(__lowercase ) or "__init__" in f_name or "_test" in f_name or ".py" not in f_name: self._logger.info("Skipping file" ) continue with open(__lowercase , encoding="utf-8" ) as f: snake_case_ = f.readlines() snake_case_ = [] snake_case_ = False snake_case_ = False snake_case_ = [] for line in lines: snake_case_ = line # Convert imports if "import tensorflow.compat.v2 as tf" in out_line: continue elif "@tfds.core" in out_line: continue elif "builder=self" in out_line: continue elif "import tensorflow_datasets.public_api as tfds" in out_line: snake_case_ = 'import datasets\n' elif "import tensorflow" in out_line: # order is important here snake_case_ = '' continue elif "from absl import logging" in out_line: snake_case_ = 'from datasets import logging\n' elif "getLogger" in out_line: snake_case_ = out_line.replace("getLogger" , "get_logger" ) elif any(expression in out_line for expression in TO_HIGHLIGHT ): snake_case_ = True snake_case_ = list(filter(lambda __lowercase : e in out_line , __lowercase ) ) out_lines.append(HIGHLIGHT_MESSAGE_PRE + str(__lowercase ) + "\n" ) out_lines.append(__lowercase ) out_lines.append(__lowercase ) continue else: for pattern, replacement in TO_CONVERT: snake_case_ = re.sub(__lowercase , __lowercase , __lowercase ) # Take care of saving utilities (to later move them together with main script) if "tensorflow_datasets" in out_line: snake_case_ = re.match(r"from\stensorflow_datasets.*import\s([^\.\r\n]+)" , __lowercase ) tfds_imports.extend(imp.strip() for imp in match.group(1 ).split("," ) ) snake_case_ = 'from . import ' + match.group(1 ) # Check we have not forget anything if "tf." in out_line or "tfds." in out_line or "tensorflow_datasets" in out_line: raise ValueError(f"Error converting {out_line.strip()}" ) if "GeneratorBasedBuilder" in out_line or "BeamBasedBuilder" in out_line: snake_case_ = True out_lines.append(__lowercase ) if is_builder or "wmt" in f_name: # We create a new directory for each dataset snake_case_ = f_name.replace(".py" , "" ) snake_case_ = os.path.join(__lowercase , __lowercase ) snake_case_ = os.path.join(__lowercase , __lowercase ) os.makedirs(__lowercase , exist_ok=__lowercase ) self._logger.info(f"Adding directory {output_dir}" ) imports_to_builder_map.update({imp: output_dir for imp in tfds_imports} ) else: # Utilities will be moved at the end utils_files.append(__lowercase ) if needs_manual_update: with_manual_update.append(__lowercase ) with open(__lowercase , "w" , encoding="utf-8" ) as f: f.writelines(__lowercase ) self._logger.info(f"Converted in {output_file}" ) for utils_file in utils_files: try: snake_case_ = os.path.basename(__lowercase ) snake_case_ = imports_to_builder_map[f_name.replace(".py" , "" )] self._logger.info(f"Moving {dest_folder} to {utils_file}" ) shutil.copy(__lowercase , __lowercase ) except KeyError: self._logger.error(f"Cannot find destination folder for {utils_file}. Please copy manually." ) if with_manual_update: for file_path in with_manual_update: self._logger.warning( f"You need to manually update file {file_path} to remove configurations using \'TextEncoderConfig\'." )
187
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
0
'''simple docstring''' import numpy as np import qiskit def a ( __a = 8 , __a = None ) -> str: '''simple docstring''' UpperCamelCase__ :int = np.random.default_rng(seed=lowerCamelCase_ ) # Roughly 25% of the qubits will contribute to the key. # So we take more than we need. UpperCamelCase__ :List[str] = 6 * key_len # Measurement basis for Alice's qubits. UpperCamelCase__ :Optional[Any] = rng.integers(2 , size=lowerCamelCase_ ) # The set of states Alice will prepare. UpperCamelCase__ :str = rng.integers(2 , size=lowerCamelCase_ ) # Measurement basis for Bob's qubits. UpperCamelCase__ :Any = rng.integers(2 , size=lowerCamelCase_ ) # Quantum Circuit to simulate BB84 UpperCamelCase__ :Dict = qiskit.QuantumCircuit(lowerCamelCase_ , name='''BB84''' ) # Alice prepares her qubits according to rules above. for index, _ in enumerate(lowerCamelCase_ ): if alice_state[index] == 1: bbaa_circ.x(lowerCamelCase_ ) if alice_basis[index] == 1: bbaa_circ.h(lowerCamelCase_ ) bbaa_circ.barrier() # Bob measures the received qubits according to rules above. for index, _ in enumerate(lowerCamelCase_ ): if bob_basis[index] == 1: bbaa_circ.h(lowerCamelCase_ ) bbaa_circ.barrier() bbaa_circ.measure_all() # Simulate the quantum circuit. UpperCamelCase__ :Optional[Any] = qiskit.Aer.get_backend('''aer_simulator''' ) # We only need to run one shot because the key is unique. # Multiple shots will produce the same key. UpperCamelCase__ :Optional[int] = qiskit.execute(lowerCamelCase_ , lowerCamelCase_ , shots=1 , seed_simulator=lowerCamelCase_ ) # Returns the result of measurement. UpperCamelCase__ :Optional[Any] = job.result().get_counts(lowerCamelCase_ ).most_frequent() # Extracting the generated key from the simulation results. # Only keep measurement results where Alice and Bob chose the same basis. UpperCamelCase__ :List[Any] = ''.join( [ result_bit for alice_basis_bit, bob_basis_bit, result_bit in zip( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) if alice_basis_bit == bob_basis_bit ] ) # Get final key. Pad with 0 if too short, otherwise truncate. UpperCamelCase__ :Optional[int] = gen_key[:key_len] if len(lowerCamelCase_ ) >= key_len else gen_key.ljust(lowerCamelCase_ , '''0''' ) return key if __name__ == "__main__": print(F"""The generated key is : {bbaa(8, seed=0)}""") from doctest import testmod testmod()
97
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
0
"""simple docstring""" __A = {} def __A (_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) ->int: """simple docstring""" if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on lowerCAmelCase__ :Dict = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one lowerCAmelCase__ :str = _calculate(days - 1 , lowerCamelCase_ , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 lowerCAmelCase__ :int = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter lowerCAmelCase__ :Tuple = _calculate(days - 1 , lowerCamelCase_ , 0 ) lowerCAmelCase__ :Tuple = state_late + state_absent + state_ontime lowerCAmelCase__ :str = prizestrings return prizestrings def __A (_SCREAMING_SNAKE_CASE = 30 ) ->int: """simple docstring""" return _calculate(lowerCamelCase_ , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
293
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
0
'''simple docstring''' import torch from transformers import CamembertForMaskedLM, CamembertTokenizer def UpperCAmelCase_ ( __lowercase : Any , __lowercase : List[Any] , __lowercase : str , __lowercase : Optional[Any]=5 ) -> Optional[Any]: '''simple docstring''' assert masked_input.count("<mask>" ) == 1 _UpperCAmelCase = torch.tensor(tokenizer.encode(__lowercase , add_special_tokens=__lowercase ) ).unsqueeze(0 ) # Batch size 1 _UpperCAmelCase = model(__lowercase )[0] # The last hidden-state is the first element of the output tuple _UpperCAmelCase = (input_ids.squeeze() == tokenizer.mask_token_id).nonzero().item() _UpperCAmelCase = logits[0, masked_index, :] _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase , _UpperCAmelCase = prob.topk(k=__lowercase , dim=0 ) _UpperCAmelCase = " ".join( [tokenizer.convert_ids_to_tokens(indices[i].item() ) for i in range(len(__lowercase ) )] ) _UpperCAmelCase = tokenizer.mask_token _UpperCAmelCase = [] for index, predicted_token_bpe in enumerate(topk_predicted_token_bpe.split(" " ) ): _UpperCAmelCase = predicted_token_bpe.replace("\u2581" , " " ) if " {0}".format(__lowercase ) in masked_input: topk_filled_outputs.append( ( masked_input.replace(" {0}".format(__lowercase ) , __lowercase ), values[index].item(), predicted_token, ) ) else: topk_filled_outputs.append( ( masked_input.replace(__lowercase , __lowercase ), values[index].item(), predicted_token, ) ) return topk_filled_outputs __SCREAMING_SNAKE_CASE :Any = CamembertTokenizer.from_pretrained('''camembert-base''') __SCREAMING_SNAKE_CASE :Optional[Any] = CamembertForMaskedLM.from_pretrained('''camembert-base''') model.eval() __SCREAMING_SNAKE_CASE :int = '''Le camembert est <mask> :)''' print(fill_mask(masked_input, model, tokenizer, topk=3))
22
'''simple docstring''' import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef __SCREAMING_SNAKE_CASE :List[str] = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : Tuple ) -> int: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase_ ( __lowercase : int , __lowercase : str ) -> Optional[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = simple_accuracy(__lowercase , __lowercase ) _UpperCAmelCase = fa_score(y_true=__lowercase , y_pred=__lowercase ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : List[str] ) -> List[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = pearsonr(__lowercase , __lowercase )[0] _UpperCAmelCase = spearmanr(__lowercase , __lowercase )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) assert len(__lowercase ) == len(__lowercase ), f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' if task_name == "cola": return {"mcc": matthews_corrcoef(__lowercase , __lowercase )} elif task_name == "sst-2": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mrpc": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "sts-b": return pearson_and_spearman(__lowercase , __lowercase ) elif task_name == "qqp": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "qnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "rte": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "wnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "hans": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : Dict , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) if len(__lowercase ) != len(__lowercase ): raise ValueError(f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' ) if task_name == "xnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase )
22
1
'''simple docstring''' import json import os import shutil import tempfile import unittest from transformers import BatchEncoding, CanineTokenizer from transformers.testing_utils import require_tokenizers, require_torch from transformers.tokenization_utils import AddedToken from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : str = CanineTokenizer _lowerCamelCase : Tuple = False def lowercase ( self : List[Any] ): super().setUp() _UpperCAmelCase = CanineTokenizer() tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : List[str] ): return CanineTokenizer.from_pretrained("google/canine-s" ) def lowercase ( self : Union[str, Any] , **snake_case_ : List[Any] ): _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname , **snake_case_ ) _UpperCAmelCase = 1_0_2_4 return tokenizer @require_torch def lowercase ( self : List[str] ): _UpperCAmelCase = self.canine_tokenizer _UpperCAmelCase = ["Life is like a box of chocolates.", "You never know what you're gonna get."] # fmt: off _UpperCAmelCase = [5_7_3_4_4, 7_6, 1_0_5, 1_0_2, 1_0_1, 3_2, 1_0_5, 1_1_5, 3_2, 1_0_8, 1_0_5, 1_0_7, 1_0_1, 3_2, 9_7, 3_2, 9_8, 1_1_1, 1_2_0, 3_2, 1_1_1, 1_0_2, 3_2, 9_9, 1_0_4, 1_1_1, 9_9, 1_1_1, 1_0_8, 9_7, 1_1_6, 1_0_1, 1_1_5, 4_6, 5_7_3_4_5, 0, 0, 0, 0] # fmt: on _UpperCAmelCase = tokenizer(snake_case_ , padding=snake_case_ , return_tensors="pt" ) self.assertIsInstance(snake_case_ , snake_case_ ) _UpperCAmelCase = list(batch.input_ids.numpy()[0] ) self.assertListEqual(snake_case_ , snake_case_ ) self.assertEqual((2, 3_9) , batch.input_ids.shape ) self.assertEqual((2, 3_9) , batch.attention_mask.shape ) @require_torch def lowercase ( self : List[Any] ): _UpperCAmelCase = self.canine_tokenizer _UpperCAmelCase = ["Once there was a man.", "He wrote a test in HuggingFace Tranformers."] _UpperCAmelCase = tokenizer(snake_case_ , padding=snake_case_ , return_tensors="pt" ) # check if input_ids, attention_mask and token_type_ids are returned self.assertIn("input_ids" , snake_case_ ) self.assertIn("attention_mask" , snake_case_ ) self.assertIn("token_type_ids" , snake_case_ ) @require_torch def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.canine_tokenizer _UpperCAmelCase = [ "What's the weater?", "It's about 25 degrees.", ] _UpperCAmelCase = tokenizer( text_target=snake_case_ , max_length=3_2 , padding="max_length" , truncation=snake_case_ , return_tensors="pt" ) self.assertEqual(3_2 , targets["input_ids"].shape[1] ) def lowercase ( self : Union[str, Any] ): # safety check on max_len default value so we are sure the test works _UpperCAmelCase = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): self.assertNotEqual(tokenizer.model_max_length , 4_2 ) # Now let's start the test _UpperCAmelCase = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): # Isolate this from the other tests because we save additional tokens/etc _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = " He is very happy, UNwant\u00E9d,running" _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) tokenizer.save_pretrained(snake_case_ ) _UpperCAmelCase = tokenizer.__class__.from_pretrained(snake_case_ ) _UpperCAmelCase = after_tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) shutil.rmtree(snake_case_ ) _UpperCAmelCase = self.get_tokenizers(model_max_length=4_2 ) for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): # Isolate this from the other tests because we save additional tokens/etc _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = " He is very happy, UNwant\u00E9d,running" _UpperCAmelCase = tokenizer.additional_special_tokens # We can add a new special token for Canine as follows: _UpperCAmelCase = chr(0Xe0_07 ) additional_special_tokens.append(snake_case_ ) tokenizer.add_special_tokens({"additional_special_tokens": additional_special_tokens} ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) tokenizer.save_pretrained(snake_case_ ) _UpperCAmelCase = tokenizer.__class__.from_pretrained(snake_case_ ) _UpperCAmelCase = after_tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) self.assertIn(snake_case_ , after_tokenizer.additional_special_tokens ) self.assertEqual(after_tokenizer.model_max_length , 4_2 ) _UpperCAmelCase = tokenizer.__class__.from_pretrained(snake_case_ , model_max_length=4_3 ) self.assertEqual(tokenizer.model_max_length , 4_3 ) shutil.rmtree(snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.get_tokenizers(do_lower_case=snake_case_ ) for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): _UpperCAmelCase , _UpperCAmelCase = self.get_clean_sequence(snake_case_ ) # a special token for Canine can be defined as follows: _UpperCAmelCase = 0Xe0_05 _UpperCAmelCase = chr(snake_case_ ) tokenizer.add_special_tokens({"cls_token": special_token} ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertEqual(len(snake_case_ ) , 1 ) _UpperCAmelCase = tokenizer.decode(ids + encoded_special_token , clean_up_tokenization_spaces=snake_case_ ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertEqual(snake_case_ , input_encoded + special_token_id ) _UpperCAmelCase = tokenizer.decode(snake_case_ , skip_special_tokens=snake_case_ ) self.assertTrue(special_token not in decoded ) def lowercase ( self : int ): _UpperCAmelCase = self.get_tokenizers(do_lower_case=snake_case_ ) for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): _UpperCAmelCase = chr(0Xe0_05 ) _UpperCAmelCase = chr(0Xe0_06 ) # `add_tokens` method stores special tokens only in `tokenizer.unique_no_split_tokens`. (in tokenization_utils.py) tokenizer.add_tokens([SPECIAL_TOKEN_1] , special_tokens=snake_case_ ) # `add_special_tokens` method stores special tokens in `tokenizer.additional_special_tokens`, # which also occur in `tokenizer.all_special_tokens`. (in tokenization_utils_base.py) tokenizer.add_special_tokens({"additional_special_tokens": [SPECIAL_TOKEN_2]} ) _UpperCAmelCase = tokenizer.tokenize(snake_case_ ) _UpperCAmelCase = tokenizer.tokenize(snake_case_ ) self.assertEqual(len(snake_case_ ) , 1 ) self.assertEqual(len(snake_case_ ) , 1 ) self.assertEqual(token_a[0] , snake_case_ ) self.assertEqual(token_a[0] , snake_case_ ) @require_tokenizers def lowercase ( self : Any ): _UpperCAmelCase = self.get_tokenizers(do_lower_case=snake_case_ ) for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): # a special token for Canine can be defined as follows: _UpperCAmelCase = 0Xe0_06 _UpperCAmelCase = chr(snake_case_ ) _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ ) tokenizer.add_special_tokens({"additional_special_tokens": [new_token]} ) with tempfile.TemporaryDirectory() as tmp_dir_name: tokenizer.save_pretrained(snake_case_ ) tokenizer.from_pretrained(snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase = [] if self.test_slow_tokenizer: tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()) ) if self.test_rust_tokenizer: tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()) ) for tokenizer_class, tokenizer_utils in tokenizer_list: with tempfile.TemporaryDirectory() as tmp_dir: tokenizer_utils.save_pretrained(snake_case_ ) with open(os.path.join(snake_case_ , "special_tokens_map.json" ) , encoding="utf-8" ) as json_file: _UpperCAmelCase = json.load(snake_case_ ) with open(os.path.join(snake_case_ , "tokenizer_config.json" ) , encoding="utf-8" ) as json_file: _UpperCAmelCase = json.load(snake_case_ ) # a special token for Canine can be defined as follows: _UpperCAmelCase = 0Xe0_06 _UpperCAmelCase = chr(snake_case_ ) _UpperCAmelCase = [new_token_a] _UpperCAmelCase = [new_token_a] with open(os.path.join(snake_case_ , "special_tokens_map.json" ) , "w" , encoding="utf-8" ) as outfile: json.dump(snake_case_ , snake_case_ ) with open(os.path.join(snake_case_ , "tokenizer_config.json" ) , "w" , encoding="utf-8" ) as outfile: json.dump(snake_case_ , snake_case_ ) # the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes # into account the new value of additional_special_tokens given in the "tokenizer_config.json" and # "special_tokens_map.json" files _UpperCAmelCase = tokenizer_class.from_pretrained(snake_case_ , extra_ids=0 ) self.assertIn(snake_case_ , tokenizer_without_change_in_init.additional_special_tokens ) # self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab self.assertEqual( [new_token_a] , tokenizer_without_change_in_init.convert_ids_to_tokens( tokenizer_without_change_in_init.convert_tokens_to_ids([new_token_a] ) ) , ) _UpperCAmelCase = 0Xe0_07 _UpperCAmelCase = chr(snake_case_ ) # Now we test that we can change the value of additional_special_tokens in the from_pretrained _UpperCAmelCase = [AddedToken(snake_case_ , lstrip=snake_case_ )] _UpperCAmelCase = tokenizer_class.from_pretrained( snake_case_ , additional_special_tokens=snake_case_ , extra_ids=0 ) self.assertIn(snake_case_ , tokenizer.additional_special_tokens ) # self.assertIn(new_token_2,tokenizer.get_vocab()) # ByT5Tokenization no vocab self.assertEqual( [new_token_a] , tokenizer.convert_ids_to_tokens(tokenizer.convert_tokens_to_ids([new_token_a] ) ) ) @require_tokenizers def lowercase ( self : Tuple ): _UpperCAmelCase = self.get_tokenizers(do_lower_case=snake_case_ ) for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): _UpperCAmelCase = "hello world" if self.space_between_special_tokens: _UpperCAmelCase = "[CLS] hello world [SEP]" else: _UpperCAmelCase = input _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) _UpperCAmelCase = tokenizer.decode(snake_case_ , spaces_between_special_tokens=self.space_between_special_tokens ) self.assertIn(snake_case_ , [output, output.lower()] ) def lowercase ( self : str ): _UpperCAmelCase = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): _UpperCAmelCase = [ "bos_token", "eos_token", "unk_token", "sep_token", "pad_token", "cls_token", "mask_token", ] _UpperCAmelCase = "a" _UpperCAmelCase = ord(snake_case_ ) for attr in attributes_list: setattr(snake_case_ , attr + "_id" , snake_case_ ) self.assertEqual(getattr(snake_case_ , snake_case_ ) , snake_case_ ) self.assertEqual(getattr(snake_case_ , attr + "_id" ) , snake_case_ ) setattr(snake_case_ , attr + "_id" , snake_case_ ) self.assertEqual(getattr(snake_case_ , snake_case_ ) , snake_case_ ) self.assertEqual(getattr(snake_case_ , attr + "_id" ) , snake_case_ ) setattr(snake_case_ , "additional_special_tokens_ids" , [] ) self.assertListEqual(getattr(snake_case_ , "additional_special_tokens" ) , [] ) self.assertListEqual(getattr(snake_case_ , "additional_special_tokens_ids" ) , [] ) _UpperCAmelCase = 0Xe0_06 _UpperCAmelCase = chr(snake_case_ ) setattr(snake_case_ , "additional_special_tokens_ids" , [additional_special_token_id] ) self.assertListEqual(getattr(snake_case_ , "additional_special_tokens" ) , [additional_special_token] ) self.assertListEqual(getattr(snake_case_ , "additional_special_tokens_ids" ) , [additional_special_token_id] ) def lowercase ( self : Any ): pass def lowercase ( self : List[Any] ): pass def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[Any] ): pass def lowercase ( self : List[Any] ): pass def lowercase ( self : int ): pass def lowercase ( self : int ): pass def lowercase ( self : Optional[Any] ): pass
22
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS model. \n''' '''This specifies the model architecture.''' ), ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
1
'''simple docstring''' from __future__ import annotations __SCREAMING_SNAKE_CASE :Union[str, Any] = '''Muhammad Umer Farooq''' __SCREAMING_SNAKE_CASE :Optional[int] = '''MIT''' __SCREAMING_SNAKE_CASE :Any = '''1.0.0''' __SCREAMING_SNAKE_CASE :Union[str, Any] = '''Muhammad Umer Farooq''' __SCREAMING_SNAKE_CASE :Optional[int] = '''[email protected]''' __SCREAMING_SNAKE_CASE :Any = '''Alpha''' import re from html.parser import HTMLParser from urllib import parse import requests class A_ ( lowerCAmelCase_ ): def __init__( self : Tuple , snake_case_ : str ): super().__init__() _UpperCAmelCase = [] _UpperCAmelCase = domain def lowercase ( self : List[Any] , snake_case_ : str , snake_case_ : list[tuple[str, str | None]] ): # Only parse the 'anchor' tag. if tag == "a": # Check the list of defined attributes. for name, value in attrs: # If href is defined, and not empty nor # print it. if name == "href" and value != "#" and value != "": # If not already in urls. if value not in self.urls: _UpperCAmelCase = parse.urljoin(self.domain , snake_case_ ) self.urls.append(snake_case_ ) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return ".".join(get_sub_domain_name(__lowercase ).split("." )[-2:] ) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return parse.urlparse(__lowercase ).netloc def UpperCAmelCase_ ( __lowercase : str = "https://github.com" ) -> list[str]: '''simple docstring''' _UpperCAmelCase = get_domain_name(__lowercase ) # Initialize the parser _UpperCAmelCase = Parser(__lowercase ) try: # Open URL _UpperCAmelCase = requests.get(__lowercase ) # pass the raw HTML to the parser to get links parser.feed(r.text ) # Get links and loop through _UpperCAmelCase = set() for link in parser.urls: # open URL. # read = requests.get(link) try: _UpperCAmelCase = requests.get(__lowercase ) # Get the valid email. _UpperCAmelCase = re.findall("[a-zA-Z0-9]+@" + domain , read.text ) # If not in list then append it. for email in emails: valid_emails.add(__lowercase ) except ValueError: pass except ValueError: raise SystemExit(1 ) # Finally return a sorted list of email addresses with no duplicates. return sorted(__lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = emails_from_url('''https://github.com''') print(F"{len(emails)} emails found:") print('''\n'''.join(sorted(emails)))
22
'''simple docstring''' import os from datetime import datetime as dt from github import Github __SCREAMING_SNAKE_CASE :str = [ '''good first issue''', '''feature request''', '''wip''', ] def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = Github(os.environ["GITHUB_TOKEN"] ) _UpperCAmelCase = g.get_repo("huggingface/accelerate" ) _UpperCAmelCase = repo.get_issues(state="open" ) for issue in open_issues: _UpperCAmelCase = sorted([comment for comment in issue.get_comments()] , key=lambda __lowercase : i.created_at , reverse=__lowercase ) _UpperCAmelCase = comments[0] if len(__lowercase ) > 0 else None _UpperCAmelCase = dt.utcnow() _UpperCAmelCase = (current_time - issue.updated_at).days _UpperCAmelCase = (current_time - issue.created_at).days if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and days_since_updated > 7 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Close issue since it has been 7 days of inactivity since bot mention. issue.edit(state="closed" ) elif ( days_since_updated > 23 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Add stale comment issue.create_comment( "This issue has been automatically marked as stale because it has not had " "recent activity. If you think this still needs to be addressed " "please comment on this thread.\n\nPlease note that issues that do not follow the " "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) " "are likely to be ignored." ) if __name__ == "__main__": main()
22
1
'''simple docstring''' import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel from diffusers.utils.testing_utils import ( enable_full_determinism, load_numpy, nightly, require_torch_gpu, slow, torch_device, ) from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Union[str, Any] = LDMTextToImagePipeline _lowerCamelCase : List[Any] = TEXT_TO_IMAGE_PARAMS - { """negative_prompt""", """negative_prompt_embeds""", """cross_attention_kwargs""", """prompt_embeds""", } _lowerCamelCase : List[str] = PipelineTesterMixin.required_optional_params - { """num_images_per_prompt""", """callback""", """callback_steps""", } _lowerCamelCase : str = TEXT_TO_IMAGE_BATCH_PARAMS _lowerCamelCase : List[Any] = False def lowercase ( self : Union[str, Any] ): torch.manual_seed(0 ) _UpperCAmelCase = 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 , ) _UpperCAmelCase = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="scaled_linear" , clip_sample=snake_case_ , set_alpha_to_one=snake_case_ , ) torch.manual_seed(0 ) _UpperCAmelCase = AutoencoderKL( block_out_channels=(3_2, 6_4) , in_channels=3 , out_channels=3 , down_block_types=("DownEncoderBlock2D", "DownEncoderBlock2D") , up_block_types=("UpDecoderBlock2D", "UpDecoderBlock2D") , latent_channels=4 , ) torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( 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 , ) _UpperCAmelCase = CLIPTextModel(snake_case_ ) _UpperCAmelCase = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" ) _UpperCAmelCase = { "unet": unet, "scheduler": scheduler, "vqvae": vae, "bert": text_encoder, "tokenizer": tokenizer, } return components def lowercase ( self : int , snake_case_ : str , snake_case_ : Tuple=0 ): if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = { "prompt": "A painting of a squirrel eating a burger", "generator": generator, "num_inference_steps": 2, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def lowercase ( self : Dict ): _UpperCAmelCase = "cpu" # ensure determinism for the device-dependent torch.Generator _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = LDMTextToImagePipeline(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_dummy_inputs(snake_case_ ) _UpperCAmelCase = pipe(**snake_case_ ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 1_6, 1_6, 3) _UpperCAmelCase = np.array([0.6_1_0_1, 0.6_1_5_6, 0.5_6_2_2, 0.4_8_9_5, 0.6_6_6_1, 0.3_8_0_4, 0.5_7_4_8, 0.6_1_3_6, 0.5_0_1_4] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-3 @slow @require_torch_gpu class A_ ( unittest.TestCase ): def lowercase ( self : int ): super().tearDown() gc.collect() torch.cuda.empty_cache() def lowercase ( self : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : int=torch.floataa , snake_case_ : Optional[Any]=0 ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) _UpperCAmelCase = np.random.RandomState(snake_case_ ).standard_normal((1, 4, 3_2, 3_2) ) _UpperCAmelCase = torch.from_numpy(snake_case_ ).to(device=snake_case_ , dtype=snake_case_ ) _UpperCAmelCase = { "prompt": "A painting of a squirrel eating a burger", "latents": latents, "generator": generator, "num_inference_steps": 3, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def lowercase ( self : List[Any] ): _UpperCAmelCase = LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256" ).to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_inputs(snake_case_ ) _UpperCAmelCase = pipe(**snake_case_ ).images _UpperCAmelCase = image[0, -3:, -3:, -1].flatten() assert image.shape == (1, 2_5_6, 2_5_6, 3) _UpperCAmelCase = np.array([0.5_1_8_2_5, 0.5_2_8_5_0, 0.5_2_5_4_3, 0.5_4_2_5_8, 0.5_2_3_0_4, 0.5_2_5_6_9, 0.5_4_3_6_3, 0.5_5_2_7_6, 0.5_6_8_7_8] ) _UpperCAmelCase = np.abs(expected_slice - image_slice ).max() assert max_diff < 1e-3 @nightly @require_torch_gpu class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): super().tearDown() gc.collect() torch.cuda.empty_cache() def lowercase ( self : Dict , snake_case_ : Dict , snake_case_ : int=torch.floataa , snake_case_ : Dict=0 ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) _UpperCAmelCase = np.random.RandomState(snake_case_ ).standard_normal((1, 4, 3_2, 3_2) ) _UpperCAmelCase = torch.from_numpy(snake_case_ ).to(device=snake_case_ , dtype=snake_case_ ) _UpperCAmelCase = { "prompt": "A painting of a squirrel eating a burger", "latents": latents, "generator": generator, "num_inference_steps": 5_0, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def lowercase ( self : Tuple ): _UpperCAmelCase = LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256" ).to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_inputs(snake_case_ ) _UpperCAmelCase = pipe(**snake_case_ ).images[0] _UpperCAmelCase = load_numpy( "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy" ) _UpperCAmelCase = np.abs(expected_image - image ).max() assert max_diff < 1e-3
22
'''simple docstring''' import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( "files" , [ ["full:README.md", "dataset_infos.json"], ["empty:README.md", "dataset_infos.json"], ["dataset_infos.json"], ["full:README.md"], ] , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : int ) -> int: '''simple docstring''' _UpperCAmelCase = tmp_path_factory.mktemp("dset_infos_dir" ) if "full:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("---\ndataset_info:\n dataset_size: 42\n---" ) if "empty:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("" ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / "dataset_infos.json" , "w" ) as f: f.write("{\"default\": {\"dataset_size\": 42}}" ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( "dataset_info" , [ DatasetInfo(), DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ), ] , ) def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : DatasetInfo ) -> Any: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_info.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfo.from_directory(__lowercase ) assert dataset_info == reloaded assert os.path.exists(os.path.join(__lowercase , "dataset_info.json" ) ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = DatasetInfo( description="foo" , citation="bar" , homepage="https://foo.bar" , license="CC0" , features=Features({"a": Value("int32" )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train", "num_examples": 42}] , download_checksums={} , download_size=1337 , post_processing_size=442 , dataset_size=1234 , size_in_bytes=1337 + 442 + 1234 , ) _UpperCAmelCase = dataset_info._to_yaml_dict() assert sorted(__lowercase ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _UpperCAmelCase = yaml.safe_dump(__lowercase ) _UpperCAmelCase = yaml.safe_load(__lowercase ) assert dataset_info_yaml_dict == reloaded def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = DatasetInfo() _UpperCAmelCase = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( "dataset_infos_dict" , [ DatasetInfosDict(), DatasetInfosDict({"default": DatasetInfo()} ), DatasetInfosDict({"my_config_name": DatasetInfo()} ), DatasetInfosDict( { "default": DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ) } ), DatasetInfosDict( { "v1": DatasetInfo(dataset_size=42 ), "v2": DatasetInfo(dataset_size=1337 ), } ), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : DatasetInfosDict ) -> Dict: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_infos_dict.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _UpperCAmelCase = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _UpperCAmelCase = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(__lowercase , "README.md" ) )
22
1
'''simple docstring''' # Copyright 2021 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import warnings from typing import List from unittest.mock import Mock import torch from torch.utils.data import DataLoader, IterableDataset, TensorDataset from accelerate.accelerator import Accelerator from accelerate.utils.dataclasses import DistributedType class A_ ( lowerCAmelCase_ ): def __init__( self : Union[str, Any] , snake_case_ : Union[str, Any] ): _UpperCAmelCase = data def __iter__( self : Any ): for element in self.data: yield element def UpperCAmelCase_ ( __lowercase : Optional[int]=True ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = Accelerator(even_batches=__lowercase ) assert accelerator.num_processes == 2, "this script expects that two GPUs are available" return accelerator def UpperCAmelCase_ ( __lowercase : Accelerator , __lowercase : int , __lowercase : int , __lowercase : bool = False ) -> Tuple: '''simple docstring''' if iterable: _UpperCAmelCase = DummyIterableDataset(torch.as_tensor(range(__lowercase ) ) ) else: _UpperCAmelCase = TensorDataset(torch.as_tensor(range(__lowercase ) ) ) _UpperCAmelCase = DataLoader(__lowercase , batch_size=__lowercase ) _UpperCAmelCase = accelerator.prepare(__lowercase ) return dl def UpperCAmelCase_ ( __lowercase : Accelerator , __lowercase : int , __lowercase : int , __lowercase : List[int] , __lowercase : List[int] , ) -> Tuple: '''simple docstring''' _UpperCAmelCase = create_dataloader(accelerator=__lowercase , dataset_size=__lowercase , batch_size=__lowercase ) _UpperCAmelCase = [len(batch[0] ) for batch in dl] if accelerator.process_index == 0: assert batch_sizes == process_0_expected_batch_sizes elif accelerator.process_index == 1: assert batch_sizes == process_1_expected_batch_sizes def UpperCAmelCase_ ( ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = create_accelerator() # without padding, we would expect a different number of batches verify_dataloader_batch_sizes( __lowercase , dataset_size=3 , batch_size=1 , process_0_expected_batch_sizes=[1, 1] , process_1_expected_batch_sizes=[1, 1] , ) # without padding, we would expect the same number of batches, but different sizes verify_dataloader_batch_sizes( __lowercase , dataset_size=7 , batch_size=2 , process_0_expected_batch_sizes=[2, 2] , process_1_expected_batch_sizes=[2, 2] , ) def UpperCAmelCase_ ( ) -> int: '''simple docstring''' _UpperCAmelCase = create_accelerator(even_batches=__lowercase ) verify_dataloader_batch_sizes( __lowercase , dataset_size=3 , batch_size=1 , process_0_expected_batch_sizes=[1, 1] , process_1_expected_batch_sizes=[1] , ) verify_dataloader_batch_sizes( __lowercase , dataset_size=7 , batch_size=2 , process_0_expected_batch_sizes=[2, 2] , process_1_expected_batch_sizes=[2, 1] , ) def UpperCAmelCase_ ( ) -> int: '''simple docstring''' _UpperCAmelCase = create_accelerator(even_batches=__lowercase ) _UpperCAmelCase = torch.nn.Linear(1 , 1 ) _UpperCAmelCase = accelerator.prepare(__lowercase ) _UpperCAmelCase = create_dataloader(__lowercase , dataset_size=3 , batch_size=1 ) _UpperCAmelCase = [] with accelerator.join_uneven_inputs([ddp_model] ): for batch_idx, batch in enumerate(__lowercase ): _UpperCAmelCase = ddp_model(batch[0].float() ) _UpperCAmelCase = output.sum() loss.backward() batch_idxs.append(__lowercase ) accelerator.wait_for_everyone() if accelerator.process_index == 0: assert batch_idxs == [0, 1] elif accelerator.process_index == 1: assert batch_idxs == [0] def UpperCAmelCase_ ( __lowercase : List[Any] ) -> Tuple: '''simple docstring''' with warnings.catch_warnings(record=__lowercase ) as w: with accelerator.join_uneven_inputs([Mock()] ): pass assert issubclass(w[-1].category , __lowercase ) assert "only supported for multi-GPU" in str(w[-1].message ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = create_accelerator(even_batches=__lowercase ) _UpperCAmelCase = torch.nn.Linear(1 , 1 ) _UpperCAmelCase = accelerator.prepare(__lowercase ) _UpperCAmelCase = create_dataloader(__lowercase , dataset_size=3 , batch_size=1 ) _UpperCAmelCase = create_dataloader(__lowercase , dataset_size=3 , batch_size=1 ) with accelerator.join_uneven_inputs([ddp_model] , even_batches=__lowercase ): _UpperCAmelCase = train_dl.batch_sampler.even_batches _UpperCAmelCase = valid_dl.batch_sampler.even_batches assert train_dl_overridden_value == overridden_even_batches assert valid_dl_overridden_value == overridden_even_batches assert train_dl.batch_sampler.even_batches == default_even_batches assert valid_dl.batch_sampler.even_batches == default_even_batches def UpperCAmelCase_ ( ) -> Dict: '''simple docstring''' _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = create_accelerator(even_batches=__lowercase ) _UpperCAmelCase = torch.nn.Linear(1 , 1 ) _UpperCAmelCase = accelerator.prepare(__lowercase ) create_dataloader(__lowercase , dataset_size=3 , batch_size=1 , iterable=__lowercase ) _UpperCAmelCase = create_dataloader(__lowercase , dataset_size=3 , batch_size=1 ) with warnings.catch_warnings(): warnings.filterwarnings("ignore" ) try: with accelerator.join_uneven_inputs([ddp_model] , even_batches=__lowercase ): _UpperCAmelCase = batch_dl.batch_sampler.even_batches except AttributeError: # ensure attribute error is not raised when processing iterable dl raise AssertionError assert batch_dl_overridden_value == overridden_even_batches assert batch_dl.batch_sampler.even_batches == default_even_batches def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = create_accelerator() _UpperCAmelCase = torch.nn.Linear(1 , 1 ) _UpperCAmelCase = accelerator.prepare(__lowercase ) create_dataloader(__lowercase , dataset_size=3 , batch_size=1 , iterable=__lowercase ) with warnings.catch_warnings(record=__lowercase ) as w: with accelerator.join_uneven_inputs([ddp_model] , even_batches=__lowercase ): pass assert issubclass(w[-1].category , __lowercase ) assert "only supported for map-style datasets" in str(w[-1].message ) def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = create_accelerator() accelerator.print("Test that even_batches variable ensures uniform batches across processes" ) test_default_ensures_even_batch_sizes() accelerator.print("Run tests with even_batches disabled" ) test_can_disable_even_batches() accelerator.print("Test joining uneven inputs" ) test_can_join_uneven_inputs() accelerator.print("Test overriding even_batches when joining uneven inputs" ) test_join_can_override_even_batches() accelerator.print("Test overriding even_batches for mixed dataloader types" ) test_join_can_override_for_mixed_type_dataloaders() accelerator.print("Test overriding even_batches raises a warning for iterable dataloaders" ) test_join_raises_warning_for_iterable_when_overriding_even_batches() accelerator.print("Test join with non DDP distributed raises warning" ) _UpperCAmelCase = accelerator.state.distributed_type _UpperCAmelCase = DistributedType.FSDP test_join_raises_warning_for_non_ddp_distributed(__lowercase ) _UpperCAmelCase = original_state if __name__ == "__main__": main()
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
1
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
1
'''simple docstring''' from torch import nn class A_ ( nn.Module ): def __init__( self : Dict , snake_case_ : Tuple , snake_case_ : Any ): super().__init__() _UpperCAmelCase = class_size _UpperCAmelCase = embed_size # self.mlp1 = nn.Linear(embed_size, embed_size) # self.mlp2 = (nn.Linear(embed_size, class_size)) _UpperCAmelCase = nn.Linear(snake_case_ , snake_case_ ) def lowercase ( self : int , snake_case_ : int ): # hidden_state = nn.functional.relu(self.mlp1(hidden_state)) # hidden_state = self.mlp2(hidden_state) _UpperCAmelCase = self.mlp(snake_case_ ) return logits
22
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 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 lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 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], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 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]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
1
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
'''simple docstring''' import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class A_ ( unittest.TestCase ): def lowercase ( self : int ): _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = BlipImageProcessor() _UpperCAmelCase = BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-BertModel" ) _UpperCAmelCase = BlipProcessor(snake_case_ , snake_case_ ) processor.save_pretrained(self.tmpdirname ) def lowercase ( self : Tuple , **snake_case_ : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).tokenizer def lowercase ( self : Dict , **snake_case_ : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).image_processor def lowercase ( self : int ): shutil.rmtree(self.tmpdirname ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] _UpperCAmelCase = [Image.fromarray(np.moveaxis(snake_case_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def lowercase ( self : int ): _UpperCAmelCase = BlipProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) _UpperCAmelCase = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) _UpperCAmelCase = self.get_image_processor(do_normalize=snake_case_ , padding_value=1.0 ) _UpperCAmelCase = BlipProcessor.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_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="np" ) _UpperCAmelCase = 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 lowercase ( self : Optional[int] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = processor(text=snake_case_ ) _UpperCAmelCase = tokenizer(snake_case_ , return_token_type_ids=snake_case_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] ) # test if it raises when no input is passed with pytest.raises(snake_case_ ): processor() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(snake_case_ ) _UpperCAmelCase = tokenizer.batch_decode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] )
22
1
'''simple docstring''' import requests __SCREAMING_SNAKE_CASE :Optional[Any] = '''https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey=''' def UpperCAmelCase_ ( __lowercase : str ) -> None: '''simple docstring''' _UpperCAmelCase = requests.get(_NEWS_API + bbc_news_api_key ).json() # each article in the list is a dict for i, article in enumerate(bbc_news_page["articles"] , 1 ): print(f'{i}.) {article["title"]}' ) if __name__ == "__main__": fetch_bbc_news(bbc_news_api_key='''<Your BBC News API key goes here>''')
22
'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def UpperCAmelCase_ ( __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.size _UpperCAmelCase , _UpperCAmelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 _UpperCAmelCase = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) _UpperCAmelCase = np.array(__lowercase ).astype(np.floataa ) / 255.0 _UpperCAmelCase = image[None].transpose(0 , 3 , 1 , 2 ) _UpperCAmelCase = torch.from_numpy(__lowercase ) return 2.0 * image - 1.0 class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , snake_case_ : VQModel , snake_case_ : UNetaDModel , snake_case_ : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ): super().__init__() self.register_modules(vqvae=snake_case_ , unet=snake_case_ , scheduler=snake_case_ ) @torch.no_grad() def __call__( self : Any , snake_case_ : Union[torch.Tensor, PIL.Image.Image] = None , snake_case_ : Optional[int] = 1 , snake_case_ : Optional[int] = 1_0_0 , snake_case_ : Optional[float] = 0.0 , snake_case_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case_ : Optional[str] = "pil" , snake_case_ : bool = True , ): if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = 1 elif isinstance(snake_case_ , torch.Tensor ): _UpperCAmelCase = image.shape[0] else: raise ValueError(f'`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(snake_case_ )}' ) if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = preprocess(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image _UpperCAmelCase = (batch_size, self.unet.config.in_channels // 2, height, width) _UpperCAmelCase = next(self.unet.parameters() ).dtype _UpperCAmelCase = randn_tensor(snake_case_ , generator=snake_case_ , device=self.device , dtype=snake_case_ ) _UpperCAmelCase = image.to(device=self.device , dtype=snake_case_ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(snake_case_ , device=self.device ) _UpperCAmelCase = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler _UpperCAmelCase = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _UpperCAmelCase = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) _UpperCAmelCase = {} if accepts_eta: _UpperCAmelCase = eta for t in self.progress_bar(snake_case_ ): # concat latents and low resolution image in the channel dimension. _UpperCAmelCase = torch.cat([latents, image] , dim=1 ) _UpperCAmelCase = self.scheduler.scale_model_input(snake_case_ , snake_case_ ) # predict the noise residual _UpperCAmelCase = self.unet(snake_case_ , snake_case_ ).sample # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ).prev_sample # decode the image latents with the VQVAE _UpperCAmelCase = self.vqvae.decode(snake_case_ ).sample _UpperCAmelCase = torch.clamp(snake_case_ , -1.0 , 1.0 ) _UpperCAmelCase = image / 2 + 0.5 _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _UpperCAmelCase = self.numpy_to_pil(snake_case_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case_ )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __SCREAMING_SNAKE_CASE :Union[str, Any] = { '''configuration_canine''': ['''CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CanineConfig'''], '''tokenization_canine''': ['''CanineTokenizer'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Tuple = [ '''CANINE_PRETRAINED_MODEL_ARCHIVE_LIST''', '''CanineForMultipleChoice''', '''CanineForQuestionAnswering''', '''CanineForSequenceClassification''', '''CanineForTokenClassification''', '''CanineLayer''', '''CanineModel''', '''CaninePreTrainedModel''', '''load_tf_weights_in_canine''', ] if TYPE_CHECKING: from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig from .tokenization_canine import CanineTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_canine import ( CANINE_PRETRAINED_MODEL_ARCHIVE_LIST, CanineForMultipleChoice, CanineForQuestionAnswering, CanineForSequenceClassification, CanineForTokenClassification, CanineLayer, CanineModel, CaninePreTrainedModel, load_tf_weights_in_canine, ) else: import sys __SCREAMING_SNAKE_CASE :int = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
1
'''simple docstring''' from __future__ import annotations def UpperCAmelCase_ ( __lowercase : float , __lowercase : float , __lowercase : float ) -> float: '''simple docstring''' if days_between_payments <= 0: raise ValueError("days_between_payments must be > 0" ) if daily_interest_rate < 0: raise ValueError("daily_interest_rate must be >= 0" ) if principal <= 0: raise ValueError("principal must be > 0" ) return principal * daily_interest_rate * days_between_payments def UpperCAmelCase_ ( __lowercase : float , __lowercase : float , __lowercase : float , ) -> float: '''simple docstring''' if number_of_compounding_periods <= 0: raise ValueError("number_of_compounding_periods must be > 0" ) if nominal_annual_interest_rate_percentage < 0: raise ValueError("nominal_annual_interest_rate_percentage must be >= 0" ) if principal <= 0: raise ValueError("principal must be > 0" ) return principal * ( (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods - 1 ) def UpperCAmelCase_ ( __lowercase : float , __lowercase : float , __lowercase : float , ) -> float: '''simple docstring''' if number_of_years <= 0: raise ValueError("number_of_years must be > 0" ) if nominal_annual_percentage_rate < 0: raise ValueError("nominal_annual_percentage_rate must be >= 0" ) if principal <= 0: raise ValueError("principal must be > 0" ) return compound_interest( __lowercase , nominal_annual_percentage_rate / 365 , number_of_years * 365 ) if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import io import json import unittest from parameterized import parameterized from transformers import FSMTForConditionalGeneration, FSMTTokenizer from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device from utils import calculate_bleu __SCREAMING_SNAKE_CASE :Tuple = get_tests_dir() + '''/test_data/fsmt/fsmt_val_data.json''' with io.open(filename, '''r''', encoding='''utf-8''') as f: __SCREAMING_SNAKE_CASE :Tuple = json.load(f) @require_torch class A_ ( unittest.TestCase ): def lowercase ( self : str , snake_case_ : Optional[Any] ): return FSMTTokenizer.from_pretrained(snake_case_ ) def lowercase ( self : str , snake_case_ : Optional[int] ): _UpperCAmelCase = FSMTForConditionalGeneration.from_pretrained(snake_case_ ).to(snake_case_ ) if torch_device == "cuda": model.half() return model @parameterized.expand( [ ["en-ru", 2_6.0], ["ru-en", 2_2.0], ["en-de", 2_2.0], ["de-en", 2_9.0], ] ) @slow def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[Any] ): # note: this test is not testing the best performance since it only evals a small batch # but it should be enough to detect a regression in the output quality _UpperCAmelCase = f'facebook/wmt19-{pair}' _UpperCAmelCase = self.get_tokenizer(snake_case_ ) _UpperCAmelCase = self.get_model(snake_case_ ) _UpperCAmelCase = bleu_data[pair]["src"] _UpperCAmelCase = bleu_data[pair]["tgt"] _UpperCAmelCase = tokenizer(snake_case_ , return_tensors="pt" , truncation=snake_case_ , padding="longest" ).to(snake_case_ ) _UpperCAmelCase = model.generate( input_ids=batch.input_ids , num_beams=8 , ) _UpperCAmelCase = tokenizer.batch_decode( snake_case_ , skip_special_tokens=snake_case_ , clean_up_tokenization_spaces=snake_case_ ) _UpperCAmelCase = calculate_bleu(snake_case_ , snake_case_ ) print(snake_case_ ) self.assertGreaterEqual(scores["bleu"] , snake_case_ )
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' # Imports import numpy as np class A_ : def __init__( self : str , snake_case_ : int=None , snake_case_ : Any=None , snake_case_ : str=None , snake_case_ : Tuple=None , snake_case_ : Any=None ): self.set_matricies(red=snake_case_ , green=snake_case_ , blue=snake_case_ , red_edge=snake_case_ , nir=snake_case_ ) def lowercase ( self : List[Any] , snake_case_ : Dict=None , snake_case_ : int=None , snake_case_ : Any=None , snake_case_ : Union[str, Any]=None , snake_case_ : Dict=None ): if red is not None: _UpperCAmelCase = red if green is not None: _UpperCAmelCase = green if blue is not None: _UpperCAmelCase = blue if red_edge is not None: _UpperCAmelCase = red_edge if nir is not None: _UpperCAmelCase = nir return True def lowercase ( self : Any , snake_case_ : Optional[int]="" , snake_case_ : Any=None , snake_case_ : Tuple=None , snake_case_ : Optional[Any]=None , snake_case_ : Dict=None , snake_case_ : Union[str, Any]=None ): self.set_matricies(red=snake_case_ , green=snake_case_ , blue=snake_case_ , red_edge=snake_case_ , nir=snake_case_ ) _UpperCAmelCase = { "ARVI2": self.arvaa, "CCCI": self.ccci, "CVI": self.cvi, "GLI": self.gli, "NDVI": self.ndvi, "BNDVI": self.bndvi, "redEdgeNDVI": self.red_edge_ndvi, "GNDVI": self.gndvi, "GBNDVI": self.gbndvi, "GRNDVI": self.grndvi, "RBNDVI": self.rbndvi, "PNDVI": self.pndvi, "ATSAVI": self.atsavi, "BWDRVI": self.bwdrvi, "CIgreen": self.ci_green, "CIrededge": self.ci_rededge, "CI": self.ci, "CTVI": self.ctvi, "GDVI": self.gdvi, "EVI": self.evi, "GEMI": self.gemi, "GOSAVI": self.gosavi, "GSAVI": self.gsavi, "Hue": self.hue, "IVI": self.ivi, "IPVI": self.ipvi, "I": self.i, "RVI": self.rvi, "MRVI": self.mrvi, "MSAVI": self.m_savi, "NormG": self.norm_g, "NormNIR": self.norm_nir, "NormR": self.norm_r, "NGRDI": self.ngrdi, "RI": self.ri, "S": self.s, "IF": self._if, "DVI": self.dvi, "TVI": self.tvi, "NDRE": self.ndre, } try: return funcs[index]() except KeyError: print("Index not in the list!" ) return False def lowercase ( self : Tuple ): return -0.1_8 + (1.1_7 * ((self.nir - self.red) / (self.nir + self.red))) def lowercase ( self : str ): return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / ( (self.nir - self.red) / (self.nir + self.red) ) def lowercase ( self : Optional[Any] ): return self.nir * (self.red / (self.green**2)) def lowercase ( self : Tuple ): return (2 * self.green - self.red - self.blue) / ( 2 * self.green + self.red + self.blue ) def lowercase ( self : Optional[int] ): return (self.nir - self.red) / (self.nir + self.red) def lowercase ( self : List[Any] ): return (self.nir - self.blue) / (self.nir + self.blue) def lowercase ( self : List[str] ): return (self.redEdge - self.red) / (self.redEdge + self.red) def lowercase ( self : str ): return (self.nir - self.green) / (self.nir + self.green) def lowercase ( self : str ): return (self.nir - (self.green + self.blue)) / ( self.nir + (self.green + self.blue) ) def lowercase ( self : str ): return (self.nir - (self.green + self.red)) / ( self.nir + (self.green + self.red) ) def lowercase ( self : int ): return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red)) def lowercase ( self : List[str] ): return (self.nir - (self.green + self.red + self.blue)) / ( self.nir + (self.green + self.red + self.blue) ) def lowercase ( self : int , snake_case_ : List[Any]=0.0_8 , snake_case_ : Any=1.2_2 , snake_case_ : List[str]=0.0_3 ): return a * ( (self.nir - a * self.red - b) / (a * self.nir + self.red - a * b + x * (1 + a**2)) ) def lowercase ( self : str ): return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue) def lowercase ( self : Optional[Any] ): return (self.nir / self.green) - 1 def lowercase ( self : List[str] ): return (self.nir / self.redEdge) - 1 def lowercase ( self : str ): return (self.red - self.blue) / self.red def lowercase ( self : List[Any] ): _UpperCAmelCase = self.ndvi() return ((ndvi + 0.5) / (abs(ndvi + 0.5 ))) * (abs(ndvi + 0.5 ) ** (1 / 2)) def lowercase ( self : Dict ): return self.nir - self.green def lowercase ( self : List[Any] ): return 2.5 * ( (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1) ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / ( self.nir + self.red + 0.5 ) return n * (1 - 0.2_5 * n) - (self.red - 0.1_2_5) / (1 - self.red) def lowercase ( self : Optional[int] , snake_case_ : Optional[int]=0.1_6 ): return (self.nir - self.green) / (self.nir + self.green + y) def lowercase ( self : Optional[int] , snake_case_ : int=0.5 ): return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n) def lowercase ( self : Optional[int] ): return np.arctan( ((2 * self.red - self.green - self.blue) / 3_0.5) * (self.green - self.blue) ) def lowercase ( self : Any , snake_case_ : Tuple=None , snake_case_ : Tuple=None ): return (self.nir - b) / (a * self.red) def lowercase ( self : Optional[Any] ): return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1) def lowercase ( self : List[Any] ): return (self.red + self.green + self.blue) / 3_0.5 def lowercase ( self : str ): return self.nir / self.red def lowercase ( self : Union[str, Any] ): return (self.rvi() - 1) / (self.rvi() + 1) def lowercase ( self : Optional[int] ): return ( (2 * self.nir + 1) - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2) ) / 2 def lowercase ( self : Dict ): return self.green / (self.nir + self.red + self.green) def lowercase ( self : List[Any] ): return self.nir / (self.nir + self.red + self.green) def lowercase ( self : Union[str, Any] ): return self.red / (self.nir + self.red + self.green) def lowercase ( self : List[str] ): return (self.green - self.red) / (self.green + self.red) def lowercase ( self : List[str] ): return (self.red - self.green) / (self.red + self.green) def lowercase ( self : Tuple ): _UpperCAmelCase = np.max([np.max(self.red ), np.max(self.green ), np.max(self.blue )] ) _UpperCAmelCase = np.min([np.min(self.red ), np.min(self.green ), np.min(self.blue )] ) return (max_value - min_value) / max_value def lowercase ( self : List[Any] ): return (2 * self.red - self.green - self.blue) / (self.green - self.blue) def lowercase ( self : Tuple ): return self.nir / self.red def lowercase ( self : Union[str, Any] ): return (self.ndvi() + 0.5) ** (1 / 2) def lowercase ( self : Any ): return (self.nir - self.redEdge) / (self.nir + self.redEdge)
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' import math from collections.abc import Iterator from itertools import takewhile def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(__lowercase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def UpperCAmelCase_ ( ) -> Iterator[int]: '''simple docstring''' _UpperCAmelCase = 2 while True: if is_prime(__lowercase ): yield num num += 1 def UpperCAmelCase_ ( __lowercase : int = 200_0000 ) -> int: '''simple docstring''' return sum(takewhile(lambda __lowercase : x < n , prime_generator() ) ) if __name__ == "__main__": print(F"{solution() = }")
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> bool: '''simple docstring''' _UpperCAmelCase = len(__lowercase ) + 1 _UpperCAmelCase = len(__lowercase ) + 1 # dp is a 2d matrix where dp[i][j] denotes whether prefix string of # length i of input_string matches with prefix string of length j of # given pattern. # "dp" stands for dynamic programming. _UpperCAmelCase = [[0 for i in range(__lowercase )] for j in range(__lowercase )] # since string of zero length match pattern of zero length _UpperCAmelCase = 1 # since pattern of zero length will never match with string of non-zero length for i in range(1 , __lowercase ): _UpperCAmelCase = 0 # since string of zero length will match with pattern where there # is at least one * alternatively for j in range(1 , __lowercase ): _UpperCAmelCase = dp[0][j - 2] if pattern[j - 1] == "*" else 0 # now using bottom-up approach to find for all remaining lengths for i in range(1 , __lowercase ): for j in range(1 , __lowercase ): if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".": _UpperCAmelCase = dp[i - 1][j - 1] elif pattern[j - 1] == "*": if dp[i][j - 2] == 1: _UpperCAmelCase = 1 elif pattern[j - 2] in (input_string[i - 1], "."): _UpperCAmelCase = dp[i - 1][j] else: _UpperCAmelCase = 0 else: _UpperCAmelCase = 0 return bool(dp[-1][-1] ) if __name__ == "__main__": import doctest doctest.testmod() # inputing the strings # input_string = input("input a string :") # pattern = input("input a pattern :") __SCREAMING_SNAKE_CASE :str = '''aab''' __SCREAMING_SNAKE_CASE :Optional[Any] = '''c*a*b''' # using function to check whether given string matches the given pattern if match_pattern(input_string, pattern): print(F"{input_string} matches the given pattern {pattern}") else: print(F"{input_string} does not match with the given pattern {pattern}")
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> list: '''simple docstring''' _UpperCAmelCase = len(__lowercase ) _UpperCAmelCase = [] for i in range(len(__lowercase ) - pat_len + 1 ): _UpperCAmelCase = True for j in range(__lowercase ): if s[i + j] != pattern[j]: _UpperCAmelCase = False break if match_found: position.append(__lowercase ) return position if __name__ == "__main__": assert naive_pattern_search('''ABCDEFG''', '''DE''') == [3] print(naive_pattern_search('''ABAAABCDBBABCDDEBCABC''', '''ABC'''))
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' from __future__ import annotations from collections import Counter from random import random class A_ : def __init__( self : List[str] ): _UpperCAmelCase = {} def lowercase ( self : int , snake_case_ : str ): _UpperCAmelCase = {} def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : str , snake_case_ : float ): if nodea not in self.connections: self.add_node(snake_case_ ) if nodea not in self.connections: self.add_node(snake_case_ ) _UpperCAmelCase = probability def lowercase ( self : Tuple ): return list(self.connections ) def lowercase ( self : Dict , snake_case_ : str ): _UpperCAmelCase = 0 _UpperCAmelCase = random() for dest in self.connections[node]: current_probability += self.connections[node][dest] if current_probability > random_value: return dest return "" def UpperCAmelCase_ ( __lowercase : str , __lowercase : list[tuple[str, str, float]] , __lowercase : int ) -> dict[str, int]: '''simple docstring''' _UpperCAmelCase = MarkovChainGraphUndirectedUnweighted() for nodea, nodea, probability in transitions: graph.add_transition_probability(__lowercase , __lowercase , __lowercase ) _UpperCAmelCase = Counter(graph.get_nodes() ) _UpperCAmelCase = start for _ in range(__lowercase ): _UpperCAmelCase = graph.transition(__lowercase ) visited[node] += 1 return visited if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # 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(__lowercase ) )
22
1
'''simple docstring''' import unittest from transformers import XLMConfig, 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 ( XLMForMultipleChoice, XLMForQuestionAnswering, XLMForQuestionAnsweringSimple, XLMForSequenceClassification, XLMForTokenClassification, XLMModel, XLMWithLMHeadModel, ) from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST class A_ : def __init__( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[int]=1_3 , snake_case_ : Dict=7 , snake_case_ : List[Any]=True , snake_case_ : Union[str, Any]=True , snake_case_ : Any=True , snake_case_ : str=True , snake_case_ : str=True , snake_case_ : int=False , snake_case_ : Union[str, Any]=False , snake_case_ : List[str]=False , snake_case_ : List[Any]=2 , snake_case_ : List[str]=9_9 , snake_case_ : str=0 , snake_case_ : List[str]=3_2 , snake_case_ : str=5 , snake_case_ : Optional[int]=4 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : List[str]=0.1 , snake_case_ : List[Any]=5_1_2 , snake_case_ : Dict=2 , snake_case_ : str=0.0_2 , snake_case_ : List[Any]=2 , snake_case_ : Tuple=4 , snake_case_ : Union[str, Any]="last" , snake_case_ : List[Any]=True , snake_case_ : List[Any]=None , snake_case_ : Optional[int]=0 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_lengths _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = gelu_activation _UpperCAmelCase = sinusoidal_embeddings _UpperCAmelCase = causal _UpperCAmelCase = asm _UpperCAmelCase = n_langs _UpperCAmelCase = vocab_size _UpperCAmelCase = n_special _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = summary_type _UpperCAmelCase = use_proj _UpperCAmelCase = scope _UpperCAmelCase = bos_token_id def lowercase ( self : Dict ): _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_input_lengths: _UpperCAmelCase = ( ids_tensor([self.batch_size] , vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.n_langs ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , 2 ).float() _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = self.get_config() return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def lowercase ( self : Optional[int] ): return XLMConfig( vocab_size=self.vocab_size , n_special=self.n_special , emb_dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , gelu_activation=self.gelu_activation , sinusoidal_embeddings=self.sinusoidal_embeddings , asm=self.asm , causal=self.causal , n_langs=self.n_langs , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , summary_type=self.summary_type , use_proj=self.use_proj , num_labels=self.num_labels , bos_token_id=self.bos_token_id , ) def lowercase ( self : Any , snake_case_ : Dict , snake_case_ : Tuple , snake_case_ : List[Any] , snake_case_ : Tuple , snake_case_ : Tuple , snake_case_ : Union[str, Any] , snake_case_ : Any , snake_case_ : List[Any] , snake_case_ : List[Any] , ): _UpperCAmelCase = XLMModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , lengths=snake_case_ , langs=snake_case_ ) _UpperCAmelCase = model(snake_case_ , langs=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowercase ( self : Optional[Any] , snake_case_ : List[Any] , snake_case_ : Any , snake_case_ : List[Any] , snake_case_ : Any , snake_case_ : Dict , snake_case_ : Optional[Any] , snake_case_ : Dict , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] , ): _UpperCAmelCase = XLMWithLMHeadModel(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , token_type_ids=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) ) def lowercase ( self : int , snake_case_ : List[str] , snake_case_ : Dict , snake_case_ : Optional[Any] , snake_case_ : str , snake_case_ : Any , snake_case_ : List[str] , snake_case_ : Any , snake_case_ : List[str] , snake_case_ : List[str] , ): _UpperCAmelCase = XLMForQuestionAnsweringSimple(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) _UpperCAmelCase = model(snake_case_ , start_positions=snake_case_ , end_positions=snake_case_ ) _UpperCAmelCase = outputs 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 lowercase ( self : Optional[Any] , snake_case_ : Dict , snake_case_ : Any , snake_case_ : List[Any] , snake_case_ : List[Any] , snake_case_ : Union[str, Any] , snake_case_ : str , snake_case_ : List[str] , snake_case_ : Optional[int] , snake_case_ : List[Any] , ): _UpperCAmelCase = XLMForQuestionAnswering(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) _UpperCAmelCase = model( snake_case_ , start_positions=snake_case_ , end_positions=snake_case_ , cls_index=snake_case_ , is_impossible=snake_case_ , p_mask=snake_case_ , ) _UpperCAmelCase = model( snake_case_ , start_positions=snake_case_ , end_positions=snake_case_ , cls_index=snake_case_ , is_impossible=snake_case_ , ) ((_UpperCAmelCase) , ) = result_with_labels.to_tuple() _UpperCAmelCase = model(snake_case_ , start_positions=snake_case_ , end_positions=snake_case_ ) ((_UpperCAmelCase) , ) = result_with_labels.to_tuple() self.parent.assertEqual(result_with_labels.loss.shape , () ) self.parent.assertEqual(result.start_top_log_probs.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual(result.start_top_index.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual( result.end_top_log_probs.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual( result.end_top_index.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual(result.cls_logits.shape , (self.batch_size,) ) def lowercase ( self : Any , snake_case_ : Union[str, Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : List[Any] , snake_case_ : str , ): _UpperCAmelCase = XLMForSequenceClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) _UpperCAmelCase = model(snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def lowercase ( self : Tuple , snake_case_ : int , snake_case_ : int , snake_case_ : Optional[int] , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[int] , snake_case_ : Optional[Any] , snake_case_ : Union[str, Any] , ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = XLMForTokenClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def lowercase ( self : int , snake_case_ : List[Any] , snake_case_ : str , snake_case_ : Union[str, Any] , snake_case_ : List[str] , snake_case_ : Optional[int] , snake_case_ : str , snake_case_ : Optional[Any] , snake_case_ : List[Any] , snake_case_ : Optional[int] , ): _UpperCAmelCase = self.num_choices _UpperCAmelCase = XLMForMultipleChoice(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = 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 lowercase ( self : Optional[int] ): _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths} return config, inputs_dict @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Union[str, Any] = ( ( XLMModel, XLMWithLMHeadModel, XLMForQuestionAnswering, XLMForSequenceClassification, XLMForQuestionAnsweringSimple, XLMForTokenClassification, XLMForMultipleChoice, ) if is_torch_available() else () ) _lowerCamelCase : Optional[int] = ( (XLMWithLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _lowerCamelCase : Optional[Any] = ( { """feature-extraction""": XLMModel, """fill-mask""": XLMWithLMHeadModel, """question-answering""": XLMForQuestionAnsweringSimple, """text-classification""": XLMForSequenceClassification, """text-generation""": XLMWithLMHeadModel, """token-classification""": XLMForTokenClassification, """zero-shot""": XLMForSequenceClassification, } if is_torch_available() else {} ) def lowercase ( self : Optional[Any] , snake_case_ : List[Any] , snake_case_ : Tuple , snake_case_ : Any , snake_case_ : str , snake_case_ : Union[str, Any] ): if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("Fast" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def lowercase ( self : Union[str, Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : Tuple=False ): _UpperCAmelCase = super()._prepare_for_class(snake_case_ , snake_case_ , return_labels=snake_case_ ) if return_labels: if model_class.__name__ == "XLMForQuestionAnswering": _UpperCAmelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=snake_case_ ) _UpperCAmelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=snake_case_ ) return inputs_dict def lowercase ( self : Tuple ): _UpperCAmelCase = XLMModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , emb_dim=3_7 ) def lowercase ( self : Optional[int] ): self.config_tester.run_common_tests() def lowercase ( self : Any ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_model(*snake_case_ ) def lowercase ( self : Dict ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_lm_head(*snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_simple_qa(*snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_qa(*snake_case_ ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_token_classif(*snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any , snake_case_ : Tuple , snake_case_ : Any , snake_case_ : Optional[Any] , snake_case_ : Tuple , snake_case_ : Any=False , snake_case_ : Union[str, Any]=1 ): self.assertIsInstance(snake_case_ , snake_case_ ) self.assertListEqual( [isinstance(snake_case_ , snake_case_ ) for iter_attentions in attentions] , [True] * len(snake_case_ ) ) self.assertEqual(len(snake_case_ ) , (max_length - min_length) * num_beam_groups ) for idx, iter_attentions in enumerate(snake_case_ ): # adds PAD dummy token _UpperCAmelCase = min_length + idx + 1 _UpperCAmelCase = min_length + idx + 1 _UpperCAmelCase = ( batch_size * num_beam_groups, config.num_attention_heads, tgt_len, src_len, ) # check attn size self.assertListEqual( [layer_attention.shape for layer_attention in iter_attentions] , [expected_shape] * len(snake_case_ ) ) def lowercase ( self : Any , snake_case_ : Any , snake_case_ : int , snake_case_ : List[Any] , snake_case_ : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : int=False , snake_case_ : List[Any]=1 ): self.assertIsInstance(snake_case_ , snake_case_ ) self.assertListEqual( [isinstance(snake_case_ , snake_case_ ) for iter_hidden_states in hidden_states] , [True] * len(snake_case_ ) , ) self.assertEqual(len(snake_case_ ) , (max_length - min_length) * num_beam_groups ) for idx, iter_hidden_states in enumerate(snake_case_ ): # adds PAD dummy token _UpperCAmelCase = min_length + idx + 1 _UpperCAmelCase = (batch_size * num_beam_groups, seq_len, config.hidden_size) # check hidden size self.assertListEqual( [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states] , [expected_shape] * len(snake_case_ ) , ) pass @slow def lowercase ( self : int ): for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = XLMModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) @require_torch class A_ ( unittest.TestCase ): @slow def lowercase ( self : Any ): _UpperCAmelCase = XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048" ) model.to(snake_case_ ) _UpperCAmelCase = torch.tensor([[1_4, 4_4_7]] , dtype=torch.long , device=snake_case_ ) # the president _UpperCAmelCase = [ 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, 1_4, 4_4_7, ] # the president the president the president the president the president the president the president the president the president the president # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference _UpperCAmelCase = model.generate(snake_case_ , do_sample=snake_case_ ) self.assertListEqual(output_ids[0].cpu().numpy().tolist() , snake_case_ )
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1