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 math import tensorflow as tf from packaging import version def _a ( SCREAMING_SNAKE_CASE : str ) -> Optional[int]: """simple docstring""" __lowerCAmelCase: Union[str, Any] = tf.convert_to_tensor(A__ ) __lowerCAmelCase: int = 0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0 ) , x.dtype ) )) return x * cdf def _a ( SCREAMING_SNAKE_CASE : Any ) -> Any: """simple docstring""" __lowerCAmelCase: int = tf.convert_to_tensor(A__ ) __lowerCAmelCase: Dict = tf.cast(math.pi , x.dtype ) __lowerCAmelCase: Union[str, Any] = tf.cast(0.0_4_4_7_1_5 , x.dtype ) __lowerCAmelCase: List[Any] = 0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi ) * (x + coeff * tf.pow(A__ , 3 )) )) return x * cdf def _a ( SCREAMING_SNAKE_CASE : Tuple ) -> str: """simple docstring""" __lowerCAmelCase: Optional[int] = tf.convert_to_tensor(A__ ) return x * tf.tanh(tf.math.softplus(A__ ) ) def _a ( SCREAMING_SNAKE_CASE : List[Any] ) -> List[str]: """simple docstring""" __lowerCAmelCase: List[Any] = tf.convert_to_tensor(A__ ) __lowerCAmelCase: List[Any] = tf.cast(0.0_4_4_7_1_5 , x.dtype ) __lowerCAmelCase: Optional[int] = tf.cast(0.7_9_7_8_8_4_5_6_0_8 , x.dtype ) return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x) )) def _a ( SCREAMING_SNAKE_CASE : Optional[Any] ) -> List[str]: """simple docstring""" __lowerCAmelCase: Tuple = tf.convert_to_tensor(A__ ) __lowerCAmelCase: int = tf.cast(1.7_0_2 , x.dtype ) return x * tf.math.sigmoid(coeff * x ) def _a ( SCREAMING_SNAKE_CASE : str ) -> Optional[int]: """simple docstring""" return tf.clip_by_value(_gelu(A__ ) , -10 , 10 ) def _a ( SCREAMING_SNAKE_CASE : List[Any] , SCREAMING_SNAKE_CASE : Tuple=-1 ) -> Optional[Any]: """simple docstring""" __lowerCAmelCase , __lowerCAmelCase: Optional[Any] = tf.split(A__ , 2 , axis=A__ ) return a * tf.math.sigmoid(A__ ) if version.parse(tf.version.VERSION) >= version.parse('''2.4'''): def _a ( SCREAMING_SNAKE_CASE : List[Any] ) -> str: """simple docstring""" return tf.keras.activations.gelu(A__ , approximate=A__ ) _a = tf.keras.activations.gelu _a = approximate_gelu_wrap else: _a = _gelu _a = _gelu_new _a = { "gelu": gelu, "gelu_10": gelu_aa, "gelu_fast": gelu_fast, "gelu_new": gelu_new, "glu": glu, "mish": mish, "quick_gelu": quick_gelu, "relu": tf.keras.activations.relu, "sigmoid": tf.keras.activations.sigmoid, "silu": tf.keras.activations.swish, "swish": tf.keras.activations.swish, "tanh": tf.keras.activations.tanh, } def _a ( SCREAMING_SNAKE_CASE : str ) -> int: """simple docstring""" if activation_string in ACTaFN: return ACTaFN[activation_string] else: raise KeyError(f'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys() )}''' )
322
'''simple docstring''' import os from itertools import chain from random import randrange, shuffle import pytest from .sola import PokerHand _lowerCamelCase : Optional[int] = ( "4S 3H 2C 7S 5H", "9D 8H 2C 6S 7H", "2D 6D 9D TH 7D", "TC 8C 2S JH 6C", "JH 8S TH AH QH", "TS KS 5S 9S AC", "KD 6S 9D TH AD", "KS 8D 4D 9S 4S", # pair "8C 4S KH JS 4D", # pair "QH 8H KD JH 8S", # pair "KC 4H KS 2H 8D", # pair "KD 4S KC 3H 8S", # pair "AH 8S AS KC JH", # pair "3H 4C 4H 3S 2H", # 2 pairs "5S 5D 2C KH KH", # 2 pairs "3C KH 5D 5S KH", # 2 pairs "AS 3C KH AD KH", # 2 pairs "7C 7S 3S 7H 5S", # 3 of a kind "7C 7S KH 2H 7H", # 3 of a kind "AC KH QH AH AS", # 3 of a kind "2H 4D 3C AS 5S", # straight (low ace) "3C 5C 4C 2C 6H", # straight "6S 8S 7S 5H 9H", # straight "JS QS 9H TS KH", # straight "QC KH TS JS AH", # straight (high ace) "8C 9C 5C 3C TC", # flush "3S 8S 9S 5S KS", # flush "4C 5C 9C 8C KC", # flush "JH 8H AH KH QH", # flush "3D 2H 3H 2C 2D", # full house "2H 2C 3S 3H 3D", # full house "KH KC 3S 3H 3D", # full house "JC 6H JS JD JH", # 4 of a kind "JC 7H JS JD JH", # 4 of a kind "JC KH JS JD JH", # 4 of a kind "2S AS 4S 5S 3S", # straight flush (low ace) "2D 6D 3D 4D 5D", # straight flush "5C 6C 3C 7C 4C", # straight flush "JH 9H TH KH QH", # straight flush "JH AH TH KH QH", # royal flush (high ace straight flush) ) _lowerCamelCase : Union[str, Any] = ( ("2H 3H 4H 5H 6H", "KS AS TS QS JS", "Loss"), ("2H 3H 4H 5H 6H", "AS AD AC AH JD", "Win"), ("AS AH 2H AD AC", "JS JD JC JH 3D", "Win"), ("2S AH 2H AS AC", "JS JD JC JH AD", "Loss"), ("2S AH 2H AS AC", "2H 3H 5H 6H 7H", "Win"), ("AS 3S 4S 8S 2S", "2H 3H 5H 6H 7H", "Win"), ("2H 3H 5H 6H 7H", "2S 3H 4H 5S 6C", "Win"), ("2S 3H 4H 5S 6C", "3D 4C 5H 6H 2S", "Tie"), ("2S 3H 4H 5S 6C", "AH AC 5H 6H AS", "Win"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H AS", "Loss"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H 7S", "Win"), ("6S AD 7H 4S AS", "AH AC 5H 6H 7S", "Loss"), ("2S AH 4H 5S KC", "AH AC 5H 6H 7S", "Loss"), ("2S 3H 6H 7S 9C", "7H 3C TH 6H 9S", "Loss"), ("4S 5H 6H TS AC", "3S 5H 6H TS AC", "Win"), ("2S AH 4H 5S 6C", "AD 4C 5H 6H 2C", "Tie"), ("AS AH 3H AD AC", "AS AH 2H AD AC", "Win"), ("AH AC 5H 5C QS", "AH AC 5H 5C KS", "Loss"), ("AH AC 5H 5C QS", "KH KC 5H 5C QS", "Win"), ("7C 7S KH 2H 7H", "3C 3S AH 2H 3H", "Win"), ("3C 3S AH 2H 3H", "7C 7S KH 2H 7H", "Loss"), ("6H 5H 4H 3H 2H", "5H 4H 3H 2H AH", "Win"), ("5H 4H 3H 2H AH", "5H 4H 3H 2H AH", "Tie"), ("5H 4H 3H 2H AH", "6H 5H 4H 3H 2H", "Loss"), ("AH AD KS KC AC", "AH KD KH AC KC", "Win"), ("2H 4D 3C AS 5S", "2H 4D 3C 6S 5S", "Loss"), ("2H 3S 3C 3H 2S", "3S 3C 2S 2H 2D", "Win"), ("4D 6D 5D 2D JH", "3S 8S 3H TC KH", "Loss"), ("4S 6C 8S 3S 7S", "AD KS 2D 7D 7C", "Loss"), ("6S 4C 7H 8C 3H", "5H JC AH 9D 9C", "Loss"), ("9D 9H JH TC QH", "3C 2S JS 5C 7H", "Win"), ("2H TC 8S AD 9S", "4H TS 7H 2C 5C", "Win"), ("9D 3S 2C 7S 7C", "JC TD 3C TC 9H", "Loss"), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", True), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", False), ("AS 3S 4S 8S 2S", True), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", False), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", True), ) _lowerCamelCase : Optional[Any] = ( ("2H 4D 3C AS 5S", True, [5, 4, 3, 2, 14]), ("2H 5D 3C AS 5S", False, [14, 5, 5, 3, 2]), ("JH QD KC AS TS", False, [14, 13, 12, 11, 10]), ("9D 3S 2C 7S 7C", False, [9, 7, 7, 3, 2]), ) _lowerCamelCase : List[Any] = ( ("JH AH TH KH QH", 0), ("JH 9H TH KH QH", 0), ("JC KH JS JD JH", 7), ("KH KC 3S 3H 3D", 6), ("8C 9C 5C 3C TC", 0), ("JS QS 9H TS KH", 0), ("7C 7S KH 2H 7H", 3), ("3C KH 5D 5S KH", 2), ("QH 8H KD JH 8S", 1), ("2D 6D 9D TH 7D", 0), ) _lowerCamelCase : List[str] = ( ("JH AH TH KH QH", 23), ("JH 9H TH KH QH", 22), ("JC KH JS JD JH", 21), ("KH KC 3S 3H 3D", 20), ("8C 9C 5C 3C TC", 19), ("JS QS 9H TS KH", 18), ("7C 7S KH 2H 7H", 17), ("3C KH 5D 5S KH", 16), ("QH 8H KD JH 8S", 15), ("2D 6D 9D TH 7D", 14), ) def __lowerCamelCase ( ) -> Optional[Any]: """simple docstring""" UpperCamelCase , UpperCamelCase = randrange(len(A__ ) ), randrange(len(A__ ) ) UpperCamelCase = ['Loss', 'Tie', 'Win'][(play >= oppo) + (play > oppo)] UpperCamelCase , UpperCamelCase = SORTED_HANDS[play], SORTED_HANDS[oppo] return hand, other, expected def __lowerCamelCase ( A__ = 100 ) -> Optional[Any]: """simple docstring""" return (generate_random_hand() for _ in range(A__ )) @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_flush() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_straight() == expected @pytest.mark.parametrize('hand, expected, card_values' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> str: """simple docstring""" UpperCamelCase = PokerHand(A__ ) assert player._is_five_high_straight() == expected assert player._card_values == card_values @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Dict: """simple docstring""" assert PokerHand(A__ )._is_same_kind() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> str: """simple docstring""" assert PokerHand(A__ )._hand_type == expected @pytest.mark.parametrize('hand, other, expected' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> Tuple: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected @pytest.mark.parametrize('hand, other, expected' , generate_random_hands() ) def __lowerCamelCase ( A__ , A__ , A__ ) -> List[str]: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected def __lowerCamelCase ( ) -> str: """simple docstring""" UpperCamelCase = [PokerHand(A__ ) for hand in SORTED_HANDS] UpperCamelCase = poker_hands.copy() shuffle(A__ ) UpperCamelCase = chain(sorted(A__ ) ) for index, hand in enumerate(A__ ): assert hand == poker_hands[index] def __lowerCamelCase ( ) -> Optional[int]: """simple docstring""" # Test that five high straights are compared correctly. UpperCamelCase = [PokerHand('2D AC 3H 4H 5S' ), PokerHand('2S 3H 4H 5S 6C' )] pokerhands.sort(reverse=A__ ) assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C" def __lowerCamelCase ( ) -> str: """simple docstring""" # Multiple calls to five_high_straight function should still return True # and shouldn't mutate the list in every call other than the first. UpperCamelCase = PokerHand('2C 4S AS 3D 5C' ) UpperCamelCase = True UpperCamelCase = [5, 4, 3, 2, 14] for _ in range(10 ): assert pokerhand._is_five_high_straight() == expected assert pokerhand._card_values == expected_card_values def __lowerCamelCase ( ) -> List[str]: """simple docstring""" # Problem number 54 from Project Euler # Testing from poker_hands.txt file UpperCamelCase = 0 UpperCamelCase = os.path.abspath(os.path.dirname(A__ ) ) UpperCamelCase = os.path.join(A__ , 'poker_hands.txt' ) with open(A__ ) as file_hand: for line in file_hand: UpperCamelCase = line[:14].strip() UpperCamelCase = line[15:].strip() UpperCamelCase , UpperCamelCase = PokerHand(A__ ), PokerHand(A__ ) UpperCamelCase = player.compare_with(A__ ) if output == "Win": answer += 1 assert answer == 376
28
0
"""simple docstring""" import unittest from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow if is_flax_available(): import jax from transformers.models.auto.modeling_flax_auto import FlaxAutoModel from transformers.models.bert.modeling_flax_bert import FlaxBertModel from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel @require_flax class __snake_case ( unittest.TestCase): @slow def SCREAMING_SNAKE_CASE ( self : Optional[int] ): """simple docstring""" for model_name in ["bert-base-cased", "bert-large-uncased"]: with self.subTest(UpperCamelCase__ ): _lowerCamelCase : Optional[Any] = AutoConfig.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) self.assertIsInstance(UpperCamelCase__ , UpperCamelCase__ ) _lowerCamelCase : List[str] = FlaxAutoModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) self.assertIsInstance(UpperCamelCase__ , UpperCamelCase__ ) @slow def SCREAMING_SNAKE_CASE ( self : List[Any] ): """simple docstring""" for model_name in ["roberta-base", "roberta-large"]: with self.subTest(UpperCamelCase__ ): _lowerCamelCase : List[Any] = AutoConfig.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) self.assertIsInstance(UpperCamelCase__ , UpperCamelCase__ ) _lowerCamelCase : List[Any] = FlaxAutoModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) self.assertIsInstance(UpperCamelCase__ , UpperCamelCase__ ) @slow def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ): """simple docstring""" for model_name in ["bert-base-cased", "bert-large-uncased"]: _lowerCamelCase : List[Any] = AutoTokenizer.from_pretrained(UpperCamelCase__ ) _lowerCamelCase : Optional[Any] = FlaxBertModel.from_pretrained(UpperCamelCase__ ) _lowerCamelCase : List[str] = tokenizer('''Do you support jax jitted function?''' , return_tensors=TensorType.JAX ) @jax.jit def eval(**__lowerCAmelCase : str ): return model(**UpperCamelCase__ ) eval(**UpperCamelCase__ ).block_until_ready() @slow def SCREAMING_SNAKE_CASE ( self : List[Any] ): """simple docstring""" for model_name in ["roberta-base", "roberta-large"]: _lowerCamelCase : Any = AutoTokenizer.from_pretrained(UpperCamelCase__ ) _lowerCamelCase : Dict = FlaxRobertaModel.from_pretrained(UpperCamelCase__ ) _lowerCamelCase : str = tokenizer('''Do you support jax jitted function?''' , return_tensors=TensorType.JAX ) @jax.jit def eval(**__lowerCAmelCase : str ): return model(**UpperCamelCase__ ) eval(**UpperCamelCase__ ).block_until_ready() def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ): """simple docstring""" with self.assertRaisesRegex( UpperCamelCase__ , '''bert-base is not a local folder and is not a valid model identifier''' ): _lowerCamelCase : Any = FlaxAutoModel.from_pretrained('''bert-base''' ) def SCREAMING_SNAKE_CASE ( self : List[Any] ): """simple docstring""" with self.assertRaisesRegex( UpperCamelCase__ , R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)''' ): _lowerCamelCase : Any = FlaxAutoModel.from_pretrained(UpperCamelCase__ , revision='''aaaaaa''' ) def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ): """simple docstring""" with self.assertRaisesRegex( UpperCamelCase__ , '''hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack''' , ): _lowerCamelCase : Optional[Any] = FlaxAutoModel.from_pretrained('''hf-internal-testing/config-no-model''' ) def SCREAMING_SNAKE_CASE ( self : str ): """simple docstring""" with self.assertRaisesRegex(UpperCamelCase__ , '''Use `from_pt=True` to load this model''' ): _lowerCamelCase : str = FlaxAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only''' )
72
'''simple docstring''' from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = None class SCREAMING_SNAKE_CASE ( _a , _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 2 @register_to_config def __init__( self : Union[str, Any] , UpperCamelCase__ : float = 0.0_2 , UpperCamelCase__ : float = 1_0_0 , UpperCamelCase__ : float = 1.0_0_7 , UpperCamelCase__ : float = 8_0 , UpperCamelCase__ : float = 0.0_5 , UpperCamelCase__ : float = 5_0 , ): """simple docstring""" UpperCamelCase = sigma_max # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None ): """simple docstring""" return sample def A ( self : Union[str, Any] , UpperCamelCase__ : int , UpperCamelCase__ : Union[str, torch.device] = None ): """simple docstring""" UpperCamelCase = num_inference_steps UpperCamelCase = np.arange(0 , self.num_inference_steps )[::-1].copy() UpperCamelCase = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) UpperCamelCase = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in self.timesteps ] UpperCamelCase = torch.tensor(UpperCamelCase__ , dtype=torch.floataa , device=UpperCamelCase__ ) def A ( self : Dict , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : Optional[torch.Generator] = None ): """simple docstring""" if self.config.s_min <= sigma <= self.config.s_max: UpperCamelCase = min(self.config.s_churn / self.num_inference_steps , 2**0.5 - 1 ) else: UpperCamelCase = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCamelCase = self.config.s_noise * randn_tensor(sample.shape , generator=UpperCamelCase__ ).to(sample.device ) UpperCamelCase = sigma + gamma * sigma UpperCamelCase = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_hat + sigma_hat * model_output UpperCamelCase = (sample_hat - pred_original_sample) / sigma_hat UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : List[Any] , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_prev + sigma_prev * model_output UpperCamelCase = (sample_prev - pred_original_sample) / sigma_prev UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : int , UpperCamelCase__ : str ): """simple docstring""" raise NotImplementedError()
28
0
import inspect import unittest from transformers import ViTHybridConfig from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class A__: """simple docstring""" def __init__( self , _lowercase , _lowercase=13 , _lowercase=64 , _lowercase=2 , _lowercase=3 , _lowercase=True , _lowercase=True , _lowercase=32 , _lowercase=5 , _lowercase=4 , _lowercase=37 , _lowercase="gelu" , _lowercase=0.1 , _lowercase=0.1 , _lowercase=10 , _lowercase=0.0_2 , _lowercase=[1, 16, 4, 4] , _lowercase=None , ) -> Union[str, Any]: a_ : str = parent a_ : Optional[Any] = batch_size a_ : Optional[Any] = image_size a_ : str = patch_size a_ : Tuple = num_channels a_ : Dict = is_training a_ : Optional[Any] = use_labels a_ : Optional[Any] = hidden_size a_ : Union[str, Any] = num_hidden_layers a_ : str = num_attention_heads a_ : Tuple = intermediate_size a_ : Optional[Any] = hidden_act a_ : Tuple = hidden_dropout_prob a_ : Optional[int] = attention_probs_dropout_prob a_ : str = type_sequence_label_size a_ : int = initializer_range a_ : Any = scope a_ : Any = backbone_featmap_shape # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token) # the number of patches is based on the feature map of the backbone, which by default uses an output stride # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size a_ : str = (self.image_size // 32) ** 2 a_ : Optional[int] = num_patches + 1 def UpperCamelCase__ ( self ) -> List[Any]: a_ : Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) a_ : Union[str, Any] = None if self.use_labels: a_ : List[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) a_ : Dict = self.get_config() return config, pixel_values, labels def UpperCamelCase__ ( self ) -> List[str]: a_ : Dict = { """global_padding""": """same""", """layer_type""": """bottleneck""", """depths""": [3, 4, 9], """out_features""": ["""stage1""", """stage2""", """stage3"""], """embedding_dynamic_padding""": True, """hidden_sizes""": [4, 8, 16, 32], """num_groups""": 2, } return ViTHybridConfig( 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=UpperCamelCase__ , initializer_range=self.initializer_range , backbone_featmap_shape=self.backbone_featmap_shape , backbone_config=UpperCamelCase__ , ) def UpperCamelCase__ ( self , _lowercase , _lowercase , _lowercase ) -> str: a_ : Tuple = ViTHybridModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() a_ : Optional[int] = model(UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def UpperCamelCase__ ( self , _lowercase , _lowercase , _lowercase ) -> Tuple: a_ : List[Any] = self.type_sequence_label_size a_ : List[Any] = ViTHybridForImageClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() a_ : str = model(UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def UpperCamelCase__ ( self ) -> int: a_ : List[str] = self.prepare_config_and_inputs() a_ , a_ , a_ : Optional[Any] = config_and_inputs a_ : Optional[Any] = {"""pixel_values""": pixel_values} return config, inputs_dict @require_torch class A__(_a, _a, unittest.TestCase ): """simple docstring""" _A : List[Any] = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else () _A : Tuple = ( {'''feature-extraction''': ViTHybridModel, '''image-classification''': ViTHybridForImageClassification} if is_torch_available() else {} ) _A : Optional[Any] = False _A : int = False _A : List[str] = False def UpperCamelCase__ ( self ) -> List[str]: a_ : List[str] = ViTHybridModelTester(self ) a_ : Optional[int] = ConfigTester(self , config_class=UpperCamelCase__ , has_text_modality=UpperCamelCase__ , hidden_size=37 ) def UpperCamelCase__ ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() @unittest.skip(reason="""ViT does not use inputs_embeds""" ) def UpperCamelCase__ ( self ) -> Dict: pass def UpperCamelCase__ ( self ) -> Optional[Any]: a_ , 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(UpperCamelCase__ ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) a_ : str = model.get_output_embeddings() self.assertTrue(x is None or isinstance(UpperCamelCase__ , nn.Linear ) ) def UpperCamelCase__ ( self ) -> Tuple: a_ , a_ : List[str] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: a_ : Tuple = model_class(UpperCamelCase__ ) a_ : int = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic a_ : Tuple = [*signature.parameters.keys()] a_ : Union[str, Any] = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , UpperCamelCase__ ) def UpperCamelCase__ ( self ) -> Union[str, Any]: a_ : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def UpperCamelCase__ ( self ) -> List[Any]: a_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ ) def UpperCamelCase__ ( self ) -> int: a_ , a_ : List[str] = self.model_tester.prepare_config_and_inputs_for_common() a_ : Optional[int] = _config_zero_init(UpperCamelCase__ ) for model_class in self.all_model_classes: a_ : List[Any] = model_class(config=UpperCamelCase__ ) # Skip the check for the backbone for name, module in model.named_modules(): if module.__class__.__name__ == "ViTHybridPatchEmbeddings": a_ : str = [F'''{name}.{key}''' for key in module.state_dict().keys()] break for name, param in model.named_parameters(): if param.requires_grad: if name in backbone_params: continue self.assertIn( ((param.data.mean() * 1e9).round() / 1e9).item() , [0.0, 1.0] , msg=F'''Parameter {name} of model {model_class} seems not properly initialized''' , ) @slow def UpperCamelCase__ ( self ) -> int: for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: a_ : str = ViTHybridModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) def _UpperCAmelCase ( ): '''simple docstring''' a_ : Union[str, Any] = 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 ) -> Optional[int]: return ( ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def UpperCamelCase__ ( self ) -> Tuple: a_ : Any = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to( UpperCamelCase__ ) a_ : List[str] = self.default_image_processor a_ : Tuple = prepare_img() a_ : List[str] = image_processor(images=UpperCamelCase__ , return_tensors="""pt""" ).to(UpperCamelCase__ ) # forward pass with torch.no_grad(): a_ : Dict = model(**UpperCamelCase__ ) # verify the logits a_ : List[str] = torch.Size((1, 1_000) ) self.assertEqual(outputs.logits.shape , UpperCamelCase__ ) a_ : Optional[Any] = torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(UpperCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , UpperCamelCase__ , atol=1e-4 ) ) @slow @require_accelerate def UpperCamelCase__ ( self ) -> str: a_ : Tuple = ViTHybridImageProcessor.from_pretrained("""google/vit-hybrid-base-bit-384""" ) a_ : Optional[Any] = ViTHybridForImageClassification.from_pretrained("""google/vit-hybrid-base-bit-384""" , device_map="""auto""" ) a_ : Dict = prepare_img() a_ : Optional[Any] = image_processor(images=UpperCamelCase__ , return_tensors="""pt""" ) a_ : Optional[int] = model(**UpperCamelCase__ ) a_ : int = outputs.logits # model predicts one of the 1000 ImageNet classes a_ : Any = logits.argmax(-1 ).item() self.assertTrue(model.config.idalabel[predicted_class_idx] , """tabby, tabby cat""" )
248
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available _lowerCamelCase : Tuple = {"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Dict = [ "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "IBertForMaskedLM", "IBertForMultipleChoice", "IBertForQuestionAnswering", "IBertForSequenceClassification", "IBertForTokenClassification", "IBertModel", "IBertPreTrainedModel", ] if TYPE_CHECKING: from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ibert import ( IBERT_PRETRAINED_MODEL_ARCHIVE_LIST, IBertForMaskedLM, IBertForMultipleChoice, IBertForQuestionAnswering, IBertForSequenceClassification, IBertForTokenClassification, IBertModel, IBertPreTrainedModel, ) else: import sys _lowerCamelCase : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
from __future__ import annotations from typing import Any class SCREAMING_SNAKE_CASE_ : def __init__( self : List[str] , _A : int = 6 ) -> List[Any]: """simple docstring""" snake_case_ : Dict = None snake_case_ : List[str] = None self.create_linked_list(UpperCamelCase__ ) def UpperCAmelCase_ ( self : List[Any] , _A : int ) -> Optional[int]: """simple docstring""" snake_case_ : Optional[Any] = Node() snake_case_ : Optional[int] = current_node snake_case_ : Tuple = current_node snake_case_ : str = current_node for _ in range(1 , UpperCamelCase__ ): snake_case_ : Optional[int] = Node() snake_case_ : Union[str, Any] = current_node snake_case_ : Dict = previous_node snake_case_ : Optional[Any] = current_node snake_case_ : Optional[int] = self.front snake_case_ : List[Any] = previous_node def UpperCAmelCase_ ( self : str ) -> Optional[int]: """simple docstring""" return ( self.front == self.rear and self.front is not None and self.front.data is None ) def UpperCAmelCase_ ( self : List[str] ) -> List[str]: """simple docstring""" self.check_can_perform_operation() return self.front.data if self.front else None def UpperCAmelCase_ ( self : str , _A : Any ) -> str: """simple docstring""" if self.rear is None: return self.check_is_full() if not self.is_empty(): snake_case_ : Optional[int] = self.rear.next if self.rear: snake_case_ : Tuple = data def UpperCAmelCase_ ( self : Dict ) -> int: """simple docstring""" self.check_can_perform_operation() if self.rear is None or self.front is None: return None if self.front == self.rear: snake_case_ : List[Any] = self.front.data snake_case_ : List[Any] = None return data snake_case_ : Tuple = self.front snake_case_ : Optional[Any] = old_front.next snake_case_ : List[Any] = old_front.data snake_case_ : Union[str, Any] = None return data def UpperCAmelCase_ ( self : Any ) -> str: """simple docstring""" if self.is_empty(): raise Exception('Empty Queue' ) def UpperCAmelCase_ ( self : Tuple ) -> List[Any]: """simple docstring""" if self.rear and self.rear.next == self.front: raise Exception('Full Queue' ) class SCREAMING_SNAKE_CASE_ : def __init__( self : Any ) -> List[Any]: """simple docstring""" snake_case_ : Any = None snake_case_ : Optional[int] = None snake_case_ : int = None if __name__ == "__main__": import doctest doctest.testmod()
327
'''simple docstring''' def __lowerCamelCase ( A__ = 10**9 ) -> int: """simple docstring""" UpperCamelCase = 1 UpperCamelCase = 2 UpperCamelCase = 0 UpperCamelCase = 0 UpperCamelCase = 0 while perimeter <= max_perimeter: perimeters_sum += perimeter prev_value += 2 * value value += prev_value UpperCamelCase = 2 * value + 2 if i % 2 == 0 else 2 * value - 2 i += 1 return perimeters_sum if __name__ == "__main__": print(f'''{solution() = }''')
28
0
import warnings from functools import wraps from typing import Callable def A ( _lowerCamelCase ): '''simple docstring''' @wraps(A__ ) def _inner_fn(*_lowerCamelCase , **_lowerCamelCase ): warnings.warn( (F"'{fn.__name__}' is experimental and might be subject to breaking changes in the future.") , A__ , ) return fn(*A__ , **A__ ) return _inner_fn
36
'''simple docstring''' import math class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Union[str, Any] , UpperCamelCase__ : Optional[Any]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" UpperCamelCase = n UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # adjacency matrix for weight UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # dp[i][j] stores minimum distance from i to j def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = w def A ( self : str ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): UpperCamelCase = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": _lowerCamelCase : List[str] = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
28
0
import re from typing import Callable, List, Optional, Union import tensorflow as tf try: from tensorflow.keras.optimizers.legacy import Adam except ImportError: from tensorflow.keras.optimizers import Adam class A ( tf.keras.optimizers.schedules.LearningRateSchedule ): def __init__(self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase = 1.0 , lowerCAmelCase = None , ): super().__init__() __lowercase= initial_learning_rate __lowercase= warmup_steps __lowercase= power __lowercase= decay_schedule_fn __lowercase= name def __call__(self , lowerCAmelCase ): with tf.name_scope(self.name or 'WarmUp' ) as name: # Implements polynomial warmup. i.e., if global_step < warmup_steps, the # learning rate will be `global_step/num_warmup_steps * init_lr`. __lowercase= tf.cast(UpperCamelCase__ , tf.floataa ) __lowercase= tf.cast(self.warmup_steps , tf.floataa ) __lowercase= global_step_float / warmup_steps_float __lowercase= self.initial_learning_rate * tf.math.pow(UpperCamelCase__ , self.power ) return tf.cond( global_step_float < warmup_steps_float , lambda: warmup_learning_rate , lambda: self.decay_schedule_fn(step - self.warmup_steps ) , name=UpperCamelCase__ , ) def _A (self ): return { "initial_learning_rate": self.initial_learning_rate, "decay_schedule_fn": self.decay_schedule_fn, "warmup_steps": self.warmup_steps, "power": self.power, "name": self.name, } def _lowerCamelCase( lowercase__ , lowercase__ , lowercase__ , lowercase__ = 0.0 , lowercase__ = 0.9 , lowercase__ = 0.999 , lowercase__ = 1E-8 , lowercase__ = None , lowercase__ = None , lowercase__ = 0.0 , lowercase__ = 1.0 , lowercase__ = None , ) -> str: '''simple docstring''' __lowercase= tf.keras.optimizers.schedules.PolynomialDecay( initial_learning_rate=A__ , decay_steps=num_train_steps - num_warmup_steps , end_learning_rate=init_lr * min_lr_ratio , power=A__ , ) if num_warmup_steps: __lowercase= WarmUp( initial_learning_rate=A__ , decay_schedule_fn=A__ , warmup_steps=A__ , ) if weight_decay_rate > 0.0: __lowercase= AdamWeightDecay( learning_rate=A__ , weight_decay_rate=A__ , beta_a=A__ , beta_a=A__ , epsilon=A__ , clipnorm=A__ , global_clipnorm=A__ , exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias'] , include_in_weight_decay=A__ , ) else: __lowercase= tf.keras.optimizers.Adam( learning_rate=A__ , beta_a=A__ , beta_a=A__ , epsilon=A__ , clipnorm=A__ , global_clipnorm=A__ , ) # We return the optimizer and the LR scheduler in order to better track the # evolution of the LR independently of the optimizer. return optimizer, lr_schedule class A ( _a ): def __init__(self , lowerCAmelCase = 0.0_01 , lowerCAmelCase = 0.9 , lowerCAmelCase = 0.9_99 , lowerCAmelCase = 1E-7 , lowerCAmelCase = False , lowerCAmelCase = 0.0 , lowerCAmelCase = None , lowerCAmelCase = None , lowerCAmelCase = "AdamWeightDecay" , **lowerCAmelCase , ): super().__init__(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= weight_decay_rate __lowercase= include_in_weight_decay __lowercase= exclude_from_weight_decay @classmethod def _A (cls , lowerCAmelCase ): __lowercase= {'WarmUp': WarmUp} return super(UpperCamelCase__ , cls ).from_config(UpperCamelCase__ , custom_objects=UpperCamelCase__ ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): super(UpperCamelCase__ , self )._prepare_local(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) __lowercase= tf.constant( self.weight_decay_rate , name='adam_weight_decay_rate' ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): __lowercase= self._do_use_weight_decay(var.name ) if do_decay: return var.assign_sub( learning_rate * var * apply_state[(var.device, var.dtype.base_dtype)]['weight_decay_rate'] , use_locking=self._use_locking , ) return tf.no_op() def _A (self , lowerCAmelCase , lowerCAmelCase=None , **lowerCAmelCase ): __lowercase, __lowercase= list(zip(*UpperCamelCase__ ) ) return super(UpperCamelCase__ , self ).apply_gradients(zip(UpperCamelCase__ , UpperCamelCase__ ) , name=UpperCamelCase__ , **UpperCamelCase__ ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ): if apply_state is None: return self._decayed_lr_t[var_dtype], {} __lowercase= apply_state or {} __lowercase= apply_state.get((var_device, var_dtype) ) if coefficients is None: __lowercase= self._fallback_apply_state(UpperCamelCase__ , UpperCamelCase__ ) __lowercase= coefficients return coefficients["lr_t"], {"apply_state": apply_state} def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=None ): __lowercase, __lowercase= self._get_lr(var.device , var.dtype.base_dtype , UpperCamelCase__ ) __lowercase= self._decay_weights_op(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) with tf.control_dependencies([decay] ): return super(UpperCamelCase__ , self )._resource_apply_dense(UpperCamelCase__ , UpperCamelCase__ , **UpperCamelCase__ ) def _A (self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=None ): __lowercase, __lowercase= self._get_lr(var.device , var.dtype.base_dtype , UpperCamelCase__ ) __lowercase= self._decay_weights_op(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) with tf.control_dependencies([decay] ): return super(UpperCamelCase__ , self )._resource_apply_sparse(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , **UpperCamelCase__ ) def _A (self ): __lowercase= super().get_config() config.update({'weight_decay_rate': self.weight_decay_rate} ) return config def _A (self , lowerCAmelCase ): if self.weight_decay_rate == 0: return False if self._include_in_weight_decay: for r in self._include_in_weight_decay: if re.search(UpperCamelCase__ , UpperCamelCase__ ) is not None: return True if self._exclude_from_weight_decay: for r in self._exclude_from_weight_decay: if re.search(UpperCamelCase__ , UpperCamelCase__ ) is not None: return False return True class A ( _a ): def __init__(self ): __lowercase= [] __lowercase= None @property def _A (self ): if self._accum_steps is None: __lowercase= tf.Variable( tf.constant(0 , dtype=tf.intaa ) , trainable=UpperCamelCase__ , synchronization=tf.VariableSynchronization.ON_READ , aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA , ) return self._accum_steps.value() @property def _A (self ): if not self._gradients: raise ValueError('The accumulator should be called first to initialize the gradients' ) return [gradient.value() if gradient is not None else gradient for gradient in self._gradients] def __call__(self , lowerCAmelCase ): if not self._gradients: __lowercase= self.step # Create the step variable. self._gradients.extend( [ tf.Variable( tf.zeros_like(UpperCamelCase__ ) , trainable=UpperCamelCase__ , synchronization=tf.VariableSynchronization.ON_READ , aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA , ) if gradient is not None else gradient for gradient in gradients ] ) if len(UpperCamelCase__ ) != len(self._gradients ): raise ValueError(f'Expected {len(self._gradients )} gradients, but got {len(UpperCamelCase__ )}' ) for accum_gradient, gradient in zip(self._gradients , UpperCamelCase__ ): if accum_gradient is not None and gradient is not None: accum_gradient.assign_add(UpperCamelCase__ ) self._accum_steps.assign_add(1 ) def _A (self ): if not self._gradients: return self._accum_steps.assign(0 ) for gradient in self._gradients: if gradient is not None: gradient.assign(tf.zeros_like(UpperCamelCase__ ) )
295
'''simple docstring''' _lowerCamelCase : int = "0.21.0" from .accelerator import Accelerator from .big_modeling import ( cpu_offload, cpu_offload_with_hook, disk_offload, dispatch_model, init_empty_weights, init_on_device, load_checkpoint_and_dispatch, ) from .data_loader import skip_first_batches from .launchers import debug_launcher, notebook_launcher from .state import PartialState from .utils import ( DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, FullyShardedDataParallelPlugin, GradScalerKwargs, InitProcessGroupKwargs, find_executable_batch_size, infer_auto_device_map, is_rich_available, load_checkpoint_in_model, synchronize_rng_states, ) if is_rich_available(): from .utils import rich
28
0
'''simple docstring''' import unittest from transformers.testing_utils import require_bsa from transformers.utils import is_bsa_available from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin if is_bsa_available(): from transformers import MarkupLMFeatureExtractor class a__( unittest.TestCase ): def __init__( self : Tuple , __snake_case : Optional[int] ): a : Union[str, Any] = parent def lowercase_ ( self : Union[str, Any] ): return {} def lowerCamelCase__ ( ): a : List[Any] = '<HTML>\n\n <HEAD>\n <TITLE>sample document</TITLE>\n </HEAD>\n\n <BODY BGCOLOR="FFFFFF">\n <HR>\n <a href="http://google.com">Goog</a>\n <H1>This is one header</H1>\n <H2>This is a another Header</H2>\n <P>Travel from\n <P>\n <B>SFO to JFK</B>\n <BR>\n <B><I>on May 2, 2015 at 2:00 pm. For details go to confirm.com </I></B>\n <HR>\n <div style="color:#0000FF">\n <h3>Traveler <b> name </b> is\n <p> John Doe </p>\n </div>' a : Optional[int] = '\n <!DOCTYPE html>\n <html>\n <body>\n\n <h1>My First Heading</h1>\n <p>My first paragraph.</p>\n\n </body>\n </html>\n ' return [html_string_a, html_string_a] @require_bsa class a__( _a , unittest.TestCase ): lowercase__ = MarkupLMFeatureExtractor if is_bsa_available() else None def lowercase_ ( self : Any ): a : List[str] = MarkupLMFeatureExtractionTester(self ) @property def lowercase_ ( self : Dict ): return self.feature_extract_tester.prepare_feat_extract_dict() def lowercase_ ( self : List[Any] ): a : Any = self.feature_extraction_class() # Test not batched input a : Union[str, Any] = get_html_strings()[0] a : Union[str, Any] = feature_extractor(UpperCamelCase__ ) # fmt: off a : List[str] = [['sample document', 'Goog', 'This is one header', 'This is a another Header', 'Travel from', 'SFO to JFK', 'on May 2, 2015 at 2:00 pm. For details go to confirm.com', 'Traveler', 'name', 'is', 'John Doe']] a : Optional[Any] = [['/html/head/title', '/html/body/a', '/html/body/h1', '/html/body/h2', '/html/body/p', '/html/body/p/p/b[1]', '/html/body/p/p/b[2]/i', '/html/body/p/p/div/h3', '/html/body/p/p/div/h3/b', '/html/body/p/p/div/h3', '/html/body/p/p/div/h3/p']] # fmt: on self.assertEqual(encoding.nodes , UpperCamelCase__ ) self.assertEqual(encoding.xpaths , UpperCamelCase__ ) # Test batched a : str = get_html_strings() a : str = feature_extractor(UpperCamelCase__ ) # fmt: off a : Union[str, Any] = expected_nodes + [['My First Heading', 'My first paragraph.']] a : Optional[Any] = expected_xpaths + [['/html/body/h1', '/html/body/p']] self.assertEqual(len(encoding.nodes ) , 2 ) self.assertEqual(len(encoding.xpaths ) , 2 ) self.assertEqual(encoding.nodes , UpperCamelCase__ ) self.assertEqual(encoding.xpaths , UpperCamelCase__ )
297
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowerCamelCase : List[Any] = { "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"], "tokenization_m2m_100": ["M2M100Tokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : int = [ "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST", "M2M100ForConditionalGeneration", "M2M100Model", "M2M100PreTrainedModel", ] if TYPE_CHECKING: from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig from .tokenization_mam_aaa import MaMaaaTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mam_aaa import ( M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST, MaMaaaForConditionalGeneration, MaMaaaModel, MaMaaaPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
"""simple docstring""" import unittest from transformers import LiltConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( LiltForQuestionAnswering, LiltForSequenceClassification, LiltForTokenClassification, LiltModel, ) from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST class lowercase_ : '''simple docstring''' def __init__( self : Tuple , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Union[str, Any]=13 , _UpperCAmelCase : Any=7 , _UpperCAmelCase : Optional[Any]=True , _UpperCAmelCase : Union[str, Any]=True , _UpperCAmelCase : Tuple=True , _UpperCAmelCase : Tuple=True , _UpperCAmelCase : Dict=99 , _UpperCAmelCase : Dict=24 , _UpperCAmelCase : List[str]=2 , _UpperCAmelCase : Any=6 , _UpperCAmelCase : Optional[Any]=37 , _UpperCAmelCase : Any="gelu" , _UpperCAmelCase : Tuple=0.1 , _UpperCAmelCase : Any=0.1 , _UpperCAmelCase : Any=512 , _UpperCAmelCase : Union[str, Any]=16 , _UpperCAmelCase : Tuple=2 , _UpperCAmelCase : Optional[Any]=0.02 , _UpperCAmelCase : Tuple=3 , _UpperCAmelCase : Dict=None , _UpperCAmelCase : List[str]=1_000 , ): _A = parent _A = batch_size _A = seq_length _A = is_training _A = use_input_mask _A = use_token_type_ids _A = use_labels _A = vocab_size _A = hidden_size _A = num_hidden_layers _A = num_attention_heads _A = intermediate_size _A = hidden_act _A = hidden_dropout_prob _A = attention_probs_dropout_prob _A = max_position_embeddings _A = type_vocab_size _A = type_sequence_label_size _A = initializer_range _A = num_labels _A = scope _A = range_bbox def lowerCAmelCase_ ( self : Optional[int] ): _A = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _A = ids_tensor([self.batch_size, self.seq_length, 4] , self.range_bbox ) # Ensure that bbox is legal for i in range(bbox.shape[0] ): for j in range(bbox.shape[1] ): if bbox[i, j, 3] < bbox[i, j, 1]: _A = bbox[i, j, 3] _A = bbox[i, j, 1] _A = t if bbox[i, j, 2] < bbox[i, j, 0]: _A = bbox[i, j, 2] _A = bbox[i, j, 0] _A = t _A = None if self.use_input_mask: _A = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) _A = None if self.use_token_type_ids: _A = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _A = None _A = None if self.use_labels: _A = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _A = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _A = self.get_config() return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels def lowerCAmelCase_ ( self : Dict ): return LiltConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , ) def lowerCAmelCase_ ( self : Dict , _UpperCAmelCase : List[str] , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Tuple , _UpperCAmelCase : List[str] , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] , ): _A = LiltModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _A = model(UpperCamelCase__ , bbox=UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) _A = model(UpperCamelCase__ , bbox=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) _A = model(UpperCamelCase__ , bbox=UpperCamelCase__ ) 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 lowerCAmelCase_ ( self : Any , _UpperCAmelCase : Dict , _UpperCAmelCase : List[Any] , _UpperCAmelCase : List[str] , _UpperCAmelCase : Tuple , _UpperCAmelCase : List[Any] , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : Union[str, Any] , ): _A = self.num_labels _A = LiltForTokenClassification(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _A = model( UpperCamelCase__ , bbox=UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def lowerCAmelCase_ ( self : List[str] , _UpperCAmelCase : List[str] , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Any , _UpperCAmelCase : Tuple , _UpperCAmelCase : int , _UpperCAmelCase : Dict , ): _A = LiltForQuestionAnswering(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _A = model( UpperCamelCase__ , bbox=UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , start_positions=UpperCamelCase__ , end_positions=UpperCamelCase__ , ) 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 lowerCAmelCase_ ( self : int ): _A = self.prepare_config_and_inputs() ( ( _A ) , ( _A ) , ( _A ) , ( _A ) , ( _A ) , ( _A ) , ( _A ) , ) = config_and_inputs _A = { 'input_ids': input_ids, 'bbox': bbox, 'token_type_ids': token_type_ids, 'attention_mask': input_mask, } return config, inputs_dict @require_torch class lowercase_ ( _a , _a , _a , unittest.TestCase ): '''simple docstring''' UpperCAmelCase : str = ( ( LiltModel, LiltForSequenceClassification, LiltForTokenClassification, LiltForQuestionAnswering, ) if is_torch_available() else () ) UpperCAmelCase : Union[str, Any] = ( { '''feature-extraction''': LiltModel, '''question-answering''': LiltForQuestionAnswering, '''text-classification''': LiltForSequenceClassification, '''token-classification''': LiltForTokenClassification, '''zero-shot''': LiltForSequenceClassification, } if is_torch_available() else {} ) UpperCAmelCase : Tuple = False UpperCAmelCase : Optional[Any] = False def lowerCAmelCase_ ( self : Union[str, Any] , _UpperCAmelCase : Any , _UpperCAmelCase : int , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str] , _UpperCAmelCase : List[Any] ): return True def lowerCAmelCase_ ( self : Union[str, Any] ): _A = LiltModelTester(self ) _A = ConfigTester(self , config_class=UpperCamelCase__ , hidden_size=37 ) def lowerCAmelCase_ ( self : Union[str, Any] ): self.config_tester.run_common_tests() def lowerCAmelCase_ ( self : str ): _A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def lowerCAmelCase_ ( self : List[str] ): _A = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: _A = type self.model_tester.create_and_check_model(*UpperCamelCase__ ) def lowerCAmelCase_ ( self : Dict ): _A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__ ) def lowerCAmelCase_ ( self : List[Any] ): _A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__ ) @slow def lowerCAmelCase_ ( self : Union[str, Any] ): for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _A = LiltModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) @require_torch @slow class lowercase_ ( unittest.TestCase ): '''simple docstring''' def lowerCAmelCase_ ( self : str ): _A = LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base' ).to(UpperCamelCase__ ) _A = torch.tensor([[1, 2]] , device=UpperCamelCase__ ) _A = torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]] , device=UpperCamelCase__ ) # forward pass with torch.no_grad(): _A = model(input_ids=UpperCamelCase__ , bbox=UpperCamelCase__ ) _A = torch.Size([1, 2, 768] ) _A = torch.tensor( [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]] , device=UpperCamelCase__ , ) self.assertTrue(outputs.last_hidden_state.shape , UpperCamelCase__ ) self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3] , UpperCamelCase__ , atol=1E-3 ) )
315
'''simple docstring''' from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def __lowerCamelCase ( A__ , A__ , A__=1e-1_2 ) -> Dict: """simple docstring""" UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T return jnp.matmul(A__ , norm_emb_a.T ) class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = jnp.floataa def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = FlaxCLIPVisionModule(self.config.vision_config ) UpperCamelCase = nn.Dense(self.config.projection_dim , use_bias=UpperCamelCase__ , dtype=self.dtype ) UpperCamelCase = self.param('concept_embeds' , jax.nn.initializers.ones , (1_7, self.config.projection_dim) ) UpperCamelCase = self.param( 'special_care_embeds' , jax.nn.initializers.ones , (3, self.config.projection_dim) ) UpperCamelCase = self.param('concept_embeds_weights' , jax.nn.initializers.ones , (1_7,) ) UpperCamelCase = self.param('special_care_embeds_weights' , jax.nn.initializers.ones , (3,) ) def __call__( self : str , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = self.vision_model(UpperCamelCase__ )[1] UpperCamelCase = self.visual_projection(UpperCamelCase__ ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.special_care_embeds ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.concept_embeds ) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs UpperCamelCase = 0.0 UpperCamelCase = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(special_scores > 0 , axis=1 , keepdims=UpperCamelCase__ ) # Use a lower threshold if an image has any special care concept UpperCamelCase = is_special_care * 0.0_1 UpperCamelCase = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(concept_scores > 0 , axis=1 ) return has_nsfw_concepts class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = CLIPConfig _SCREAMING_SNAKE_CASE = """clip_input""" _SCREAMING_SNAKE_CASE = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , UpperCamelCase__ : CLIPConfig , UpperCamelCase__ : Optional[Tuple] = None , UpperCamelCase__ : int = 0 , UpperCamelCase__ : jnp.dtype = jnp.floataa , UpperCamelCase__ : bool = True , **UpperCamelCase__ : List[str] , ): """simple docstring""" if input_shape is None: UpperCamelCase = (1, 2_2_4, 2_2_4, 3) UpperCamelCase = self.module_class(config=UpperCamelCase__ , dtype=UpperCamelCase__ , **UpperCamelCase__ ) super().__init__(UpperCamelCase__ , UpperCamelCase__ , input_shape=UpperCamelCase__ , seed=UpperCamelCase__ , dtype=UpperCamelCase__ , _do_init=_do_init ) def A ( self : int , UpperCamelCase__ : jax.random.KeyArray , UpperCamelCase__ : Tuple , UpperCamelCase__ : FrozenDict = None ): """simple docstring""" UpperCamelCase = jax.random.normal(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase , UpperCamelCase = jax.random.split(UpperCamelCase__ ) UpperCamelCase = {'params': params_rng, 'dropout': dropout_rng} UpperCamelCase = self.module.init(UpperCamelCase__ , UpperCamelCase__ )['params'] return random_params def __call__( self : List[Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : dict = None , ): """simple docstring""" UpperCamelCase = jnp.transpose(UpperCamelCase__ , (0, 2, 3, 1) ) return self.module.apply( {'params': params or self.params} , jnp.array(UpperCamelCase__ , dtype=jnp.floataa ) , rngs={} , )
28
0
from timeit import timeit def lowerCAmelCase_ ( snake_case_ ): if number < 0: raise ValueError("""the value of input must not be negative""" ) _A : Any = 0 while number: number &= number - 1 result += 1 return result def lowerCAmelCase_ ( snake_case_ ): if number < 0: raise ValueError("""the value of input must not be negative""" ) _A : List[Any] = 0 while number: if number % 2 == 1: result += 1 number >>= 1 return result def lowerCAmelCase_ ( ): def do_benchmark(snake_case_ ) -> None: _A : Any = """import __main__ as z""" print(f'''Benchmark when {number = }:''' ) print(f'''{get_set_bits_count_using_modulo_operator(A__ ) = }''' ) _A : Dict = timeit("""z.get_set_bits_count_using_modulo_operator(25)""",setup=A__ ) print(f'''timeit() runs in {timing} seconds''' ) print(f'''{get_set_bits_count_using_brian_kernighans_algorithm(A__ ) = }''' ) _A : Union[str, Any] = timeit( """z.get_set_bits_count_using_brian_kernighans_algorithm(25)""",setup=A__,) print(f'''timeit() runs in {timing} seconds''' ) for number in (25, 37, 58, 0): do_benchmark(A__ ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
26
'''simple docstring''' import warnings from ...utils import logging from .image_processing_chinese_clip import ChineseCLIPImageProcessor _lowerCamelCase : str = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" def __init__( self : Dict , *UpperCamelCase__ : List[Any] , **UpperCamelCase__ : List[Any] ): """simple docstring""" warnings.warn( 'The class ChineseCLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use ChineseCLIPImageProcessor instead.' , UpperCamelCase__ , ) super().__init__(*UpperCamelCase__ , **UpperCamelCase__ )
28
0
from typing import Dict, List, Optional, Type from .. import config from ..utils import logging from .formatting import ( ArrowFormatter, CustomFormatter, Formatter, PandasFormatter, PythonFormatter, TensorFormatter, format_table, query_table, ) from .np_formatter import NumpyFormatter _A : Any = logging.get_logger(__name__) _A : Dict[Optional[str], Type[Formatter]] = {} _A : Dict[Optional[str], str] = {} _A : Dict[Optional[str], Exception] = {} def _a ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = None , ) -> Any: """simple docstring""" lowerCamelCase__ : str = aliases if aliases is not None else [] if format_type in _FORMAT_TYPES: logger.warning( f"Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})" ) lowerCamelCase__ : Optional[Any] = formatter_cls for alias in set(aliases + [format_type] ): if alias in _FORMAT_TYPES_ALIASES: logger.warning( f"Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})" ) lowerCamelCase__ : int = format_type def _a ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase = None ) -> Any: """simple docstring""" lowerCamelCase__ : Optional[int] = aliases if aliases is not None else [] for alias in set(aliases + [format_type] ): lowerCamelCase__ : Union[str, Any] = unavailable_error # Here we define all the available formatting functions that can be used by `Dataset.set_format` _register_formatter(PythonFormatter, None, aliases=['python']) _register_formatter(ArrowFormatter, 'arrow', aliases=['pa', 'pyarrow']) _register_formatter(NumpyFormatter, 'numpy', aliases=['np']) _register_formatter(PandasFormatter, 'pandas', aliases=['pd']) _register_formatter(CustomFormatter, 'custom') if config.TORCH_AVAILABLE: from .torch_formatter import TorchFormatter _register_formatter(TorchFormatter, 'torch', aliases=['pt', 'pytorch']) else: _A : Optional[int] = ValueError('PyTorch needs to be installed to be able to return PyTorch tensors.') _register_unavailable_formatter(_torch_error, 'torch', aliases=['pt', 'pytorch']) if config.TF_AVAILABLE: from .tf_formatter import TFFormatter _register_formatter(TFFormatter, 'tensorflow', aliases=['tf']) else: _A : Any = ValueError('Tensorflow needs to be installed to be able to return Tensorflow tensors.') _register_unavailable_formatter(_tf_error, 'tensorflow', aliases=['tf']) if config.JAX_AVAILABLE: from .jax_formatter import JaxFormatter _register_formatter(JaxFormatter, 'jax', aliases=[]) else: _A : str = ValueError('JAX needs to be installed to be able to return JAX arrays.') _register_unavailable_formatter(_jax_error, 'jax', aliases=[]) def _a ( UpperCAmelCase ) -> Optional[str]: """simple docstring""" if format_type in _FORMAT_TYPES_ALIASES: return _FORMAT_TYPES_ALIASES[format_type] else: return format_type def _a ( UpperCAmelCase , **UpperCAmelCase ) -> Formatter: """simple docstring""" lowerCamelCase__ : Optional[int] = get_format_type_from_alias(A__ ) if format_type in _FORMAT_TYPES: return _FORMAT_TYPES[format_type](**A__ ) if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE: raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type] else: raise ValueError( f"Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None )}, but got '{format_type}'" )
142
'''simple docstring''' import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed _lowerCamelCase : Optional[int] = logging.getLogger(__name__) def __lowerCamelCase ( A__=2 , A__=3 , A__=16 , A__ = 10 , A__ = 2 ) -> int: """simple docstring""" def get_dataset(A__ ): UpperCamelCase = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(A__ , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) return (train_dataloader, valid_dataloader) def __lowerCamelCase ( A__ , A__ , A__ , A__ , A__ , A__=None ) -> int: """simple docstring""" UpperCamelCase = [] for epoch in range(A__ ): # Train quickly model.train() for batch in dataloader: UpperCamelCase , UpperCamelCase = batch UpperCamelCase = model(A__ ) UpperCamelCase = torch.nn.functional.mse_loss(A__ , A__ ) accelerator.backward(A__ ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" def __init__( self : Tuple ): """simple docstring""" super().__init__() UpperCamelCase = nn.Parameter(torch.randn(1 ) ) UpperCamelCase = nn.Parameter(torch.randn(1 ) ) def A ( self : str , UpperCamelCase__ : Dict ): """simple docstring""" return x * self.a + self.b class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(total_limit=1 , project_dir=UpperCamelCase__ , automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def A ( self : Optional[int] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() # Train baseline UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial UpperCamelCase = os.path.join(UpperCamelCase__ , 'initial' ) accelerator.save_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything UpperCamelCase = os.path.join(UpperCamelCase__ , 'checkpoint' ) accelerator.save_state(UpperCamelCase__ ) # Load everything back in and make sure all states work accelerator.load_state(UpperCamelCase__ ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=UpperCamelCase__ ) UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = torch.tensor([1, 2, 3] ) UpperCamelCase = torch.tensor([2, 3, 4] ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(net.parameters() ) UpperCamelCase = Accelerator() with self.assertRaises(UpperCamelCase__ ) as ve: accelerator.register_for_checkpointing(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def A ( self : Dict ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase = torch.optim.lr_scheduler.StepLR(UpperCamelCase__ , step_size=1 , gamma=0.9_9 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() UpperCamelCase = scheduler.state_dict() train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) self.assertNotEqual(UpperCamelCase__ , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(UpperCamelCase__ , scheduler.state_dict() ) def A ( self : List[str] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ , total_limit=2 ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase = accelerator.prepare(UpperCamelCase__ ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def A ( self : Dict ): """simple docstring""" UpperCamelCase = ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )] execute_subprocess_async(UpperCamelCase__ , env=os.environ.copy() ) if __name__ == "__main__": _lowerCamelCase : Optional[int] = "/tmp/accelerate/state_checkpointing" _lowerCamelCase : Union[str, Any] = DummyModel() _lowerCamelCase : Optional[Any] = torch.optim.Adam(params=model.parameters(), lr=1e-3) _lowerCamelCase : List[Any] = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.99) _lowerCamelCase ,_lowerCamelCase : Tuple = dummy_dataloaders() _lowerCamelCase : List[Any] = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline _lowerCamelCase : Any = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision="no") if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) _lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase : Union[str, Any] = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) _lowerCamelCase ,_lowerCamelCase : Tuple = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: _lowerCamelCase : Any = group["params"][0].device break assert param_device.type == accelerator.device.type _lowerCamelCase : Tuple = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="cpu") for group in optimizer.param_groups: _lowerCamelCase : Optional[Any] = group["params"][0].device break assert ( param_device.type == torch.device("cpu").type ), f"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="on_device") for group in optimizer.param_groups: _lowerCamelCase : Dict = group["params"][0].device break assert ( param_device.type == accelerator.device.type ), f"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match="Unsupported optimizer map location passed"): accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="invalid") accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
28
0
'''simple docstring''' from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig snake_case_ : Union[str, Any] = { "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/config.json", "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/config.json", "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/config.json", "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json", "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/config.json", "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/config.json", "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/config.json", "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json", } class lowercase__ ( _a ): lowercase__ = """albert""" def __init__( self : int ,lowerCamelCase__ : Optional[int]=30000 ,lowerCamelCase__ : Union[str, Any]=128 ,lowerCamelCase__ : int=4096 ,lowerCamelCase__ : Dict=12 ,lowerCamelCase__ : Dict=1 ,lowerCamelCase__ : List[Any]=64 ,lowerCamelCase__ : Any=16384 ,lowerCamelCase__ : Dict=1 ,lowerCamelCase__ : str="gelu_new" ,lowerCamelCase__ : str=0 ,lowerCamelCase__ : Union[str, Any]=0 ,lowerCamelCase__ : Optional[int]=512 ,lowerCamelCase__ : Any=2 ,lowerCamelCase__ : Union[str, Any]=0.0_2 ,lowerCamelCase__ : Tuple=1E-12 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : int="absolute" ,lowerCamelCase__ : Optional[Any]=0 ,lowerCamelCase__ : List[Any]=2 ,lowerCamelCase__ : str=3 ,**lowerCamelCase__ : List[str] ,): '''simple docstring''' super().__init__(pad_token_id=UpperCamelCase__ ,bos_token_id=UpperCamelCase__ ,eos_token_id=UpperCamelCase__ ,**UpperCamelCase__ ) _UpperCamelCase : List[str] = vocab_size _UpperCamelCase : Union[str, Any] = embedding_size _UpperCamelCase : Optional[int] = hidden_size _UpperCamelCase : Any = num_hidden_layers _UpperCamelCase : List[Any] = num_hidden_groups _UpperCamelCase : Optional[int] = num_attention_heads _UpperCamelCase : str = inner_group_num _UpperCamelCase : List[Any] = hidden_act _UpperCamelCase : Dict = intermediate_size _UpperCamelCase : Any = hidden_dropout_prob _UpperCamelCase : Union[str, Any] = attention_probs_dropout_prob _UpperCamelCase : Dict = max_position_embeddings _UpperCamelCase : List[Any] = type_vocab_size _UpperCamelCase : List[Any] = initializer_range _UpperCamelCase : Tuple = layer_norm_eps _UpperCamelCase : Optional[int] = classifier_dropout_prob _UpperCamelCase : Optional[Any] = position_embedding_type class lowercase__ ( _a ): @property def UpperCamelCase_ ( self : List[str] ): '''simple docstring''' if self.task == "multiple-choice": _UpperCamelCase : Optional[Any] = {0: 'batch', 1: 'choice', 2: 'sequence'} else: _UpperCamelCase : int = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ('token_type_ids', dynamic_axis), ] )
83
'''simple docstring''' import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration _lowerCamelCase : List[str] = 5_0000 _lowerCamelCase : Optional[int] = 5000 _lowerCamelCase ,_lowerCamelCase : int = os.path.split(__file__) _lowerCamelCase : str = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json")) @get_duration def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> int: """simple docstring""" for i in range(0 , len(A__ ) , A__ ): UpperCamelCase = dataset[i : i + batch_size] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> List[Any]: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ , A__ ) -> int: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(0 , A__ , A__ ): UpperCamelCase = dataset[i : i + batch_size] def __lowerCamelCase ( ) -> List[str]: """simple docstring""" UpperCamelCase = {'num examples': SPEED_TEST_N_EXAMPLES} UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted, {'type': 'pandas', 'length': SMALL_TEST}), (read_formatted, {'type': 'torch', 'length': SMALL_TEST}), (read_formatted, {'type': 'tensorflow', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print('generating dataset' ) UpperCamelCase = datasets.Features( {'list': datasets.Sequence(datasets.Value('float32' ) ), 'numbers': datasets.Value('float32' )} ) UpperCamelCase = generate_example_dataset( os.path.join(A__ , 'dataset.arrow' ) , A__ , num_examples=A__ , seq_shapes={'list': (100,)} , ) print('first set of iterations' ) for func, kwargs in functions: print(func.__name__ , str(A__ ) ) UpperCamelCase = func(A__ , **A__ ) print('shuffling dataset' ) UpperCamelCase = dataset.shuffle() print('Second set of iterations (after shuffling' ) for func, kwargs in functions_shuffled: print('shuffled ' , func.__name__ , str(A__ ) ) UpperCamelCase = func( A__ , **A__ ) with open(A__ , 'wb' ) as f: f.write(json.dumps(A__ ).encode('utf-8' ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
28
0
import math from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass # Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->UnCLIP class A_ ( _a ): _lowercase : Optional[Any] = 4_2 _lowercase : Tuple = None def _a ( SCREAMING_SNAKE_CASE : List[Any] , SCREAMING_SNAKE_CASE : Tuple=0.9_9_9 , SCREAMING_SNAKE_CASE : Tuple="cosine" , ) -> Tuple: """simple docstring""" if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE : List[Any] ): return math.cos((t + 0.0_0_8) / 1.0_0_8 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE : Optional[Any] ): return math.exp(t * -1_2.0 ) else: raise ValueError(f'''Unsupported alpha_tranform_type: {alpha_transform_type}''' ) __lowerCAmelCase: Optional[int] = [] for i in range(A__ ): __lowerCAmelCase: Any = i / num_diffusion_timesteps __lowerCAmelCase: Dict = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(A__ ) / alpha_bar_fn(A__ ) , A__ ) ) return torch.tensor(A__ , dtype=torch.floataa ) class A_ ( _a , _a ): @register_to_config def __init__( self : List[str] , UpperCAmelCase : int = 1_0_0_0 , UpperCAmelCase : str = "fixed_small_log" , UpperCAmelCase : bool = True , UpperCAmelCase : Optional[float] = 1.0 , UpperCAmelCase : str = "epsilon" , UpperCAmelCase : str = "squaredcos_cap_v2" , ) -> int: if beta_schedule != "squaredcos_cap_v2": raise ValueError('UnCLIPScheduler only supports `beta_schedule`: \'squaredcos_cap_v2\'' ) __lowerCAmelCase: Dict = betas_for_alpha_bar(UpperCamelCase__ ) __lowerCAmelCase: int = 1.0 - self.betas __lowerCAmelCase: Dict = torch.cumprod(self.alphas , dim=0 ) __lowerCAmelCase: List[Any] = torch.tensor(1.0 ) # standard deviation of the initial noise distribution __lowerCAmelCase: List[str] = 1.0 # setable values __lowerCAmelCase: Any = None __lowerCAmelCase: int = torch.from_numpy(np.arange(0 , UpperCamelCase__ )[::-1].copy() ) __lowerCAmelCase: Dict = variance_type def UpperCAmelCase ( self : Dict , UpperCAmelCase : torch.FloatTensor , UpperCAmelCase : Optional[int] = None ) -> Tuple: return sample def UpperCAmelCase ( self : List[str] , UpperCAmelCase : int , UpperCAmelCase : Union[str, torch.device] = None ) -> int: __lowerCAmelCase: Optional[Any] = num_inference_steps __lowerCAmelCase: str = (self.config.num_train_timesteps - 1) / (self.num_inference_steps - 1) __lowerCAmelCase: int = (np.arange(0 , UpperCamelCase__ ) * step_ratio).round()[::-1].copy().astype(np.intaa ) __lowerCAmelCase: Tuple = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) def UpperCAmelCase ( self : Dict , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Union[str, Any]=None , UpperCAmelCase : Optional[int]=None , UpperCAmelCase : Tuple=None ) -> List[Any]: if prev_timestep is None: __lowerCAmelCase: Union[str, Any] = t - 1 __lowerCAmelCase: str = self.alphas_cumprod[t] __lowerCAmelCase: List[str] = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one __lowerCAmelCase: Any = 1 - alpha_prod_t __lowerCAmelCase: List[Any] = 1 - alpha_prod_t_prev if prev_timestep == t - 1: __lowerCAmelCase: Union[str, Any] = self.betas[t] else: __lowerCAmelCase: str = 1 - alpha_prod_t / alpha_prod_t_prev # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf) # and sample from it to get previous sample # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample __lowerCAmelCase: Optional[int] = beta_prod_t_prev / beta_prod_t * beta if variance_type is None: __lowerCAmelCase: Union[str, Any] = self.config.variance_type # hacks - were probably added for training stability if variance_type == "fixed_small_log": __lowerCAmelCase: str = torch.log(torch.clamp(UpperCamelCase__ , min=1E-20 ) ) __lowerCAmelCase: Optional[Any] = torch.exp(0.5 * variance ) elif variance_type == "learned_range": # NOTE difference with DDPM scheduler __lowerCAmelCase: List[Any] = variance.log() __lowerCAmelCase: List[str] = beta.log() __lowerCAmelCase: List[str] = (predicted_variance + 1) / 2 __lowerCAmelCase: Union[str, Any] = frac * max_log + (1 - frac) * min_log return variance def UpperCAmelCase ( self : int , UpperCAmelCase : torch.FloatTensor , UpperCAmelCase : int , UpperCAmelCase : torch.FloatTensor , UpperCAmelCase : Optional[int] = None , UpperCAmelCase : str=None , UpperCAmelCase : bool = True , ) -> List[str]: __lowerCAmelCase: List[Any] = timestep if model_output.shape[1] == sample.shape[1] * 2 and self.variance_type == "learned_range": __lowerCAmelCase , __lowerCAmelCase: List[Any] = torch.split(UpperCamelCase__ , sample.shape[1] , dim=1 ) else: __lowerCAmelCase: List[Any] = None # 1. compute alphas, betas if prev_timestep is None: __lowerCAmelCase: Optional[Any] = t - 1 __lowerCAmelCase: List[str] = self.alphas_cumprod[t] __lowerCAmelCase: Any = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one __lowerCAmelCase: Union[str, Any] = 1 - alpha_prod_t __lowerCAmelCase: Optional[Any] = 1 - alpha_prod_t_prev if prev_timestep == t - 1: __lowerCAmelCase: Any = self.betas[t] __lowerCAmelCase: List[str] = self.alphas[t] else: __lowerCAmelCase: Any = 1 - alpha_prod_t / alpha_prod_t_prev __lowerCAmelCase: str = 1 - beta # 2. compute predicted original sample from predicted noise also called # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf if self.config.prediction_type == "epsilon": __lowerCAmelCase: Tuple = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 elif self.config.prediction_type == "sample": __lowerCAmelCase: int = model_output else: raise ValueError( F'''prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `sample`''' ' for the UnCLIPScheduler.' ) # 3. Clip "predicted x_0" if self.config.clip_sample: __lowerCAmelCase: Union[str, Any] = torch.clamp( UpperCamelCase__ , -self.config.clip_sample_range , self.config.clip_sample_range ) # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf __lowerCAmelCase: List[str] = (alpha_prod_t_prev ** 0.5 * beta) / beta_prod_t __lowerCAmelCase: Tuple = alpha ** 0.5 * beta_prod_t_prev / beta_prod_t # 5. Compute predicted previous sample µ_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf __lowerCAmelCase: Optional[Any] = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample # 6. Add noise __lowerCAmelCase: List[str] = 0 if t > 0: __lowerCAmelCase: Optional[Any] = randn_tensor( model_output.shape , dtype=model_output.dtype , generator=UpperCamelCase__ , device=model_output.device ) __lowerCAmelCase: Optional[Any] = self._get_variance( UpperCamelCase__ , predicted_variance=UpperCamelCase__ , prev_timestep=UpperCamelCase__ , ) if self.variance_type == "fixed_small_log": __lowerCAmelCase: Any = variance elif self.variance_type == "learned_range": __lowerCAmelCase: Optional[Any] = (0.5 * variance).exp() else: raise ValueError( F'''variance_type given as {self.variance_type} must be one of `fixed_small_log` or `learned_range`''' ' for the UnCLIPScheduler.' ) __lowerCAmelCase: int = variance * variance_noise __lowerCAmelCase: str = pred_prev_sample + variance if not return_dict: return (pred_prev_sample,) return UnCLIPSchedulerOutput(prev_sample=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def UpperCAmelCase ( self : int , UpperCAmelCase : torch.FloatTensor , UpperCAmelCase : torch.FloatTensor , UpperCAmelCase : torch.IntTensor , ) -> Optional[int]: __lowerCAmelCase: Union[str, Any] = self.alphas_cumprod.to(device=original_samples.device , dtype=original_samples.dtype ) __lowerCAmelCase: List[str] = timesteps.to(original_samples.device ) __lowerCAmelCase: Tuple = alphas_cumprod[timesteps] ** 0.5 __lowerCAmelCase: Any = sqrt_alpha_prod.flatten() while len(sqrt_alpha_prod.shape ) < len(original_samples.shape ): __lowerCAmelCase: str = sqrt_alpha_prod.unsqueeze(-1 ) __lowerCAmelCase: Any = (1 - alphas_cumprod[timesteps]) ** 0.5 __lowerCAmelCase: Optional[Any] = sqrt_one_minus_alpha_prod.flatten() while len(sqrt_one_minus_alpha_prod.shape ) < len(original_samples.shape ): __lowerCAmelCase: int = sqrt_one_minus_alpha_prod.unsqueeze(-1 ) __lowerCAmelCase: Optional[Any] = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise return noisy_samples
322
'''simple docstring''' import absl # noqa: F401 # Here to have a nice missing dependency error message early on import nltk # noqa: F401 # Here to have a nice missing dependency error message early on import numpy # noqa: F401 # Here to have a nice missing dependency error message early on import six # noqa: F401 # Here to have a nice missing dependency error message early on from rouge_score import rouge_scorer, scoring import datasets _lowerCamelCase : List[str] = "\\n@inproceedings{lin-2004-rouge,\n title = \"{ROUGE}: A Package for Automatic Evaluation of Summaries\",\n author = \"Lin, Chin-Yew\",\n booktitle = \"Text Summarization Branches Out\",\n month = jul,\n year = \"2004\",\n address = \"Barcelona, Spain\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://www.aclweb.org/anthology/W04-1013\",\n pages = \"74--81\",\n}\n" _lowerCamelCase : Optional[int] = "\\nROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for\nevaluating automatic summarization and machine translation software in natural language processing.\nThe metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.\n\nNote that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.\n\nThis metrics is a wrapper around Google Research reimplementation of ROUGE:\nhttps://github.com/google-research/google-research/tree/master/rouge\n" _lowerCamelCase : str = "\nCalculates average rouge scores for a list of hypotheses and references\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n rouge_types: A list of rouge types to calculate.\n Valid names:\n `\"rouge{n}\"` (e.g. `\"rouge1\"`, `\"rouge2\"`) where: {n} is the n-gram based scoring,\n `\"rougeL\"`: Longest common subsequence based scoring.\n `\"rougeLSum\"`: rougeLsum splits text using `\"\n\"`.\n See details in https://github.com/huggingface/datasets/issues/617\n use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.\n use_aggregator: Return aggregates if this is set to True\nReturns:\n rouge1: rouge_1 (precision, recall, f1),\n rouge2: rouge_2 (precision, recall, f1),\n rougeL: rouge_l (precision, recall, f1),\n rougeLsum: rouge_lsum (precision, recall, f1)\nExamples:\n\n >>> rouge = datasets.load_metric('rouge')\n >>> predictions = [\"hello there\", \"general kenobi\"]\n >>> references = [\"hello there\", \"general kenobi\"]\n >>> results = rouge.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n ['rouge1', 'rouge2', 'rougeL', 'rougeLsum']\n >>> print(results[\"rouge1\"])\n AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0))\n >>> print(results[\"rouge1\"].mid.fmeasure)\n 1.0\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/google-research/google-research/tree/master/rouge'] , reference_urls=[ 'https://en.wikipedia.org/wiki/ROUGE_(metric)', 'https://github.com/google-research/google-research/tree/master/rouge', ] , ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : List[str]=None , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Optional[Any]=False ): """simple docstring""" if rouge_types is None: UpperCamelCase = ['rouge1', 'rouge2', 'rougeL', 'rougeLsum'] UpperCamelCase = rouge_scorer.RougeScorer(rouge_types=UpperCamelCase__ , use_stemmer=UpperCamelCase__ ) if use_aggregator: UpperCamelCase = scoring.BootstrapAggregator() else: UpperCamelCase = [] for ref, pred in zip(UpperCamelCase__ , UpperCamelCase__ ): UpperCamelCase = scorer.score(UpperCamelCase__ , UpperCamelCase__ ) if use_aggregator: aggregator.add_scores(UpperCamelCase__ ) else: scores.append(UpperCamelCase__ ) if use_aggregator: UpperCamelCase = aggregator.aggregate() else: UpperCamelCase = {} for key in scores[0]: UpperCamelCase = [score[key] for score in scores] return result
28
0
"""simple docstring""" import inspect import unittest from transformers import ConvNextConfig 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_backbone_common import BackboneTesterMixin 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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class __snake_case : def __init__( self : Optional[int] , __lowerCAmelCase : List[str] , __lowerCAmelCase : Any=1_3 , __lowerCAmelCase : Optional[int]=3_2 , __lowerCAmelCase : Any=3 , __lowerCAmelCase : Tuple=4 , __lowerCAmelCase : str=[1_0, 2_0, 3_0, 4_0] , __lowerCAmelCase : str=[2, 2, 3, 2] , __lowerCAmelCase : Dict=True , __lowerCAmelCase : List[str]=True , __lowerCAmelCase : str=3_7 , __lowerCAmelCase : Union[str, Any]="gelu" , __lowerCAmelCase : Dict=1_0 , __lowerCAmelCase : Union[str, Any]=0.02 , __lowerCAmelCase : int=["stage2", "stage3", "stage4"] , __lowerCAmelCase : List[str]=[2, 3, 4] , __lowerCAmelCase : Any=None , ): """simple docstring""" _lowerCamelCase : Dict = parent _lowerCamelCase : str = batch_size _lowerCamelCase : Tuple = image_size _lowerCamelCase : Union[str, Any] = num_channels _lowerCamelCase : Dict = num_stages _lowerCamelCase : Dict = hidden_sizes _lowerCamelCase : Tuple = depths _lowerCamelCase : Any = is_training _lowerCamelCase : Optional[Any] = use_labels _lowerCamelCase : List[str] = intermediate_size _lowerCamelCase : int = hidden_act _lowerCamelCase : str = num_labels _lowerCamelCase : Tuple = initializer_range _lowerCamelCase : List[str] = out_features _lowerCamelCase : Union[str, Any] = out_indices _lowerCamelCase : Dict = scope def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ): """simple docstring""" _lowerCamelCase : Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) _lowerCamelCase : int = None if self.use_labels: _lowerCamelCase : Any = ids_tensor([self.batch_size] , self.num_labels ) _lowerCamelCase : Optional[Any] = self.get_config() return config, pixel_values, labels def SCREAMING_SNAKE_CASE ( self : List[str] ): """simple docstring""" return ConvNextConfig( num_channels=self.num_channels , hidden_sizes=self.hidden_sizes , depths=self.depths , num_stages=self.num_stages , hidden_act=self.hidden_act , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , out_features=self.out_features , out_indices=self.out_indices , num_labels=self.num_labels , ) def SCREAMING_SNAKE_CASE ( self : Union[str, Any] , __lowerCAmelCase : List[Any] , __lowerCAmelCase : Any , __lowerCAmelCase : str ): """simple docstring""" _lowerCamelCase : Any = ConvNextModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _lowerCamelCase : List[Any] = model(UpperCamelCase__ ) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , ) def SCREAMING_SNAKE_CASE ( self : List[str] , __lowerCAmelCase : Union[str, Any] , __lowerCAmelCase : Optional[Any] , __lowerCAmelCase : int ): """simple docstring""" _lowerCamelCase : Union[str, Any] = ConvNextForImageClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _lowerCamelCase : Union[str, Any] = model(UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE ( self : Tuple , __lowerCAmelCase : Optional[int] , __lowerCAmelCase : Tuple , __lowerCAmelCase : str ): """simple docstring""" _lowerCamelCase : Any = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _lowerCamelCase : List[Any] = model(UpperCamelCase__ ) # verify hidden states self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[1], 4, 4] ) # verify channels self.parent.assertEqual(len(model.channels ) , len(config.out_features ) ) self.parent.assertListEqual(model.channels , config.hidden_sizes[1:] ) # verify backbone works with out_features=None _lowerCamelCase : List[Any] = None _lowerCamelCase : Optional[int] = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() _lowerCamelCase : List[Any] = model(UpperCamelCase__ ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , 1 ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[-1], 1, 1] ) # verify channels self.parent.assertEqual(len(model.channels ) , 1 ) self.parent.assertListEqual(model.channels , [config.hidden_sizes[-1]] ) def SCREAMING_SNAKE_CASE ( self : Any ): """simple docstring""" _lowerCamelCase : Tuple = self.prepare_config_and_inputs() _lowerCamelCase , _lowerCamelCase , _lowerCamelCase : Union[str, Any] = config_and_inputs _lowerCamelCase : int = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __snake_case ( _a , _a , unittest.TestCase): snake_case__ : List[Any] = ( ( ConvNextModel, ConvNextForImageClassification, ConvNextBackbone, ) if is_torch_available() else () ) snake_case__ : List[str] = ( {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification} if is_torch_available() else {} ) snake_case__ : Optional[Any] = True snake_case__ : Union[str, Any] = False snake_case__ : Tuple = False snake_case__ : str = False snake_case__ : Any = False def SCREAMING_SNAKE_CASE ( self : Tuple ): """simple docstring""" _lowerCamelCase : List[str] = ConvNextModelTester(self ) _lowerCamelCase : str = ConfigTester(self , config_class=UpperCamelCase__ , has_text_modality=UpperCamelCase__ , hidden_size=3_7 ) def SCREAMING_SNAKE_CASE ( self : List[str] ): """simple docstring""" self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def SCREAMING_SNAKE_CASE ( self : Optional[int] ): """simple docstring""" return @unittest.skip(reason='''ConvNext does not use inputs_embeds''' ) def SCREAMING_SNAKE_CASE ( self : List[str] ): """simple docstring""" pass @unittest.skip(reason='''ConvNext does not support input and output embeddings''' ) def SCREAMING_SNAKE_CASE ( self : List[Any] ): """simple docstring""" pass @unittest.skip(reason='''ConvNext does not use feedforward chunking''' ) def SCREAMING_SNAKE_CASE ( self : Optional[int] ): """simple docstring""" pass def SCREAMING_SNAKE_CASE ( self : Any ): """simple docstring""" _lowerCamelCase , _lowerCamelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowerCamelCase : Any = model_class(UpperCamelCase__ ) _lowerCamelCase : Any = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowerCamelCase : List[Any] = [*signature.parameters.keys()] _lowerCamelCase : List[Any] = ['''pixel_values'''] self.assertListEqual(arg_names[:1] , UpperCamelCase__ ) def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ): """simple docstring""" _lowerCamelCase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def SCREAMING_SNAKE_CASE ( self : Tuple ): """simple docstring""" _lowerCamelCase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*UpperCamelCase__ ) def SCREAMING_SNAKE_CASE ( self : Optional[Any] ): """simple docstring""" def check_hidden_states_output(__lowerCAmelCase : Dict , __lowerCAmelCase : Union[str, Any] , __lowerCAmelCase : Tuple ): _lowerCamelCase : Dict = model_class(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() with torch.no_grad(): _lowerCamelCase : Any = model(**self._prepare_for_class(UpperCamelCase__ , UpperCamelCase__ ) ) _lowerCamelCase : int = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states _lowerCamelCase : Any = self.model_tester.num_stages self.assertEqual(len(UpperCamelCase__ ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) _lowerCamelCase , _lowerCamelCase : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowerCamelCase : str = 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 SCREAMING_SNAKE_CASE ( self : Dict ): """simple docstring""" _lowerCamelCase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ ) @slow def SCREAMING_SNAKE_CASE ( self : Dict ): """simple docstring""" for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowerCamelCase : List[str] = ConvNextModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) def snake_case_ ( ): '''simple docstring''' _lowerCamelCase : List[str] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __snake_case ( unittest.TestCase): @cached_property def SCREAMING_SNAKE_CASE ( self : Optional[Any] ): """simple docstring""" return AutoImageProcessor.from_pretrained('''facebook/convnext-tiny-224''' ) if is_vision_available() else None @slow def SCREAMING_SNAKE_CASE ( self : List[Any] ): """simple docstring""" _lowerCamelCase : Tuple = ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224''' ).to(UpperCamelCase__ ) _lowerCamelCase : Optional[int] = self.default_image_processor _lowerCamelCase : str = prepare_img() _lowerCamelCase : Union[str, Any] = image_processor(images=UpperCamelCase__ , return_tensors='''pt''' ).to(UpperCamelCase__ ) # forward pass with torch.no_grad(): _lowerCamelCase : str = model(**UpperCamelCase__ ) # verify the logits _lowerCamelCase : int = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , UpperCamelCase__ ) _lowerCamelCase : Optional[Any] = torch.tensor([-0.02_60, -0.47_39, 0.19_11] ).to(UpperCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , UpperCamelCase__ , atol=1E-4 ) ) @require_torch class __snake_case ( unittest.TestCase , _a): snake_case__ : List[Any] = (ConvNextBackbone,) if is_torch_available() else () snake_case__ : Optional[Any] = ConvNextConfig snake_case__ : Tuple = False def SCREAMING_SNAKE_CASE ( self : Tuple ): """simple docstring""" _lowerCamelCase : Tuple = ConvNextModelTester(self )
72
'''simple docstring''' from PIL import Image def __lowerCamelCase ( A__ , A__ ) -> Image: """simple docstring""" def brightness(A__ ) -> float: return 128 + level + (c - 128) if not -255.0 <= level <= 255.0: raise ValueError('level must be between -255.0 (black) and 255.0 (white)' ) return img.point(A__ ) if __name__ == "__main__": # Load image with Image.open("image_data/lena.jpg") as img: # Change brightness to 100 _lowerCamelCase : List[str] = change_brightness(img, 100) brigt_img.save("image_data/lena_brightness.png", format="png")
28
0
import argparse import json from collections import OrderedDict import torch from huggingface_hub import cached_download, hf_hub_url from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification def _UpperCAmelCase ( a__): '''simple docstring''' a_ : Optional[Any] = [] embed.append( ( f'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight''', f'''stage{idx}.patch_embed.proj.weight''', )) embed.append( ( f'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias''', f'''stage{idx}.patch_embed.proj.bias''', )) embed.append( ( f'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight''', f'''stage{idx}.patch_embed.norm.weight''', )) embed.append( ( f'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias''', f'''stage{idx}.patch_embed.norm.bias''', )) return embed def _UpperCAmelCase ( a__ , a__): '''simple docstring''' a_ : Tuple = [] attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked''', f'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight''', f'''stage{idx}.blocks.{cnt}.attn.proj_q.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias''', f'''stage{idx}.blocks.{cnt}.attn.proj_q.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight''', f'''stage{idx}.blocks.{cnt}.attn.proj_k.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias''', f'''stage{idx}.blocks.{cnt}.attn.proj_k.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight''', f'''stage{idx}.blocks.{cnt}.attn.proj_v.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias''', f'''stage{idx}.blocks.{cnt}.attn.proj_v.bias''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight''', f'''stage{idx}.blocks.{cnt}.attn.proj.weight''', )) attention_weights.append( ( f'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias''', f'''stage{idx}.blocks.{cnt}.attn.proj.bias''', )) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight''', f'''stage{idx}.blocks.{cnt}.mlp.fc1.weight''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias''', f'''stage{idx}.blocks.{cnt}.mlp.fc1.bias''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight''', f'''stage{idx}.blocks.{cnt}.mlp.fc2.weight''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias''', f'''stage{idx}.blocks.{cnt}.mlp.fc2.bias''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight''', f'''stage{idx}.blocks.{cnt}.norm1.weight''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias''', f'''stage{idx}.blocks.{cnt}.norm1.bias''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight''', f'''stage{idx}.blocks.{cnt}.norm2.weight''')) attention_weights.append( (f'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias''', f'''stage{idx}.blocks.{cnt}.norm2.bias''')) return attention_weights def _UpperCAmelCase ( a__): '''simple docstring''' a_ : Optional[int] = [] token.append((f'''cvt.encoder.stages.{idx}.cls_token''', """stage2.cls_token""")) return token def _UpperCAmelCase ( ): '''simple docstring''' a_ : Union[str, Any] = [] head.append(("""layernorm.weight""", """norm.weight""")) head.append(("""layernorm.bias""", """norm.bias""")) head.append(("""classifier.weight""", """head.weight""")) head.append(("""classifier.bias""", """head.bias""")) return head def _UpperCAmelCase ( a__ , a__ , a__ , a__): '''simple docstring''' a_ : Optional[int] = """imagenet-1k-id2label.json""" a_ : str = 1_0_0_0 a_ : Union[str, Any] = """huggingface/label-files""" a_ : List[str] = num_labels a_ : Union[str, Any] = json.load(open(cached_download(hf_hub_url(A__ , A__ , repo_type="""dataset""")) , """r""")) a_ : Union[str, Any] = {int(A__): v for k, v in idalabel.items()} a_ : Any = idalabel a_ : Dict = {v: k for k, v in idalabel.items()} a_ : str = CvtConfig(num_labels=A__ , idalabel=A__ , labelaid=A__) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1)[-1][4:6] == "13": a_ : Any = [1, 2, 1_0] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1)[-1][4:6] == "21": a_ : str = [1, 4, 1_6] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: a_ : Any = [2, 2, 2_0] a_ : Optional[Any] = [3, 1_2, 1_6] a_ : Union[str, Any] = [1_9_2, 7_6_8, 1_0_2_4] a_ : List[Any] = CvtForImageClassification(A__) a_ : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""") a_ : Union[str, Any] = image_size a_ : int = torch.load(A__ , map_location=torch.device("""cpu""")) a_ : List[str] = OrderedDict() a_ : List[Any] = [] for idx in range(len(config.depth)): if config.cls_token[idx]: a_ : Dict = list_of_state_dict + cls_token(A__) a_ : int = list_of_state_dict + embeddings(A__) for cnt in range(config.depth[idx]): a_ : str = list_of_state_dict + attention(A__ , A__) a_ : Optional[int] = list_of_state_dict + final() for gg in list_of_state_dict: print(A__) for i in range(len(A__)): a_ : Union[str, Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(A__) model.save_pretrained(A__) image_processor.save_pretrained(A__) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": __snake_case : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=3_84, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=r"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) __snake_case : Any = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
248
'''simple docstring''' from . import ( albert, align, altclip, audio_spectrogram_transformer, auto, autoformer, bark, bart, barthez, bartpho, beit, bert, bert_generation, bert_japanese, bertweet, big_bird, bigbird_pegasus, biogpt, bit, blenderbot, blenderbot_small, blip, blip_a, bloom, bridgetower, byta, camembert, canine, chinese_clip, clap, clip, clipseg, codegen, conditional_detr, convbert, convnext, convnextva, cpm, cpmant, ctrl, cvt, dataavec, deberta, deberta_va, decision_transformer, deformable_detr, deit, deprecated, deta, detr, dialogpt, dinat, distilbert, dit, donut, dpr, dpt, efficientformer, efficientnet, electra, encodec, encoder_decoder, ernie, ernie_m, esm, falcon, flaubert, flava, fnet, focalnet, fsmt, funnel, git, glpn, gpta, gpt_bigcode, gpt_neo, gpt_neox, gpt_neox_japanese, gpt_swa, gptj, gptsan_japanese, graphormer, groupvit, herbert, hubert, ibert, imagegpt, informer, instructblip, jukebox, layoutlm, layoutlmva, layoutlmva, layoutxlm, led, levit, lilt, llama, longformer, longta, luke, lxmert, mam_aaa, marian, markuplm, maskaformer, maskformer, mbart, mbartaa, mega, megatron_bert, megatron_gpta, mgp_str, mluke, mobilebert, mobilenet_va, mobilenet_va, mobilevit, mobilevitva, mpnet, mra, mta, musicgen, mvp, nat, nezha, nllb, nllb_moe, nystromformer, oneformer, open_llama, openai, opt, owlvit, pegasus, pegasus_x, perceiver, phobert, pixastruct, plbart, poolformer, prophetnet, qdqbert, rag, realm, reformer, regnet, rembert, resnet, roberta, roberta_prelayernorm, roc_bert, roformer, rwkv, sam, segformer, sew, sew_d, speech_encoder_decoder, speech_to_text, speech_to_text_a, speechta, splinter, squeezebert, swiftformer, swin, swinasr, swinva, switch_transformers, ta, table_transformer, tapas, time_series_transformer, timesformer, timm_backbone, transfo_xl, trocr, tvlt, umta, unispeech, unispeech_sat, upernet, videomae, vilt, vision_encoder_decoder, vision_text_dual_encoder, visual_bert, vit, vit_hybrid, vit_mae, vit_msn, vivit, wavaveca, wavaveca_conformer, wavaveca_phoneme, wavaveca_with_lm, wavlm, whisper, x_clip, xglm, xlm, xlm_prophetnet, xlm_roberta, xlm_roberta_xl, xlnet, xmod, yolos, yoso, )
28
0
import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed _SCREAMING_SNAKE_CASE = logging.getLogger(__name__) def SCREAMING_SNAKE_CASE__ ( __a=2 , __a=3 , __a=16 , __a = 10 , __a = 2 ): def get_dataset(__a ): snake_case_ : Any = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(A__ , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) snake_case_ : int = get_dataset(A__ ) snake_case_ : List[str] = get_dataset(A__ ) snake_case_ : Tuple = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) snake_case_ : Tuple = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) return (train_dataloader, valid_dataloader) def SCREAMING_SNAKE_CASE__ ( __a , __a , __a , __a , __a , __a=None ): snake_case_ : str = [] for epoch in range(A__ ): # Train quickly model.train() for batch in dataloader: snake_case_ ,snake_case_ : Optional[int] = batch snake_case_ : Optional[Any] = model(A__ ) snake_case_ : str = torch.nn.functional.mse_loss(A__ , A__ ) accelerator.backward(A__ ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class SCREAMING_SNAKE_CASE_ ( nn.Module ): def __init__( self : Tuple ) -> Union[str, Any]: """simple docstring""" super().__init__() snake_case_ : List[Any] = nn.Parameter(torch.randn(1 ) ) snake_case_ : str = nn.Parameter(torch.randn(1 ) ) def UpperCAmelCase_ ( self : str , _A : Dict ) -> List[str]: """simple docstring""" return x * self.a + self.b class SCREAMING_SNAKE_CASE_ ( unittest.TestCase ): def UpperCAmelCase_ ( self : Union[str, Any] ) -> Optional[Any]: """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(42 ) snake_case_ : Optional[Any] = DummyModel() snake_case_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ ,snake_case_ : Any = dummy_dataloaders() snake_case_ : List[Any] = ProjectConfiguration(total_limit=1 , project_dir=UpperCamelCase__ , automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline snake_case_ : str = Accelerator(project_config=UpperCamelCase__ ) snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : Optional[Any] = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def UpperCAmelCase_ ( self : Optional[int] ) -> Dict: """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(42 ) snake_case_ : Optional[Any] = DummyModel() snake_case_ : Tuple = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ ,snake_case_ : Dict = dummy_dataloaders() # Train baseline snake_case_ : Optional[int] = Accelerator() snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : Union[str, Any] = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial snake_case_ : Optional[Any] = os.path.join(UpperCamelCase__ , 'initial' ) accelerator.save_state(UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : Union[str, Any] = model.a.item(), model.b.item() snake_case_ : Union[str, Any] = optimizer.state_dict() snake_case_ : str = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : Union[str, Any] = model.a.item(), model.b.item() snake_case_ : str = optimizer.state_dict() # Train partially set_seed(42 ) snake_case_ : int = DummyModel() snake_case_ : Optional[int] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ ,snake_case_ : Dict = dummy_dataloaders() snake_case_ : Dict = Accelerator() snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : Optional[int] = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : Any = model.a.item(), model.b.item() snake_case_ : Any = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) snake_case_ : int = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything snake_case_ : str = os.path.join(UpperCamelCase__ , 'checkpoint' ) accelerator.save_state(UpperCamelCase__ ) # Load everything back in and make sure all states work accelerator.load_state(UpperCamelCase__ ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : List[str] = model.a.item(), model.b.item() snake_case_ : int = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def UpperCAmelCase_ ( self : Union[str, Any] ) -> int: """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(42 ) snake_case_ : Any = DummyModel() snake_case_ : str = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ ,snake_case_ : List[Any] = dummy_dataloaders() snake_case_ : int = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline snake_case_ : Any = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : List[Any] = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() ((snake_case_) ,(snake_case_)) : Any = model.a.item(), model.b.item() snake_case_ : Tuple = optimizer.state_dict() snake_case_ : List[str] = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : List[str] = model.a.item(), model.b.item() snake_case_ : str = optimizer.state_dict() # Train partially set_seed(42 ) snake_case_ : List[Any] = DummyModel() snake_case_ : Union[str, Any] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ ,snake_case_ : Optional[int] = dummy_dataloaders() snake_case_ : str = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=UpperCamelCase__ ) snake_case_ : str = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : int = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ((snake_case_) ,(snake_case_)) : Optional[int] = model.a.item(), model.b.item() snake_case_ : int = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) snake_case_ : int = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((snake_case_) ,(snake_case_)) : Tuple = model.a.item(), model.b.item() snake_case_ : int = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def UpperCAmelCase_ ( self : Optional[int] ) -> str: """simple docstring""" snake_case_ : Tuple = torch.tensor([1, 2, 3] ) snake_case_ : List[str] = torch.tensor([2, 3, 4] ) snake_case_ : Any = DummyModel() snake_case_ : Any = torch.optim.Adam(net.parameters() ) snake_case_ : str = Accelerator() with self.assertRaises(UpperCamelCase__ ) as ve: accelerator.register_for_checkpointing(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) snake_case_ : Union[str, Any] = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def UpperCAmelCase_ ( self : Dict ) -> Optional[Any]: """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(42 ) snake_case_ : List[Any] = DummyModel() snake_case_ : Tuple = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) snake_case_ : str = torch.optim.lr_scheduler.StepLR(UpperCamelCase__ , step_size=1 , gamma=0.9_9 ) snake_case_ ,snake_case_ : Tuple = dummy_dataloaders() snake_case_ : List[str] = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline snake_case_ : Dict = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : List[Any] = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() snake_case_ : Optional[int] = scheduler.state_dict() train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) self.assertNotEqual(UpperCamelCase__ , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(UpperCamelCase__ , scheduler.state_dict() ) def UpperCAmelCase_ ( self : List[str] ) -> Optional[int]: """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(42 ) snake_case_ : List[str] = DummyModel() snake_case_ : Tuple = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ , total_limit=2 ) # Train baseline snake_case_ : Any = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) snake_case_ : Tuple = accelerator.prepare(UpperCamelCase__ ) # Save 3 states: for _ in range(11 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def UpperCAmelCase_ ( self : Dict ) -> Optional[int]: """simple docstring""" snake_case_ : List[Any] = ['torchrun', F"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )] execute_subprocess_async(UpperCamelCase__ , env=os.environ.copy() ) if __name__ == "__main__": _SCREAMING_SNAKE_CASE = "/tmp/accelerate/state_checkpointing" _SCREAMING_SNAKE_CASE = DummyModel() _SCREAMING_SNAKE_CASE = torch.optim.Adam(params=model.parameters(), lr=1e-3) _SCREAMING_SNAKE_CASE = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9) _SCREAMING_SNAKE_CASE = dummy_dataloaders() _SCREAMING_SNAKE_CASE = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline _SCREAMING_SNAKE_CASE = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision="""no""") if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) _SCREAMING_SNAKE_CASE = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) _SCREAMING_SNAKE_CASE = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: _SCREAMING_SNAKE_CASE = group["params"][0].device break assert param_device.type == accelerator.device.type _SCREAMING_SNAKE_CASE = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""cpu""") for group in optimizer.param_groups: _SCREAMING_SNAKE_CASE = group["params"][0].device break assert ( param_device.type == torch.device("""cpu""").type ), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""on_device""") for group in optimizer.param_groups: _SCREAMING_SNAKE_CASE = group["params"][0].device break assert ( param_device.type == accelerator.device.type ), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match="""Unsupported optimizer map location passed"""): accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""invalid""") accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
327
'''simple docstring''' import unittest from transformers import MraConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_torch_available(): import torch from transformers import ( MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, MraModel, ) from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : Any=2 , UpperCamelCase__ : Union[str, Any]=8 , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Any=True , UpperCamelCase__ : str=True , UpperCamelCase__ : Dict=True , UpperCamelCase__ : List[Any]=9_9 , UpperCamelCase__ : List[Any]=1_6 , UpperCamelCase__ : List[str]=5 , UpperCamelCase__ : Dict=2 , UpperCamelCase__ : Optional[int]=3_6 , UpperCamelCase__ : str="gelu" , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Optional[int]=5_1_2 , UpperCamelCase__ : Dict=1_6 , UpperCamelCase__ : List[str]=2 , UpperCamelCase__ : Any=0.0_2 , UpperCamelCase__ : str=3 , UpperCamelCase__ : Tuple=4 , UpperCamelCase__ : Union[str, Any]=None , ): """simple docstring""" UpperCamelCase = parent UpperCamelCase = batch_size UpperCamelCase = seq_length UpperCamelCase = is_training UpperCamelCase = use_input_mask UpperCamelCase = use_token_type_ids UpperCamelCase = use_labels UpperCamelCase = vocab_size UpperCamelCase = hidden_size UpperCamelCase = num_hidden_layers UpperCamelCase = num_attention_heads UpperCamelCase = intermediate_size UpperCamelCase = hidden_act UpperCamelCase = hidden_dropout_prob UpperCamelCase = attention_probs_dropout_prob UpperCamelCase = max_position_embeddings UpperCamelCase = type_vocab_size UpperCamelCase = type_sequence_label_size UpperCamelCase = initializer_range UpperCamelCase = num_labels UpperCamelCase = num_choices UpperCamelCase = scope def A ( self : int ): """simple docstring""" UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase = None if self.use_input_mask: UpperCamelCase = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase = None if self.use_token_type_ids: UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCamelCase = 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] , self.num_choices ) UpperCamelCase = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def A ( self : Optional[int] ): """simple docstring""" return MraConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.get_config() UpperCamelCase = 3_0_0 return config def A ( self : Tuple ): """simple docstring""" ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = self.prepare_config_and_inputs() UpperCamelCase = True UpperCamelCase = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : int , UpperCamelCase__ : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : int , UpperCamelCase__ : List[str] , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = MraModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : List[str] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : str , UpperCamelCase__ : Dict , UpperCamelCase__ : Optional[Any] , ): """simple docstring""" UpperCamelCase = True UpperCamelCase = MraModel(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , encoder_attention_mask=UpperCamelCase__ , ) UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , ) UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : int , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[Any] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = MraForMaskedLM(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[str] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = MraForQuestionAnswering(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , start_positions=UpperCamelCase__ , end_positions=UpperCamelCase__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def A ( self : Optional[int] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForSequenceClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : int , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForTokenClassification(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def A ( self : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : str , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = self.num_choices UpperCamelCase = MraForMultipleChoice(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) 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( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def A ( self : int ): """simple docstring""" UpperCamelCase = self.prepare_config_and_inputs() ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = config_and_inputs UpperCamelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE ( _a , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( MraModel, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, ) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = () def A ( self : str ): """simple docstring""" UpperCamelCase = MraModelTester(self ) UpperCamelCase = ConfigTester(self , config_class=UpperCamelCase__ , hidden_size=3_7 ) def A ( self : str ): """simple docstring""" self.config_tester.run_common_tests() def A ( self : Optional[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : str ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: UpperCamelCase = type self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__ ) def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase__ ) def A ( self : Tuple ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__ ) @slow def A ( self : List[Any] ): """simple docstring""" for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase = MraModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) @unittest.skip(reason='MRA does not output attentions' ) def A ( self : List[str] ): """simple docstring""" return @require_torch class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" @slow def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = MraModel.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = torch.Size((1, 2_5_6, 7_6_8) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 2_5_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3' ) UpperCamelCase = torch.arange(4_0_9_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 4_0_9_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) )
28
0
from typing import Dict, List, Optional, Tuple, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, flip_channel_order, get_resize_output_image_size, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging if is_vision_available(): import PIL if is_torch_available(): import torch _snake_case = logging.get_logger(__name__) class UpperCAmelCase_ ( _a): lowerCamelCase__ = ['pixel_values'] def __init__( self, __a = True, __a = None, __a = PILImageResampling.BILINEAR, __a = True, __a = 1 / 255, __a = True, __a = None, __a = True, **__a, ): '''simple docstring''' super().__init__(**UpperCamelCase__) _lowerCAmelCase : Tuple = size if size is not None else {"shortest_edge": 224} _lowerCAmelCase : Any = get_size_dict(UpperCamelCase__, default_to_square=UpperCamelCase__) _lowerCAmelCase : Tuple = crop_size if crop_size is not None else {"height": 256, "width": 256} _lowerCAmelCase : int = get_size_dict(UpperCamelCase__, param_name="crop_size") _lowerCAmelCase : Optional[int] = do_resize _lowerCAmelCase : List[Any] = size _lowerCAmelCase : int = resample _lowerCAmelCase : List[str] = do_rescale _lowerCAmelCase : Tuple = rescale_factor _lowerCAmelCase : Dict = do_center_crop _lowerCAmelCase : List[str] = crop_size _lowerCAmelCase : Any = do_flip_channel_order def snake_case__ ( self, __a, __a, __a = PIL.Image.BILINEAR, __a = None, **__a, ): '''simple docstring''' _lowerCAmelCase : Optional[Any] = get_size_dict(UpperCamelCase__, default_to_square=UpperCamelCase__) if "shortest_edge" not in size: raise ValueError(f"The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}") _lowerCAmelCase : Tuple = get_resize_output_image_size(UpperCamelCase__, size=size["shortest_edge"], default_to_square=UpperCamelCase__) return resize(UpperCamelCase__, size=UpperCamelCase__, resample=UpperCamelCase__, data_format=UpperCamelCase__, **UpperCamelCase__) def snake_case__ ( self, __a, __a, __a = None, **__a, ): '''simple docstring''' _lowerCAmelCase : Dict = get_size_dict(UpperCamelCase__) if "height" not in size or "width" not in size: raise ValueError(f"The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}") return center_crop(UpperCamelCase__, size=(size["height"], size["width"]), data_format=UpperCamelCase__, **UpperCamelCase__) def snake_case__ ( self, __a, __a, __a = None, **__a, ): '''simple docstring''' return rescale(UpperCamelCase__, scale=UpperCamelCase__, data_format=UpperCamelCase__, **UpperCamelCase__) def snake_case__ ( self, __a, __a = None): '''simple docstring''' return flip_channel_order(UpperCamelCase__, data_format=UpperCamelCase__) def snake_case__ ( self, __a, __a = None, __a = None, __a = None, __a = None, __a = None, __a = None, __a = None, __a = None, __a = None, __a = ChannelDimension.FIRST, **__a, ): '''simple docstring''' _lowerCAmelCase : Dict = do_resize if do_resize is not None else self.do_resize _lowerCAmelCase : Dict = resample if resample is not None else self.resample _lowerCAmelCase : Dict = do_rescale if do_rescale is not None else self.do_rescale _lowerCAmelCase : Dict = rescale_factor if rescale_factor is not None else self.rescale_factor _lowerCAmelCase : Union[str, Any] = do_center_crop if do_center_crop is not None else self.do_center_crop _lowerCAmelCase : Optional[int] = ( do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order ) _lowerCAmelCase : Union[str, Any] = size if size is not None else self.size _lowerCAmelCase : Union[str, Any] = get_size_dict(UpperCamelCase__, default_to_square=UpperCamelCase__) _lowerCAmelCase : List[str] = crop_size if crop_size is not None else self.crop_size _lowerCAmelCase : Optional[int] = get_size_dict(UpperCamelCase__, param_name="crop_size") _lowerCAmelCase : List[Any] = make_list_of_images(UpperCamelCase__) if not valid_images(UpperCamelCase__): raise ValueError( "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, " "torch.Tensor, tf.Tensor or jax.ndarray.") if do_resize and size is None: raise ValueError("Size must be specified if do_resize is True.") if do_rescale and rescale_factor is None: raise ValueError("Rescale factor must be specified if do_rescale is True.") if do_center_crop and crop_size is None: raise ValueError("Crop size must be specified if do_center_crop is True.") # All transformations expect numpy arrays. _lowerCAmelCase : Union[str, Any] = [to_numpy_array(UpperCamelCase__) for image in images] if do_resize: _lowerCAmelCase : Tuple = [self.resize(image=UpperCamelCase__, size=UpperCamelCase__, resample=UpperCamelCase__) for image in images] if do_center_crop: _lowerCAmelCase : Dict = [self.center_crop(image=UpperCamelCase__, size=UpperCamelCase__) for image in images] if do_rescale: _lowerCAmelCase : Any = [self.rescale(image=UpperCamelCase__, scale=UpperCamelCase__) for image in images] # the pretrained checkpoints assume images are BGR, not RGB if do_flip_channel_order: _lowerCAmelCase : List[Any] = [self.flip_channel_order(image=UpperCamelCase__) for image in images] _lowerCAmelCase : Optional[Any] = [to_channel_dimension_format(UpperCamelCase__, UpperCamelCase__) for image in images] _lowerCAmelCase : List[str] = {"pixel_values": images} return BatchFeature(data=UpperCamelCase__, tensor_type=UpperCamelCase__) def snake_case__ ( self, __a, __a = None): '''simple docstring''' _lowerCAmelCase : int = outputs.logits # Resize logits and compute semantic segmentation maps if target_sizes is not None: if len(UpperCamelCase__) != len(UpperCamelCase__): raise ValueError( "Make sure that you pass in as many target sizes as the batch dimension of the logits") if is_torch_tensor(UpperCamelCase__): _lowerCAmelCase : Tuple = target_sizes.numpy() _lowerCAmelCase : List[str] = [] for idx in range(len(UpperCamelCase__)): _lowerCAmelCase : int = torch.nn.functional.interpolate( logits[idx].unsqueeze(dim=0), size=target_sizes[idx], mode="bilinear", align_corners=UpperCamelCase__) _lowerCAmelCase : str = resized_logits[0].argmax(dim=0) semantic_segmentation.append(UpperCamelCase__) else: _lowerCAmelCase : Optional[int] = logits.argmax(dim=1) _lowerCAmelCase : int = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0])] return semantic_segmentation
36
'''simple docstring''' import numpy as np import torch from torch.nn import CrossEntropyLoss from transformers import AutoModelForCausalLM, AutoTokenizer import datasets from datasets import logging _lowerCamelCase : Union[str, Any] = "\\n\n" _lowerCamelCase : List[str] = "\nPerplexity (PPL) is one of the most common metrics for evaluating language models.\nIt is defined as the exponentiated average negative log-likelihood of a sequence.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n" _lowerCamelCase : Dict = "\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n input_texts (list of str): input text, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to 'cuda' when available\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = [\"lorem ipsum\", \"Happy Birthday!\", \"Bienvenue\"]\n >>> results = perplexity.compute(model_id='gpt2',\n ... add_start_token=False,\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 78.22\n >>> print(round(results[\"perplexities\"][0], 2))\n 11.11\n\n Example 2:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = datasets.load_dataset(\"wikitext\",\n ... \"wikitext-2-raw-v1\",\n ... split=\"test\")[\"text\"][:50] # doctest:+ELLIPSIS\n [...]\n >>> input_texts = [s for s in input_texts if s!='']\n >>> results = perplexity.compute(model_id='gpt2',\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 60.35\n >>> print(round(results[\"perplexities\"][0], 2))\n 81.12\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Tuple ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'input_texts': datasets.Value('string' ), } ) , reference_urls=['https://huggingface.co/docs/transformers/perplexity'] , ) def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : int = 1_6 , UpperCamelCase__ : bool = True , UpperCamelCase__ : List[Any]=None ): """simple docstring""" if device is not None: assert device in ["gpu", "cpu", "cuda"], "device should be either gpu or cpu." if device == "gpu": UpperCamelCase = 'cuda' else: UpperCamelCase = 'cuda' if torch.cuda.is_available() else 'cpu' UpperCamelCase = AutoModelForCausalLM.from_pretrained(UpperCamelCase__ ) UpperCamelCase = model.to(UpperCamelCase__ ) UpperCamelCase = AutoTokenizer.from_pretrained(UpperCamelCase__ ) # if batch_size > 1 (which generally leads to padding being required), and # if there is not an already assigned pad_token, assign an existing # special token to also be the padding token if tokenizer.pad_token is None and batch_size > 1: UpperCamelCase = list(tokenizer.special_tokens_map_extended.values() ) # check that the model already has at least one special token defined assert ( len(UpperCamelCase__ ) > 0 ), "If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1." # assign one of the special tokens to also be the pad token tokenizer.add_special_tokens({'pad_token': existing_special_tokens[0]} ) if add_start_token: # leave room for <BOS> token to be added: assert ( tokenizer.bos_token is not None ), "Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False" UpperCamelCase = model.config.max_length - 1 else: UpperCamelCase = model.config.max_length UpperCamelCase = tokenizer( UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=UpperCamelCase__ , return_tensors='pt' , return_attention_mask=UpperCamelCase__ , ).to(UpperCamelCase__ ) UpperCamelCase = encodings['input_ids'] UpperCamelCase = encodings['attention_mask'] # check that each input is long enough: if add_start_token: assert torch.all(torch.ge(attn_masks.sum(1 ) , 1 ) ), "Each input text must be at least one token long." else: assert torch.all( torch.ge(attn_masks.sum(1 ) , 2 ) ), "When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings." UpperCamelCase = [] UpperCamelCase = CrossEntropyLoss(reduction='none' ) for start_index in logging.tqdm(range(0 , len(UpperCamelCase__ ) , UpperCamelCase__ ) ): UpperCamelCase = min(start_index + batch_size , len(UpperCamelCase__ ) ) UpperCamelCase = encoded_texts[start_index:end_index] UpperCamelCase = attn_masks[start_index:end_index] if add_start_token: UpperCamelCase = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0 ) ).to(UpperCamelCase__ ) UpperCamelCase = torch.cat([bos_tokens_tensor, encoded_batch] , dim=1 ) UpperCamelCase = torch.cat( [torch.ones(bos_tokens_tensor.size() , dtype=torch.intaa ).to(UpperCamelCase__ ), attn_mask] , dim=1 ) UpperCamelCase = encoded_batch with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ ).logits UpperCamelCase = out_logits[..., :-1, :].contiguous() UpperCamelCase = labels[..., 1:].contiguous() UpperCamelCase = attn_mask[..., 1:].contiguous() UpperCamelCase = torch.expa( (loss_fct(shift_logits.transpose(1 , 2 ) , UpperCamelCase__ ) * shift_attention_mask_batch).sum(1 ) / shift_attention_mask_batch.sum(1 ) ) ppls += perplexity_batch.tolist() return {"perplexities": ppls, "mean_perplexity": np.mean(UpperCamelCase__ )}
28
0
lowerCAmelCase = [ "DownloadConfig", "DownloadManager", "DownloadMode", "StreamingDownloadManager", ] from .download_config import DownloadConfig from .download_manager import DownloadManager, DownloadMode from .streaming_download_manager import StreamingDownloadManager
295
'''simple docstring''' def __lowerCamelCase ( A__ = 50 ) -> int: """simple docstring""" UpperCamelCase = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(f'''{solution() = }''')
28
0
'''simple docstring''' import math import random from typing import Any from .hill_climbing import SearchProblem def lowerCamelCase__ ( _A , _A = True , _A = math.inf , _A = -math.inf , _A = math.inf , _A = -math.inf , _A = False , _A = 100 , _A = 0.01 , _A = 1 , ): a : Union[str, Any] = False a : List[Any] = search_prob a : Any = start_temperate a : List[str] = [] a : Any = 0 a : str = None while not search_end: a : Union[str, Any] = current_state.score() if best_state is None or current_score > best_state.score(): a : Tuple = current_state scores.append(A__ ) iterations += 1 a : Dict = None a : int = current_state.get_neighbors() while ( next_state is None and neighbors ): # till we do not find a neighbor that we can move to a : str = random.randint(0 , len(A__ ) - 1 ) # picking a random neighbor a : Dict = neighbors.pop(A__ ) a : str = picked_neighbor.score() - current_score if ( picked_neighbor.x > max_x or picked_neighbor.x < min_x or picked_neighbor.y > max_y or picked_neighbor.y < min_y ): continue # neighbor outside our bounds if not find_max: a : List[str] = change * -1 # in case we are finding minimum if change > 0: # improves the solution a : Optional[Any] = picked_neighbor else: a : Optional[Any] = (math.e) ** ( change / current_temp ) # probability generation function if random.random() < probability: # random number within probability a : Tuple = picked_neighbor a : int = current_temp - (current_temp * rate_of_decrease) if current_temp < threshold_temp or next_state is None: # temperature below threshold, or could not find a suitable neighbor a : Optional[Any] = True else: a : int = next_state if visualization: from matplotlib import pyplot as plt plt.plot(range(A__ ) , A__ ) plt.xlabel('Iterations' ) plt.ylabel('Function values' ) plt.show() return best_state if __name__ == "__main__": def lowerCamelCase__ ( _A , _A ): return (x**2) + (y**2) # starting the problem with initial coordinates (12, 47) lowerCAmelCase: Tuple = SearchProblem(x=1_2, y=4_7, step_size=1, function_to_optimize=test_fa) lowerCAmelCase: Optional[Any] = simulated_annealing( prob, find_max=False, max_x=1_0_0, min_x=5, max_y=5_0, min_y=-5, visualization=True ) print( 'The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 ' F"and 50 > y > - 5 found via hill climbing: {local_min.score()}" ) # starting the problem with initial coordinates (12, 47) lowerCAmelCase: Optional[Any] = SearchProblem(x=1_2, y=4_7, step_size=1, function_to_optimize=test_fa) lowerCAmelCase: List[Any] = simulated_annealing( prob, find_max=True, max_x=1_0_0, min_x=5, max_y=5_0, min_y=-5, visualization=True ) print( 'The maximum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 ' F"and 50 > y > - 5 found via hill climbing: {local_min.score()}" ) def lowerCamelCase__ ( _A , _A ): return (3 * x**2) - (6 * y) lowerCAmelCase: Optional[int] = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa) lowerCAmelCase: Tuple = simulated_annealing(prob, find_max=False, visualization=True) print( 'The minimum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: ' F"{local_min.score()}" ) lowerCAmelCase: List[Any] = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa) lowerCAmelCase: str = simulated_annealing(prob, find_max=True, visualization=True) print( 'The maximum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: ' F"{local_min.score()}" )
297
'''simple docstring''' def __lowerCamelCase ( A__ ) -> list: """simple docstring""" UpperCamelCase = len(A__ ) for i in range(1 , A__ ): UpperCamelCase = collection[i] UpperCamelCase = 0 UpperCamelCase = i - 1 while low <= high: UpperCamelCase = (low + high) // 2 if val < collection[mid]: UpperCamelCase = mid - 1 else: UpperCamelCase = mid + 1 for j in range(A__ , A__ , -1 ): UpperCamelCase = collection[j - 1] UpperCamelCase = val return collection if __name__ == "__main__": _lowerCamelCase : int = input("Enter numbers separated by a comma:\n").strip() _lowerCamelCase : Union[str, Any] = [int(item) for item in user_input.split(",")] print(binary_insertion_sort(unsorted))
28
0
"""simple docstring""" import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging a = logging.get_logger(__name__) a = "▁" a = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} a = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } a = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } a = { "ernie-m-base": 514, "ernie-m-large": 514, } a = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class lowercase_ ( _a ): '''simple docstring''' UpperCAmelCase : List[Any] = ['''input_ids'''] UpperCAmelCase : Tuple = VOCAB_FILES_NAMES UpperCAmelCase : Optional[Any] = PRETRAINED_INIT_CONFIGURATION UpperCAmelCase : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCAmelCase : Optional[Any] = PRETRAINED_VOCAB_FILES_MAP UpperCAmelCase : Union[str, Any] = RESOURCE_FILES_NAMES def __init__( self : int , _UpperCAmelCase : int , _UpperCAmelCase : Tuple=None , _UpperCAmelCase : Any=False , _UpperCAmelCase : int="utf8" , _UpperCAmelCase : Tuple="[UNK]" , _UpperCAmelCase : List[Any]="[SEP]" , _UpperCAmelCase : str="[PAD]" , _UpperCAmelCase : Union[str, Any]="[CLS]" , _UpperCAmelCase : List[Any]="[MASK]" , _UpperCAmelCase : Optional[Dict[str, Any]] = None , **_UpperCAmelCase : int , ): _A = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=UpperCamelCase__ , unk_token=UpperCamelCase__ , sep_token=UpperCamelCase__ , pad_token=UpperCamelCase__ , cls_token=UpperCamelCase__ , mask_token=UpperCamelCase__ , vocab_file=UpperCamelCase__ , encoding=UpperCamelCase__ , sp_model_kwargs=self.sp_model_kwargs , **UpperCamelCase__ , ) _A = do_lower_case _A = sentencepiece_model_ckpt _A = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(UpperCamelCase__ ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: _A = self.load_vocab(filepath=UpperCamelCase__ ) else: _A = {self.sp_model.id_to_piece(UpperCamelCase__ ): id for id in range(self.sp_model.get_piece_size() )} _A = {v: k for k, v in self.vocab.items()} def lowerCAmelCase_ ( self : Optional[int] , _UpperCAmelCase : Tuple ): if text is None: return None _A = self.tokenize(UpperCamelCase__ ) _A , _A = '', [] for i, ch in enumerate(UpperCamelCase__ ): if ch in self.SP_CHAR_MAPPING: _A = self.SP_CHAR_MAPPING.get(UpperCamelCase__ ) else: _A = unicodedata.normalize('NFKC' , UpperCamelCase__ ) if self.is_whitespace(UpperCamelCase__ ): continue normalized_text += ch char_mapping.extend([i] * len(UpperCamelCase__ ) ) _A , _A , _A = normalized_text, [], 0 if self.do_lower_case: _A = text.lower() for token in split_tokens: if token[:1] == "▁": _A = token[1:] _A = text[offset:].index(UpperCamelCase__ ) + offset _A = start + len(UpperCamelCase__ ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) _A = end return token_mapping @property def lowerCAmelCase_ ( self : List[str] ): return len(self.vocab ) def lowerCAmelCase_ ( self : List[str] ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : Optional[Any] ): _A = self.__dict__.copy() _A = None return state def __setstate__( self : List[Any] , _UpperCAmelCase : List[str] ): _A = d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): _A = {} _A = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def lowerCAmelCase_ ( self : Optional[int] , _UpperCAmelCase : Any ): return "".join((self.SP_CHAR_MAPPING.get(UpperCamelCase__ , UpperCamelCase__ ) for c in text) ) def lowerCAmelCase_ ( self : Union[str, Any] , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : List[str]=False , _UpperCAmelCase : str=64 , _UpperCAmelCase : Optional[Any]=0.1 ): if self.sp_model_kwargs.get('enable_sampling' ) is True: _A = True if self.sp_model_kwargs.get('alpha' ) is not None: _A = self.sp_model_kwargs.get('alpha' ) if self.sp_model_kwargs.get('nbest_size' ) is not None: _A = self.sp_model_kwargs.get('nbest_size' ) if not enable_sampling: _A = self.sp_model.EncodeAsPieces(UpperCamelCase__ ) else: _A = self.sp_model.SampleEncodeAsPieces(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) _A = [] for pi, piece in enumerate(UpperCamelCase__ ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(UpperCamelCase__ ) and pi != 0: new_pieces.append(UpperCamelCase__ ) continue else: continue _A = 0 for i, chunk in enumerate(UpperCamelCase__ ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(UpperCamelCase__ ) or self.is_punct(UpperCamelCase__ ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(UpperCamelCase__ ) _A = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) _A = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) _A = i if len(UpperCamelCase__ ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def lowerCAmelCase_ ( self : Tuple , _UpperCAmelCase : Any ): _A = ''.join(UpperCamelCase__ ).replace(UpperCamelCase__ , ' ' ).strip() return out_string def lowerCAmelCase_ ( self : Dict , _UpperCAmelCase : Union[str, Any] ): _A = self.convert_ids_to_tokens(UpperCamelCase__ ) _A = ''.join(UpperCamelCase__ ).replace(UpperCamelCase__ , ' ' ).strip() return out_string def lowerCAmelCase_ ( self : int , _UpperCAmelCase : List[Any] ): return self.vocab.get(UpperCamelCase__ , self.vocab.get(self.unk_token ) ) def lowerCAmelCase_ ( self : Optional[int] , _UpperCAmelCase : List[Any] ): return self.reverse_vocab.get(UpperCamelCase__ , self.unk_token ) def lowerCAmelCase_ ( self : List[str] , _UpperCAmelCase : Any , _UpperCAmelCase : str=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] _A = [self.cls_token_id] _A = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def lowerCAmelCase_ ( self : Optional[Any] , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : int=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def lowerCAmelCase_ ( self : List[Any] , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Union[str, Any]=None , _UpperCAmelCase : Union[str, Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( 'You should not supply a second sequence if the provided sequence of ' 'ids is already formatted with special tokens for the model.' ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(UpperCamelCase__ )) + [1, 1] + ([0] * len(UpperCamelCase__ )) + [1] return [1] + ([0] * len(UpperCamelCase__ )) + [1] def lowerCAmelCase_ ( self : str , _UpperCAmelCase : List[int] , _UpperCAmelCase : Optional[List[int]] = None ): if token_ids_a is None: # [CLS] X [SEP] return (len(UpperCamelCase__ ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(UpperCamelCase__ ) + 1) + [1] * (len(UpperCamelCase__ ) + 3) def lowerCAmelCase_ ( self : Union[str, Any] , _UpperCAmelCase : int ): if "\u4e00" <= char <= "\u9fff": return True return False def lowerCAmelCase_ ( self : List[str] , _UpperCAmelCase : str ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def lowerCAmelCase_ ( self : Optional[Any] , _UpperCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def lowerCAmelCase_ ( self : str , _UpperCAmelCase : str ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(UpperCamelCase__ ) == 1: _A = unicodedata.category(UpperCamelCase__ ) if cat == "Zs": return True return False def lowerCAmelCase_ ( self : List[Any] , _UpperCAmelCase : List[str] ): _A = {} with io.open(UpperCamelCase__ , 'r' , encoding='utf-8' ) as f: for index, line in enumerate(UpperCamelCase__ ): _A = line.rstrip('\n' ) _A = int(UpperCamelCase__ ) return token_to_idx def lowerCAmelCase_ ( self : str , _UpperCAmelCase : str , _UpperCAmelCase : Optional[str] = None ): _A = 0 if os.path.isdir(UpperCamelCase__ ): _A = os.path.join( UpperCamelCase__ , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) else: _A = (filename_prefix + '-' if filename_prefix else '') + save_directory with open(UpperCamelCase__ , 'w' , encoding='utf-8' ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _UpperCAmelCase : kv[1] ): if index != token_index: logger.warning( F'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' ' Please check that the vocabulary is not corrupted!' ) _A = token_index writer.write(token + '\n' ) index += 1 _A = os.path.join(UpperCamelCase__ , 'sentencepiece.bpe.model' ) with open(UpperCamelCase__ , 'wb' ) as fi: _A = self.sp_model.serialized_model_proto() fi.write(UpperCamelCase__ ) return (vocab_file,)
315
'''simple docstring''' import math from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass # Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->UnCLIP class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = None def __lowerCamelCase ( A__ , A__=0.999 , A__="cosine" , ) -> Tuple: """simple docstring""" if alpha_transform_type == "cosine": def alpha_bar_fn(A__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(A__ ): return math.exp(t * -12.0 ) else: raise ValueError(F"""Unsupported alpha_tranform_type: {alpha_transform_type}""" ) UpperCamelCase = [] for i in range(A__ ): UpperCamelCase = i / num_diffusion_timesteps UpperCamelCase = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(A__ ) / alpha_bar_fn(A__ ) , A__ ) ) return torch.tensor(A__ , dtype=torch.floataa ) class SCREAMING_SNAKE_CASE ( _a , _a ): """simple docstring""" @register_to_config def __init__( self : List[str] , UpperCamelCase__ : int = 1_0_0_0 , UpperCamelCase__ : str = "fixed_small_log" , UpperCamelCase__ : bool = True , UpperCamelCase__ : Optional[float] = 1.0 , UpperCamelCase__ : str = "epsilon" , UpperCamelCase__ : str = "squaredcos_cap_v2" , ): """simple docstring""" if beta_schedule != "squaredcos_cap_v2": raise ValueError('UnCLIPScheduler only supports `beta_schedule`: \'squaredcos_cap_v2\'' ) UpperCamelCase = betas_for_alpha_bar(UpperCamelCase__ ) UpperCamelCase = 1.0 - self.betas UpperCamelCase = torch.cumprod(self.alphas , dim=0 ) UpperCamelCase = torch.tensor(1.0 ) # standard deviation of the initial noise distribution UpperCamelCase = 1.0 # setable values UpperCamelCase = None UpperCamelCase = torch.from_numpy(np.arange(0 , UpperCamelCase__ )[::-1].copy() ) UpperCamelCase = variance_type def A ( self : Dict , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None ): """simple docstring""" return sample def A ( self : List[str] , UpperCamelCase__ : int , UpperCamelCase__ : Union[str, torch.device] = None ): """simple docstring""" UpperCamelCase = num_inference_steps UpperCamelCase = (self.config.num_train_timesteps - 1) / (self.num_inference_steps - 1) UpperCamelCase = (np.arange(0 , UpperCamelCase__ ) * step_ratio).round()[::-1].copy().astype(np.intaa ) UpperCamelCase = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) def A ( self : Dict , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any]=None , UpperCamelCase__ : Optional[int]=None , UpperCamelCase__ : Tuple=None ): """simple docstring""" if prev_timestep is None: UpperCamelCase = t - 1 UpperCamelCase = self.alphas_cumprod[t] UpperCamelCase = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one UpperCamelCase = 1 - alpha_prod_t UpperCamelCase = 1 - alpha_prod_t_prev if prev_timestep == t - 1: UpperCamelCase = self.betas[t] else: UpperCamelCase = 1 - alpha_prod_t / alpha_prod_t_prev # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf) # and sample from it to get previous sample # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample UpperCamelCase = beta_prod_t_prev / beta_prod_t * beta if variance_type is None: UpperCamelCase = self.config.variance_type # hacks - were probably added for training stability if variance_type == "fixed_small_log": UpperCamelCase = torch.log(torch.clamp(UpperCamelCase__ , min=1E-2_0 ) ) UpperCamelCase = torch.exp(0.5 * variance ) elif variance_type == "learned_range": # NOTE difference with DDPM scheduler UpperCamelCase = variance.log() UpperCamelCase = beta.log() UpperCamelCase = (predicted_variance + 1) / 2 UpperCamelCase = frac * max_log + (1 - frac) * min_log return variance def A ( self : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None , UpperCamelCase__ : str=None , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = timestep if model_output.shape[1] == sample.shape[1] * 2 and self.variance_type == "learned_range": UpperCamelCase , UpperCamelCase = torch.split(UpperCamelCase__ , sample.shape[1] , dim=1 ) else: UpperCamelCase = None # 1. compute alphas, betas if prev_timestep is None: UpperCamelCase = t - 1 UpperCamelCase = self.alphas_cumprod[t] UpperCamelCase = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one UpperCamelCase = 1 - alpha_prod_t UpperCamelCase = 1 - alpha_prod_t_prev if prev_timestep == t - 1: UpperCamelCase = self.betas[t] UpperCamelCase = self.alphas[t] else: UpperCamelCase = 1 - alpha_prod_t / alpha_prod_t_prev UpperCamelCase = 1 - beta # 2. compute predicted original sample from predicted noise also called # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf if self.config.prediction_type == "epsilon": UpperCamelCase = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 elif self.config.prediction_type == "sample": UpperCamelCase = model_output else: raise ValueError( f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `sample`""" ' for the UnCLIPScheduler.' ) # 3. Clip "predicted x_0" if self.config.clip_sample: UpperCamelCase = torch.clamp( UpperCamelCase__ , -self.config.clip_sample_range , self.config.clip_sample_range ) # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf UpperCamelCase = (alpha_prod_t_prev ** 0.5 * beta) / beta_prod_t UpperCamelCase = alpha ** 0.5 * beta_prod_t_prev / beta_prod_t # 5. Compute predicted previous sample µ_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf UpperCamelCase = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample # 6. Add noise UpperCamelCase = 0 if t > 0: UpperCamelCase = randn_tensor( model_output.shape , dtype=model_output.dtype , generator=UpperCamelCase__ , device=model_output.device ) UpperCamelCase = self._get_variance( UpperCamelCase__ , predicted_variance=UpperCamelCase__ , prev_timestep=UpperCamelCase__ , ) if self.variance_type == "fixed_small_log": UpperCamelCase = variance elif self.variance_type == "learned_range": UpperCamelCase = (0.5 * variance).exp() else: raise ValueError( f"""variance_type given as {self.variance_type} must be one of `fixed_small_log` or `learned_range`""" ' for the UnCLIPScheduler.' ) UpperCamelCase = variance * variance_noise UpperCamelCase = pred_prev_sample + variance if not return_dict: return (pred_prev_sample,) return UnCLIPSchedulerOutput(prev_sample=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.IntTensor , ): """simple docstring""" UpperCamelCase = self.alphas_cumprod.to(device=original_samples.device , dtype=original_samples.dtype ) UpperCamelCase = timesteps.to(original_samples.device ) UpperCamelCase = alphas_cumprod[timesteps] ** 0.5 UpperCamelCase = sqrt_alpha_prod.flatten() while len(sqrt_alpha_prod.shape ) < len(original_samples.shape ): UpperCamelCase = sqrt_alpha_prod.unsqueeze(-1 ) UpperCamelCase = (1 - alphas_cumprod[timesteps]) ** 0.5 UpperCamelCase = sqrt_one_minus_alpha_prod.flatten() while len(sqrt_one_minus_alpha_prod.shape ) < len(original_samples.shape ): UpperCamelCase = sqrt_one_minus_alpha_prod.unsqueeze(-1 ) UpperCamelCase = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise return noisy_samples
28
0
import sys import tempfile import unittest import unittest.mock as mock from pathlib import Path from huggingface_hub import HfFolder, delete_repo from requests.exceptions import HTTPError from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test sys.path.append(str(Path(__file__).parent.parent / "utils")) from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 _snake_case = get_tests_dir("fixtures") class lowercase ( unittest.TestCase ): def a__ ( self ) -> Any: _A : Union[str, Any] = mock.Mock() _A : str = 500 _A : List[str] = {} _A : Optional[int] = HTTPError _A : Union[str, Any] = {} # Download this model to make sure it's in the cache. _A : str = WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2""" ) # Under the mock environment we get a 500 error when trying to reach the model. with mock.patch("""requests.Session.request""" , return_value=UpperCamelCase__ ) as mock_head: _A : Optional[Any] = WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2""" ) # This check we did call the fake head request mock_head.assert_called() def a__ ( self ) -> Tuple: _A : List[Any] = WavaVecaFeatureExtractor.from_pretrained( """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json""" ) @is_staging_test class lowercase ( unittest.TestCase ): @classmethod def a__ ( cls ) -> Union[str, Any]: _A : Optional[int] = TOKEN HfFolder.save_token(UpperCamelCase__ ) @classmethod def a__ ( cls ) -> Tuple: try: delete_repo(token=cls._token , repo_id="""test-feature-extractor""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""valid_org/test-feature-extractor-org""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""test-dynamic-feature-extractor""" ) except HTTPError: pass def a__ ( self ) -> Dict: _A : str = WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__ ) feature_extractor.push_to_hub("""test-feature-extractor""" , use_auth_token=self._token ) _A : Dict = WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''' ) for k, v in feature_extractor.__dict__.items(): self.assertEqual(UpperCamelCase__ , getattr(UpperCamelCase__ , UpperCamelCase__ ) ) # Reset repo delete_repo(token=self._token , repo_id="""test-feature-extractor""" ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained( UpperCamelCase__ , repo_id="""test-feature-extractor""" , push_to_hub=UpperCamelCase__ , use_auth_token=self._token ) _A : List[Any] = WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor''' ) for k, v in feature_extractor.__dict__.items(): self.assertEqual(UpperCamelCase__ , getattr(UpperCamelCase__ , UpperCamelCase__ ) ) def a__ ( self ) -> Tuple: _A : Any = WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__ ) feature_extractor.push_to_hub("""valid_org/test-feature-extractor""" , use_auth_token=self._token ) _A : Tuple = WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor""" ) for k, v in feature_extractor.__dict__.items(): self.assertEqual(UpperCamelCase__ , getattr(UpperCamelCase__ , UpperCamelCase__ ) ) # Reset repo delete_repo(token=self._token , repo_id="""valid_org/test-feature-extractor""" ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained( UpperCamelCase__ , repo_id="""valid_org/test-feature-extractor-org""" , push_to_hub=UpperCamelCase__ , use_auth_token=self._token ) _A : Dict = WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org""" ) for k, v in feature_extractor.__dict__.items(): self.assertEqual(UpperCamelCase__ , getattr(UpperCamelCase__ , UpperCamelCase__ ) ) def a__ ( self ) -> Union[str, Any]: CustomFeatureExtractor.register_for_auto_class() _A : List[str] = CustomFeatureExtractor.from_pretrained(UpperCamelCase__ ) feature_extractor.push_to_hub("""test-dynamic-feature-extractor""" , use_auth_token=self._token ) # This has added the proper auto_map field to the config self.assertDictEqual( feature_extractor.auto_map , {"""AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor"""} , ) _A : Optional[Any] = AutoFeatureExtractor.from_pretrained( F'''{USER}/test-dynamic-feature-extractor''' , trust_remote_code=UpperCamelCase__ ) # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module self.assertEqual(new_feature_extractor.__class__.__name__ , """CustomFeatureExtractor""" )
26
'''simple docstring''' import inspect import unittest from transformers import ConvNextConfig 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_backbone_common import BackboneTesterMixin 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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Optional[int] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Any=1_3 , UpperCamelCase__ : Optional[int]=3_2 , UpperCamelCase__ : Any=3 , UpperCamelCase__ : Tuple=4 , UpperCamelCase__ : str=[1_0, 2_0, 3_0, 4_0] , UpperCamelCase__ : str=[2, 2, 3, 2] , UpperCamelCase__ : Dict=True , UpperCamelCase__ : List[str]=True , UpperCamelCase__ : str=3_7 , UpperCamelCase__ : Union[str, Any]="gelu" , UpperCamelCase__ : Dict=1_0 , UpperCamelCase__ : Union[str, Any]=0.0_2 , UpperCamelCase__ : int=["stage2", "stage3", "stage4"] , UpperCamelCase__ : List[str]=[2, 3, 4] , UpperCamelCase__ : Any=None , ): """simple docstring""" UpperCamelCase = parent UpperCamelCase = batch_size UpperCamelCase = image_size UpperCamelCase = num_channels UpperCamelCase = num_stages UpperCamelCase = hidden_sizes UpperCamelCase = depths UpperCamelCase = is_training UpperCamelCase = use_labels UpperCamelCase = intermediate_size UpperCamelCase = hidden_act UpperCamelCase = num_labels UpperCamelCase = initializer_range UpperCamelCase = out_features UpperCamelCase = out_indices UpperCamelCase = scope def A ( self : Union[str, Any] ): """simple docstring""" UpperCamelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCamelCase = None if self.use_labels: UpperCamelCase = ids_tensor([self.batch_size] , self.num_labels ) UpperCamelCase = self.get_config() return config, pixel_values, labels def A ( self : List[str] ): """simple docstring""" return ConvNextConfig( num_channels=self.num_channels , hidden_sizes=self.hidden_sizes , depths=self.depths , num_stages=self.num_stages , hidden_act=self.hidden_act , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , out_features=self.out_features , out_indices=self.out_indices , num_labels=self.num_labels , ) def A ( self : Union[str, Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : str ): """simple docstring""" UpperCamelCase = ConvNextModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , ) def A ( self : List[str] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : int ): """simple docstring""" UpperCamelCase = ConvNextForImageClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A ( self : Tuple , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : str ): """simple docstring""" UpperCamelCase = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # verify hidden states self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[1], 4, 4] ) # verify channels self.parent.assertEqual(len(model.channels ) , len(config.out_features ) ) self.parent.assertListEqual(model.channels , config.hidden_sizes[1:] ) # verify backbone works with out_features=None UpperCamelCase = None UpperCamelCase = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , 1 ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[-1], 1, 1] ) # verify channels self.parent.assertEqual(len(model.channels ) , 1 ) self.parent.assertListEqual(model.channels , [config.hidden_sizes[-1]] ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.prepare_config_and_inputs() UpperCamelCase , UpperCamelCase , UpperCamelCase = config_and_inputs UpperCamelCase = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE ( _a , _a , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( ConvNextModel, ConvNextForImageClassification, ConvNextBackbone, ) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE = ( {"""feature-extraction""": ConvNextModel, """image-classification""": ConvNextForImageClassification} if is_torch_available() else {} ) _SCREAMING_SNAKE_CASE = True _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False def A ( self : Tuple ): """simple docstring""" UpperCamelCase = ConvNextModelTester(self ) UpperCamelCase = ConfigTester(self , config_class=UpperCamelCase__ , has_text_modality=UpperCamelCase__ , hidden_size=3_7 ) def A ( self : List[str] ): """simple docstring""" self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def A ( self : Optional[int] ): """simple docstring""" return @unittest.skip(reason='ConvNext does not use inputs_embeds' ) def A ( self : List[str] ): """simple docstring""" pass @unittest.skip(reason='ConvNext does not support input and output embeddings' ) def A ( self : List[Any] ): """simple docstring""" pass @unittest.skip(reason='ConvNext does not use feedforward chunking' ) def A ( self : Optional[int] ): """simple docstring""" pass def A ( self : Any ): """simple docstring""" UpperCamelCase , UpperCamelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase = model_class(UpperCamelCase__ ) 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] , UpperCamelCase__ ) def A ( self : Union[str, Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : Tuple ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*UpperCamelCase__ ) def A ( self : Optional[Any] ): """simple docstring""" def check_hidden_states_output(UpperCamelCase__ : Dict , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple ): UpperCamelCase = model_class(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() with torch.no_grad(): UpperCamelCase = model(**self._prepare_for_class(UpperCamelCase__ , UpperCamelCase__ ) ) UpperCamelCase = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states UpperCamelCase = self.model_tester.num_stages self.assertEqual(len(UpperCamelCase__ ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) UpperCamelCase , UpperCamelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase = True check_hidden_states_output(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCamelCase = True check_hidden_states_output(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Dict ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ ) @slow def A ( self : Dict ): """simple docstring""" for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase = ConvNextModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) def __lowerCamelCase ( ) -> Any: """simple docstring""" UpperCamelCase = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" @cached_property def A ( self : Optional[Any] ): """simple docstring""" return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' ).to(UpperCamelCase__ ) UpperCamelCase = self.default_image_processor UpperCamelCase = prepare_img() UpperCamelCase = image_processor(images=UpperCamelCase__ , return_tensors='pt' ).to(UpperCamelCase__ ) # forward pass with torch.no_grad(): UpperCamelCase = model(**UpperCamelCase__ ) # verify the logits UpperCamelCase = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1] ).to(UpperCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , UpperCamelCase__ , atol=1E-4 ) ) @require_torch class SCREAMING_SNAKE_CASE ( unittest.TestCase , _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = (ConvNextBackbone,) if is_torch_available() else () _SCREAMING_SNAKE_CASE = ConvNextConfig _SCREAMING_SNAKE_CASE = False def A ( self : Tuple ): """simple docstring""" UpperCamelCase = ConvNextModelTester(self )
28
0
from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments def _a ( ) -> str: """simple docstring""" lowerCamelCase__ : Any = HfArgumentParser(A__ ) lowerCamelCase__ : Optional[int] = parser.parse_args_into_dataclasses()[0] lowerCamelCase__ : str = TensorFlowBenchmark(args=A__ ) try: lowerCamelCase__ : Dict = parser.parse_args_into_dataclasses()[0] except ValueError as e: lowerCamelCase__ : str = '''Arg --no_{0} is no longer used, please use --no-{0} instead.''' lowerCamelCase__ : List[Any] = ''' '''.join(str(A__ ).split(''' ''' )[:-1] ) lowerCamelCase__ : Union[str, Any] = '''''' lowerCamelCase__ : Optional[Any] = eval(str(A__ ).split(''' ''' )[-1] ) lowerCamelCase__ : int = [] for arg in depreciated_args: # arg[2:] removes '--' if arg[2:] in TensorFlowBenchmark.deprecated_args: # arg[5:] removes '--no_' full_error_msg += arg_error_msg.format(arg[5:] ) else: wrong_args.append(A__ ) if len(A__ ) > 0: lowerCamelCase__ : int = full_error_msg + begin_error_msg + str(A__ ) raise ValueError(A__ ) benchmark.run() if __name__ == "__main__": main()
142
'''simple docstring''' import argparse from collections import OrderedDict from pathlib import Path import torch from huggingface_hub import hf_hub_download from PIL import Image from torchvision.transforms import functional as F from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : int = logging.get_logger(__name__) # here we list all keys to be renamed (original name on the left, our name on the right) _lowerCamelCase : int = [] for i in range(6): # 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 encoder + 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.encoder.norm.weight", "encoder.layernorm.weight"), ("transformer.encoder.norm.bias", "encoder.layernorm.bias"), ("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"), ] ) def __lowerCamelCase ( A__ , A__ , A__ ) -> Dict: """simple docstring""" UpperCamelCase = state_dict.pop(A__ ) UpperCamelCase = val def __lowerCamelCase ( A__ ) -> int: """simple docstring""" UpperCamelCase = OrderedDict() for key, value in state_dict.items(): if "backbone.0.body" in key: UpperCamelCase = key.replace('backbone.0.body' , 'backbone.conv_encoder.model' ) UpperCamelCase = value else: UpperCamelCase = value return new_state_dict def __lowerCamelCase ( A__ ) -> Dict: """simple docstring""" UpperCamelCase = '' # 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[:256, :] UpperCamelCase = in_proj_bias[:256] UpperCamelCase = in_proj_weight[256:512, :] UpperCamelCase = in_proj_bias[256:512] UpperCamelCase = in_proj_weight[-256:, :] UpperCamelCase = in_proj_bias[-256:] # 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[:256, :] UpperCamelCase = in_proj_bias[:256] UpperCamelCase = in_proj_weight[256:512, :] UpperCamelCase = in_proj_bias[256:512] UpperCamelCase = in_proj_weight[-256:, :] UpperCamelCase = in_proj_bias[-256:] # 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[:256, :] UpperCamelCase = in_proj_bias_cross_attn[:256] UpperCamelCase = in_proj_weight_cross_attn[256:512, :] UpperCamelCase = in_proj_bias_cross_attn[256:512] UpperCamelCase = in_proj_weight_cross_attn[-256:, :] UpperCamelCase = in_proj_bias_cross_attn[-256:] def __lowerCamelCase ( A__ , A__ ) -> Optional[int]: """simple docstring""" UpperCamelCase , UpperCamelCase = image.size UpperCamelCase = max(A__ , A__ ) UpperCamelCase = 800 if 'detection' in checkpoint_url else 1_000 UpperCamelCase = target_max_size / current_max_size UpperCamelCase = image.resize((int(round(scale * width ) ), int(round(scale * height ) )) ) return resized_image def __lowerCamelCase ( A__ ) -> List[Any]: """simple docstring""" UpperCamelCase = F.to_tensor(A__ ) UpperCamelCase = F.normalize(A__ , mean=[0.485, 0.456, 0.406] , std=[0.229, 0.224, 0.225] ) return image @torch.no_grad() def __lowerCamelCase ( A__ , A__ , A__ ) -> Optional[Any]: """simple docstring""" logger.info('Converting model...' ) # load original state dict UpperCamelCase = torch.hub.load_state_dict_from_url(A__ , map_location='cpu' ) # rename keys for src, dest in rename_keys: rename_key(A__ , A__ , A__ ) UpperCamelCase = rename_backbone_keys(A__ ) # query, key and value matrices need special treatment read_in_q_k_v(A__ ) # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them UpperCamelCase = 'model.' for key in state_dict.copy().keys(): if not key.startswith('class_labels_classifier' ) and not key.startswith('bbox_predictor' ): UpperCamelCase = state_dict.pop(A__ ) UpperCamelCase = val # create HuggingFace model and load state dict UpperCamelCase = TableTransformerConfig( backbone='resnet18' , mask_loss_coefficient=1 , dice_loss_coefficient=1 , ce_loss_coefficient=1 , bbox_loss_coefficient=5 , giou_loss_coefficient=2 , eos_coefficient=0.4 , class_cost=1 , bbox_cost=5 , giou_cost=2 , ) if "detection" in checkpoint_url: UpperCamelCase = 15 UpperCamelCase = 2 UpperCamelCase = {0: 'table', 1: 'table rotated'} UpperCamelCase = idalabel UpperCamelCase = {v: k for k, v in idalabel.items()} else: UpperCamelCase = 125 UpperCamelCase = 6 UpperCamelCase = { 0: 'table', 1: 'table column', 2: 'table row', 3: 'table column header', 4: 'table projected row header', 5: 'table spanning cell', } UpperCamelCase = idalabel UpperCamelCase = {v: k for k, v in idalabel.items()} UpperCamelCase = DetrImageProcessor( format='coco_detection' , max_size=800 if 'detection' in checkpoint_url else 1_000 ) UpperCamelCase = TableTransformerForObjectDetection(A__ ) model.load_state_dict(A__ ) model.eval() # verify our conversion UpperCamelCase = 'example_pdf.png' if 'detection' in checkpoint_url else 'example_table.png' UpperCamelCase = hf_hub_download(repo_id='nielsr/example-pdf' , repo_type='dataset' , filename=A__ ) UpperCamelCase = Image.open(A__ ).convert('RGB' ) UpperCamelCase = normalize(resize(A__ , A__ ) ).unsqueeze(0 ) UpperCamelCase = model(A__ ) if "detection" in checkpoint_url: UpperCamelCase = (1, 15, 3) UpperCamelCase = torch.tensor( [[-6.7_897, -16.9_985, 6.7_937], [-8.0_186, -22.2_192, 6.9_677], [-7.3_117, -21.0_708, 7.4_055]] ) UpperCamelCase = torch.tensor([[0.4_867, 0.1_767, 0.6_732], [0.6_718, 0.4_479, 0.3_830], [0.4_716, 0.1_760, 0.6_364]] ) else: UpperCamelCase = (1, 125, 7) UpperCamelCase = torch.tensor( [[-18.1_430, -8.3_214, 4.8_274], [-18.4_685, -7.1_361, -4.2_667], [-26.3_693, -9.3_429, -4.9_962]] ) UpperCamelCase = torch.tensor([[0.4_983, 0.5_595, 0.9_440], [0.4_916, 0.6_315, 0.5_954], [0.6_108, 0.8_637, 0.1_135]] ) assert outputs.logits.shape == expected_shape assert torch.allclose(outputs.logits[0, :3, :3] , A__ , atol=1e-4 ) assert torch.allclose(outputs.pred_boxes[0, :3, :3] , A__ , 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(A__ ).mkdir(exist_ok=A__ ) model.save_pretrained(A__ ) image_processor.save_pretrained(A__ ) if push_to_hub: # Push model to HF hub logger.info('Pushing model to the hub...' ) UpperCamelCase = ( 'microsoft/table-transformer-detection' if 'detection' in checkpoint_url else 'microsoft/table-transformer-structure-recognition' ) model.push_to_hub(A__ ) image_processor.push_to_hub(A__ ) if __name__ == "__main__": _lowerCamelCase : List[str] = argparse.ArgumentParser() parser.add_argument( "--checkpoint_url", default="https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth", type=str, choices=[ "https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth", "https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth", ], help="URL of the Table Transformer checkpoint 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 or not to push the converted model to the 🤗 hub." ) _lowerCamelCase : int = parser.parse_args() convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
28
0
'''simple docstring''' from __future__ import annotations snake_case_ : str = [True] * 1000001 snake_case_ : str = 2 while i * i <= 1000000: if seive[i]: for j in range(i * i, 1000001, i): snake_case_ : Optional[int] = False i += 1 def A__ ( UpperCAmelCase_ ): return seive[n] def A__ ( UpperCAmelCase_ ): return any(digit in '02468' for digit in str(A__ ) ) def A__ ( UpperCAmelCase_ = 1_0_0_0_0_0_0 ): _UpperCamelCase : Optional[Any] = [2] # result already includes the number 2. for num in range(3 , limit + 1 , 2 ): if is_prime(A__ ) and not contains_an_even_digit(A__ ): _UpperCamelCase : int = str(A__ ) _UpperCamelCase : int = [int(str_num[j:] + str_num[:j] ) for j in range(len(A__ ) )] if all(is_prime(A__ ) for i in list_nums ): result.append(A__ ) return result def A__ ( ): return len(find_circular_primes() ) if __name__ == "__main__": print(F"""{len(find_circular_primes()) = }""")
83
'''simple docstring''' from io import BytesIO from typing import List, Union import requests from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_decord_available(): import numpy as np from decord import VideoReader if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING _lowerCamelCase : Any = logging.get_logger(__name__) @add_end_docstrings(_a ) class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" def __init__( self : Any , *UpperCamelCase__ : Dict , **UpperCamelCase__ : Union[str, Any] ): """simple docstring""" super().__init__(*UpperCamelCase__ , **UpperCamelCase__ ) requires_backends(self , 'decord' ) self.check_model_type(UpperCamelCase__ ) def A ( self : Optional[int] , UpperCamelCase__ : Optional[int]=None , UpperCamelCase__ : Optional[Any]=None , UpperCamelCase__ : Optional[Any]=None ): """simple docstring""" UpperCamelCase = {} if frame_sampling_rate is not None: UpperCamelCase = frame_sampling_rate if num_frames is not None: UpperCamelCase = num_frames UpperCamelCase = {} if top_k is not None: UpperCamelCase = top_k return preprocess_params, {}, postprocess_params def __call__( self : List[str] , UpperCamelCase__ : Union[str, List[str]] , **UpperCamelCase__ : Dict ): """simple docstring""" return super().__call__(UpperCamelCase__ , **UpperCamelCase__ ) def A ( self : Tuple , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple=None , UpperCamelCase__ : Tuple=1 ): """simple docstring""" if num_frames is None: UpperCamelCase = self.model.config.num_frames if video.startswith('http://' ) or video.startswith('https://' ): UpperCamelCase = BytesIO(requests.get(UpperCamelCase__ ).content ) UpperCamelCase = VideoReader(UpperCamelCase__ ) videoreader.seek(0 ) UpperCamelCase = 0 UpperCamelCase = num_frames * frame_sampling_rate - 1 UpperCamelCase = np.linspace(UpperCamelCase__ , UpperCamelCase__ , num=UpperCamelCase__ , dtype=np.intaa ) UpperCamelCase = videoreader.get_batch(UpperCamelCase__ ).asnumpy() UpperCamelCase = list(UpperCamelCase__ ) UpperCamelCase = self.image_processor(UpperCamelCase__ , return_tensors=self.framework ) return model_inputs def A ( self : Union[str, Any] , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = self.model(**UpperCamelCase__ ) return model_outputs def A ( self : int , UpperCamelCase__ : str , UpperCamelCase__ : List[Any]=5 ): """simple docstring""" if top_k > self.model.config.num_labels: UpperCamelCase = self.model.config.num_labels if self.framework == "pt": UpperCamelCase = model_outputs.logits.softmax(-1 )[0] UpperCamelCase , UpperCamelCase = probs.topk(UpperCamelCase__ ) else: raise ValueError(f"""Unsupported framework: {self.framework}""" ) UpperCamelCase = scores.tolist() UpperCamelCase = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(UpperCamelCase__ , UpperCamelCase__ )]
28
0
import unittest from .lib import ( Matrix, Vector, axpy, square_zero_matrix, unit_basis_vector, zero_vector, ) class A_ ( unittest.TestCase ): def UpperCAmelCase ( self : Tuple ) -> List[Any]: __lowerCAmelCase: Optional[int] = Vector([1, 2, 3] ) self.assertEqual(x.component(0 ) , 1 ) self.assertEqual(x.component(2 ) , 3 ) __lowerCAmelCase: List[str] = Vector() def UpperCAmelCase ( self : Any ) -> List[str]: __lowerCAmelCase: Optional[int] = Vector([0, 0, 0, 0, 0, 1] ) self.assertEqual(str(UpperCamelCase__ ) , '(0,0,0,0,0,1)' ) def UpperCAmelCase ( self : Dict ) -> List[str]: __lowerCAmelCase: Any = Vector([1, 2, 3, 4] ) self.assertEqual(len(UpperCamelCase__ ) , 4 ) def UpperCAmelCase ( self : Dict ) -> List[str]: __lowerCAmelCase: Optional[Any] = Vector([1, 2] ) __lowerCAmelCase: Union[str, Any] = Vector([1, 2, 3, 4, 5] ) __lowerCAmelCase: str = Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ) __lowerCAmelCase: str = Vector([1, -1, 1, -1, 2, -3, 4, -5] ) self.assertAlmostEqual(x.euclidean_length() , 2.236 , 3 ) self.assertAlmostEqual(y.euclidean_length() , 7.416 , 3 ) self.assertEqual(z.euclidean_length() , 0 ) self.assertAlmostEqual(w.euclidean_length() , 7.616 , 3 ) def UpperCAmelCase ( self : List[Any] ) -> Dict: __lowerCAmelCase: Dict = Vector([1, 2, 3] ) __lowerCAmelCase: str = Vector([1, 1, 1] ) self.assertEqual((x + y).component(0 ) , 2 ) self.assertEqual((x + y).component(1 ) , 3 ) self.assertEqual((x + y).component(2 ) , 4 ) def UpperCAmelCase ( self : Any ) -> Union[str, Any]: __lowerCAmelCase: str = Vector([1, 2, 3] ) __lowerCAmelCase: List[str] = Vector([1, 1, 1] ) self.assertEqual((x - y).component(0 ) , 0 ) self.assertEqual((x - y).component(1 ) , 1 ) self.assertEqual((x - y).component(2 ) , 2 ) def UpperCAmelCase ( self : Tuple ) -> Dict: __lowerCAmelCase: str = Vector([1, 2, 3] ) __lowerCAmelCase: List[Any] = Vector([2, -1, 4] ) # for test of dot product __lowerCAmelCase: Optional[int] = Vector([1, -2, -1] ) self.assertEqual(str(x * 3.0 ) , '(3.0,6.0,9.0)' ) self.assertEqual((a * b) , 0 ) def UpperCAmelCase ( self : Dict ) -> Dict: self.assertEqual(str(zero_vector(1_0 ) ).count('0' ) , 1_0 ) def UpperCAmelCase ( self : Union[str, Any] ) -> Tuple: self.assertEqual(str(unit_basis_vector(3 , 1 ) ) , '(0,1,0)' ) def UpperCAmelCase ( self : str ) -> Optional[Any]: __lowerCAmelCase: Any = Vector([1, 2, 3] ) __lowerCAmelCase: Any = Vector([1, 0, 1] ) self.assertEqual(str(axpy(2 , UpperCamelCase__ , UpperCamelCase__ ) ) , '(3,4,7)' ) def UpperCAmelCase ( self : Optional[Any] ) -> Optional[Any]: __lowerCAmelCase: Any = Vector([1, 0, 0, 0, 0, 0] ) __lowerCAmelCase: List[str] = x.copy() self.assertEqual(str(UpperCamelCase__ ) , str(UpperCamelCase__ ) ) def UpperCAmelCase ( self : List[str] ) -> Optional[Any]: __lowerCAmelCase: Optional[Any] = Vector([1, 0, 0] ) x.change_component(0 , 0 ) x.change_component(1 , 1 ) self.assertEqual(str(UpperCamelCase__ ) , '(0,1,0)' ) def UpperCAmelCase ( self : Optional[Any] ) -> Union[str, Any]: __lowerCAmelCase: Optional[int] = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) self.assertEqual('|1,2,3|\n|2,4,5|\n|6,7,8|\n' , str(UpperCamelCase__ ) ) def UpperCAmelCase ( self : Any ) -> int: __lowerCAmelCase: List[Any] = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) __lowerCAmelCase: Dict = [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]] for x in range(a.height() ): for y in range(a.width() ): self.assertEqual(minors[x][y] , a.minor(UpperCamelCase__ , UpperCamelCase__ ) ) def UpperCAmelCase ( self : Union[str, Any] ) -> Any: __lowerCAmelCase: Dict = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) __lowerCAmelCase: int = [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]] for x in range(a.height() ): for y in range(a.width() ): self.assertEqual(cofactors[x][y] , a.cofactor(UpperCamelCase__ , UpperCamelCase__ ) ) def UpperCAmelCase ( self : List[Any] ) -> Dict: __lowerCAmelCase: Union[str, Any] = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) self.assertEqual(-5 , a.determinant() ) def UpperCAmelCase ( self : List[str] ) -> int: __lowerCAmelCase: List[str] = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]] , 3 , 3 ) __lowerCAmelCase: Optional[int] = Vector([1, 2, 3] ) self.assertEqual('(14,32,50)' , str(a * x ) ) self.assertEqual('|2,4,6|\n|8,10,12|\n|14,16,18|\n' , str(a * 2 ) ) def UpperCAmelCase ( self : Optional[Any] ) -> List[Any]: __lowerCAmelCase: Any = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) a.change_component(0 , 2 , 5 ) self.assertEqual('|1,2,5|\n|2,4,5|\n|6,7,8|\n' , str(UpperCamelCase__ ) ) def UpperCAmelCase ( self : List[str] ) -> List[str]: __lowerCAmelCase: str = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) self.assertEqual(7 , a.component(2 , 1 ) , 0.01 ) def UpperCAmelCase ( self : List[str] ) -> Dict: __lowerCAmelCase: Optional[Any] = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) __lowerCAmelCase: Any = Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]] , 3 , 3 ) self.assertEqual('|2,4,10|\n|4,8,10|\n|12,14,18|\n' , str(a + b ) ) def UpperCAmelCase ( self : List[str] ) -> List[Any]: __lowerCAmelCase: Union[str, Any] = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]] , 3 , 3 ) __lowerCAmelCase: List[Any] = Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]] , 3 , 3 ) self.assertEqual('|0,0,-4|\n|0,0,0|\n|0,0,-2|\n' , str(a - b ) ) def UpperCAmelCase ( self : List[str] ) -> int: self.assertEqual( '|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n' , str(square_zero_matrix(5 ) ) , ) if __name__ == "__main__": unittest.main()
322
'''simple docstring''' import os from itertools import chain from random import randrange, shuffle import pytest from .sola import PokerHand _lowerCamelCase : Optional[int] = ( "4S 3H 2C 7S 5H", "9D 8H 2C 6S 7H", "2D 6D 9D TH 7D", "TC 8C 2S JH 6C", "JH 8S TH AH QH", "TS KS 5S 9S AC", "KD 6S 9D TH AD", "KS 8D 4D 9S 4S", # pair "8C 4S KH JS 4D", # pair "QH 8H KD JH 8S", # pair "KC 4H KS 2H 8D", # pair "KD 4S KC 3H 8S", # pair "AH 8S AS KC JH", # pair "3H 4C 4H 3S 2H", # 2 pairs "5S 5D 2C KH KH", # 2 pairs "3C KH 5D 5S KH", # 2 pairs "AS 3C KH AD KH", # 2 pairs "7C 7S 3S 7H 5S", # 3 of a kind "7C 7S KH 2H 7H", # 3 of a kind "AC KH QH AH AS", # 3 of a kind "2H 4D 3C AS 5S", # straight (low ace) "3C 5C 4C 2C 6H", # straight "6S 8S 7S 5H 9H", # straight "JS QS 9H TS KH", # straight "QC KH TS JS AH", # straight (high ace) "8C 9C 5C 3C TC", # flush "3S 8S 9S 5S KS", # flush "4C 5C 9C 8C KC", # flush "JH 8H AH KH QH", # flush "3D 2H 3H 2C 2D", # full house "2H 2C 3S 3H 3D", # full house "KH KC 3S 3H 3D", # full house "JC 6H JS JD JH", # 4 of a kind "JC 7H JS JD JH", # 4 of a kind "JC KH JS JD JH", # 4 of a kind "2S AS 4S 5S 3S", # straight flush (low ace) "2D 6D 3D 4D 5D", # straight flush "5C 6C 3C 7C 4C", # straight flush "JH 9H TH KH QH", # straight flush "JH AH TH KH QH", # royal flush (high ace straight flush) ) _lowerCamelCase : Union[str, Any] = ( ("2H 3H 4H 5H 6H", "KS AS TS QS JS", "Loss"), ("2H 3H 4H 5H 6H", "AS AD AC AH JD", "Win"), ("AS AH 2H AD AC", "JS JD JC JH 3D", "Win"), ("2S AH 2H AS AC", "JS JD JC JH AD", "Loss"), ("2S AH 2H AS AC", "2H 3H 5H 6H 7H", "Win"), ("AS 3S 4S 8S 2S", "2H 3H 5H 6H 7H", "Win"), ("2H 3H 5H 6H 7H", "2S 3H 4H 5S 6C", "Win"), ("2S 3H 4H 5S 6C", "3D 4C 5H 6H 2S", "Tie"), ("2S 3H 4H 5S 6C", "AH AC 5H 6H AS", "Win"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H AS", "Loss"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H 7S", "Win"), ("6S AD 7H 4S AS", "AH AC 5H 6H 7S", "Loss"), ("2S AH 4H 5S KC", "AH AC 5H 6H 7S", "Loss"), ("2S 3H 6H 7S 9C", "7H 3C TH 6H 9S", "Loss"), ("4S 5H 6H TS AC", "3S 5H 6H TS AC", "Win"), ("2S AH 4H 5S 6C", "AD 4C 5H 6H 2C", "Tie"), ("AS AH 3H AD AC", "AS AH 2H AD AC", "Win"), ("AH AC 5H 5C QS", "AH AC 5H 5C KS", "Loss"), ("AH AC 5H 5C QS", "KH KC 5H 5C QS", "Win"), ("7C 7S KH 2H 7H", "3C 3S AH 2H 3H", "Win"), ("3C 3S AH 2H 3H", "7C 7S KH 2H 7H", "Loss"), ("6H 5H 4H 3H 2H", "5H 4H 3H 2H AH", "Win"), ("5H 4H 3H 2H AH", "5H 4H 3H 2H AH", "Tie"), ("5H 4H 3H 2H AH", "6H 5H 4H 3H 2H", "Loss"), ("AH AD KS KC AC", "AH KD KH AC KC", "Win"), ("2H 4D 3C AS 5S", "2H 4D 3C 6S 5S", "Loss"), ("2H 3S 3C 3H 2S", "3S 3C 2S 2H 2D", "Win"), ("4D 6D 5D 2D JH", "3S 8S 3H TC KH", "Loss"), ("4S 6C 8S 3S 7S", "AD KS 2D 7D 7C", "Loss"), ("6S 4C 7H 8C 3H", "5H JC AH 9D 9C", "Loss"), ("9D 9H JH TC QH", "3C 2S JS 5C 7H", "Win"), ("2H TC 8S AD 9S", "4H TS 7H 2C 5C", "Win"), ("9D 3S 2C 7S 7C", "JC TD 3C TC 9H", "Loss"), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", True), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", False), ("AS 3S 4S 8S 2S", True), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", False), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", True), ) _lowerCamelCase : Optional[Any] = ( ("2H 4D 3C AS 5S", True, [5, 4, 3, 2, 14]), ("2H 5D 3C AS 5S", False, [14, 5, 5, 3, 2]), ("JH QD KC AS TS", False, [14, 13, 12, 11, 10]), ("9D 3S 2C 7S 7C", False, [9, 7, 7, 3, 2]), ) _lowerCamelCase : List[Any] = ( ("JH AH TH KH QH", 0), ("JH 9H TH KH QH", 0), ("JC KH JS JD JH", 7), ("KH KC 3S 3H 3D", 6), ("8C 9C 5C 3C TC", 0), ("JS QS 9H TS KH", 0), ("7C 7S KH 2H 7H", 3), ("3C KH 5D 5S KH", 2), ("QH 8H KD JH 8S", 1), ("2D 6D 9D TH 7D", 0), ) _lowerCamelCase : List[str] = ( ("JH AH TH KH QH", 23), ("JH 9H TH KH QH", 22), ("JC KH JS JD JH", 21), ("KH KC 3S 3H 3D", 20), ("8C 9C 5C 3C TC", 19), ("JS QS 9H TS KH", 18), ("7C 7S KH 2H 7H", 17), ("3C KH 5D 5S KH", 16), ("QH 8H KD JH 8S", 15), ("2D 6D 9D TH 7D", 14), ) def __lowerCamelCase ( ) -> Optional[Any]: """simple docstring""" UpperCamelCase , UpperCamelCase = randrange(len(A__ ) ), randrange(len(A__ ) ) UpperCamelCase = ['Loss', 'Tie', 'Win'][(play >= oppo) + (play > oppo)] UpperCamelCase , UpperCamelCase = SORTED_HANDS[play], SORTED_HANDS[oppo] return hand, other, expected def __lowerCamelCase ( A__ = 100 ) -> Optional[Any]: """simple docstring""" return (generate_random_hand() for _ in range(A__ )) @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_flush() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_straight() == expected @pytest.mark.parametrize('hand, expected, card_values' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> str: """simple docstring""" UpperCamelCase = PokerHand(A__ ) assert player._is_five_high_straight() == expected assert player._card_values == card_values @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Dict: """simple docstring""" assert PokerHand(A__ )._is_same_kind() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> str: """simple docstring""" assert PokerHand(A__ )._hand_type == expected @pytest.mark.parametrize('hand, other, expected' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> Tuple: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected @pytest.mark.parametrize('hand, other, expected' , generate_random_hands() ) def __lowerCamelCase ( A__ , A__ , A__ ) -> List[str]: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected def __lowerCamelCase ( ) -> str: """simple docstring""" UpperCamelCase = [PokerHand(A__ ) for hand in SORTED_HANDS] UpperCamelCase = poker_hands.copy() shuffle(A__ ) UpperCamelCase = chain(sorted(A__ ) ) for index, hand in enumerate(A__ ): assert hand == poker_hands[index] def __lowerCamelCase ( ) -> Optional[int]: """simple docstring""" # Test that five high straights are compared correctly. UpperCamelCase = [PokerHand('2D AC 3H 4H 5S' ), PokerHand('2S 3H 4H 5S 6C' )] pokerhands.sort(reverse=A__ ) assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C" def __lowerCamelCase ( ) -> str: """simple docstring""" # Multiple calls to five_high_straight function should still return True # and shouldn't mutate the list in every call other than the first. UpperCamelCase = PokerHand('2C 4S AS 3D 5C' ) UpperCamelCase = True UpperCamelCase = [5, 4, 3, 2, 14] for _ in range(10 ): assert pokerhand._is_five_high_straight() == expected assert pokerhand._card_values == expected_card_values def __lowerCamelCase ( ) -> List[str]: """simple docstring""" # Problem number 54 from Project Euler # Testing from poker_hands.txt file UpperCamelCase = 0 UpperCamelCase = os.path.abspath(os.path.dirname(A__ ) ) UpperCamelCase = os.path.join(A__ , 'poker_hands.txt' ) with open(A__ ) as file_hand: for line in file_hand: UpperCamelCase = line[:14].strip() UpperCamelCase = line[15:].strip() UpperCamelCase , UpperCamelCase = PokerHand(A__ ), PokerHand(A__ ) UpperCamelCase = player.compare_with(A__ ) if output == "Win": answer += 1 assert answer == 376
28
0
"""simple docstring""" from typing import List import numpy as np def snake_case_ ( A_ : List[Any] ): '''simple docstring''' _lowerCamelCase : Dict = {key: len(A__ ) for key, value in gen_kwargs.items() if isinstance(A__, A__ )} if len(set(lists_lengths.values() ) ) > 1: raise RuntimeError( ( '''Sharding is ambiguous for this dataset: ''' + '''we found several data sources lists of different lengths, and we don\'t know over which list we should parallelize:\n''' + '''\n'''.join(F'''\t- key {key} has length {length}''' for key, length in lists_lengths.items() ) + '''\nTo fix this, check the \'gen_kwargs\' and make sure to use lists only for data sources, ''' + '''and use tuples otherwise. In the end there should only be one single list, or several lists with the same length.''' ) ) _lowerCamelCase : Any = max(lists_lengths.values(), default=0 ) return max(1, A__ ) def snake_case_ ( A_ : Dict, A_ : Union[str, Any] ): '''simple docstring''' _lowerCamelCase : Optional[Any] = [] for group_idx in range(A__ ): _lowerCamelCase : Tuple = num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs)) if num_shards_to_add == 0: break _lowerCamelCase : Optional[int] = shards_indices_per_group[-1].stop if shards_indices_per_group else 0 _lowerCamelCase : Any = range(A__, start + num_shards_to_add ) shards_indices_per_group.append(A__ ) return shards_indices_per_group def snake_case_ ( A_ : List[Any], A_ : List[Any] ): '''simple docstring''' _lowerCamelCase : List[Any] = _number_of_shards_in_gen_kwargs(A__ ) if num_shards == 1: return [dict(A__ )] else: _lowerCamelCase : Any = _distribute_shards(num_shards=A__, max_num_jobs=A__ ) return [ { key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]] if isinstance(A__, A__ ) else value for key, value in gen_kwargs.items() } for group_idx in range(len(A__ ) ) ] def snake_case_ ( A_ : Any ): '''simple docstring''' return { key: [value for gen_kwargs in gen_kwargs_list for value in gen_kwargs[key]] if isinstance(gen_kwargs_list[0][key], A__ ) else gen_kwargs_list[0][key] for key in gen_kwargs_list[0] } def snake_case_ ( A_ : Optional[int], A_ : Any ): '''simple docstring''' _lowerCamelCase : List[Any] = {len(A__ ) for value in gen_kwargs.values() if isinstance(A__, A__ )} _lowerCamelCase : Any = {} for size in list_sizes: _lowerCamelCase : List[Any] = list(range(A__ ) ) rng.shuffle(indices_per_size[size] ) # Now let's copy the gen_kwargs and shuffle the lists based on their sizes _lowerCamelCase : List[str] = dict(A__ ) for key, value in shuffled_kwargs.items(): if isinstance(A__, A__ ): _lowerCamelCase : Any = [value[i] for i in indices_per_size[len(A__ )]] return shuffled_kwargs
72
'''simple docstring''' from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = None class SCREAMING_SNAKE_CASE ( _a , _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 2 @register_to_config def __init__( self : Union[str, Any] , UpperCamelCase__ : float = 0.0_2 , UpperCamelCase__ : float = 1_0_0 , UpperCamelCase__ : float = 1.0_0_7 , UpperCamelCase__ : float = 8_0 , UpperCamelCase__ : float = 0.0_5 , UpperCamelCase__ : float = 5_0 , ): """simple docstring""" UpperCamelCase = sigma_max # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None ): """simple docstring""" return sample def A ( self : Union[str, Any] , UpperCamelCase__ : int , UpperCamelCase__ : Union[str, torch.device] = None ): """simple docstring""" UpperCamelCase = num_inference_steps UpperCamelCase = np.arange(0 , self.num_inference_steps )[::-1].copy() UpperCamelCase = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) UpperCamelCase = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in self.timesteps ] UpperCamelCase = torch.tensor(UpperCamelCase__ , dtype=torch.floataa , device=UpperCamelCase__ ) def A ( self : Dict , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : Optional[torch.Generator] = None ): """simple docstring""" if self.config.s_min <= sigma <= self.config.s_max: UpperCamelCase = min(self.config.s_churn / self.num_inference_steps , 2**0.5 - 1 ) else: UpperCamelCase = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCamelCase = self.config.s_noise * randn_tensor(sample.shape , generator=UpperCamelCase__ ).to(sample.device ) UpperCamelCase = sigma + gamma * sigma UpperCamelCase = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_hat + sigma_hat * model_output UpperCamelCase = (sample_hat - pred_original_sample) / sigma_hat UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : List[Any] , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_prev + sigma_prev * model_output UpperCamelCase = (sample_prev - pred_original_sample) / sigma_prev UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : int , UpperCamelCase__ : str ): """simple docstring""" raise NotImplementedError()
28
0
import argparse import json from pathlib import Path import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel from transformers.utils import logging logging.set_verbosity_info() __snake_case : str = logging.get_logger(__name__) def _UpperCAmelCase ( a__ , a__=False): '''simple docstring''' a_ : Dict = [] for i in range(config.num_hidden_layers): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f'''blocks.{i}.norm1.weight''', f'''vit.encoder.layer.{i}.layernorm_before.weight''')) rename_keys.append((f'''blocks.{i}.norm1.bias''', f'''vit.encoder.layer.{i}.layernorm_before.bias''')) rename_keys.append((f'''blocks.{i}.attn.proj.weight''', f'''vit.encoder.layer.{i}.attention.output.dense.weight''')) rename_keys.append((f'''blocks.{i}.attn.proj.bias''', f'''vit.encoder.layer.{i}.attention.output.dense.bias''')) rename_keys.append((f'''blocks.{i}.norm2.weight''', f'''vit.encoder.layer.{i}.layernorm_after.weight''')) rename_keys.append((f'''blocks.{i}.norm2.bias''', f'''vit.encoder.layer.{i}.layernorm_after.bias''')) rename_keys.append((f'''blocks.{i}.mlp.fc1.weight''', f'''vit.encoder.layer.{i}.intermediate.dense.weight''')) rename_keys.append((f'''blocks.{i}.mlp.fc1.bias''', f'''vit.encoder.layer.{i}.intermediate.dense.bias''')) rename_keys.append((f'''blocks.{i}.mlp.fc2.weight''', f'''vit.encoder.layer.{i}.output.dense.weight''')) rename_keys.append((f'''blocks.{i}.mlp.fc2.bias''', f'''vit.encoder.layer.{i}.output.dense.bias''')) # projection layer + position embeddings rename_keys.extend( [ ("""cls_token""", """vit.embeddings.cls_token"""), ("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""), ("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""), ("""pos_embed""", """vit.embeddings.position_embeddings"""), ]) if base_model: # layernorm + pooler rename_keys.extend( [ ("""norm.weight""", """layernorm.weight"""), ("""norm.bias""", """layernorm.bias"""), ("""pre_logits.fc.weight""", """pooler.dense.weight"""), ("""pre_logits.fc.bias""", """pooler.dense.bias"""), ]) # if just the base model, we should remove "vit" from all keys that start with "vit" a_ : List[Any] = [(pair[0], pair[1][4:]) if pair[1].startswith("""vit""") else pair for pair in rename_keys] else: # layernorm + classification head rename_keys.extend( [ ("""norm.weight""", """vit.layernorm.weight"""), ("""norm.bias""", """vit.layernorm.bias"""), ("""head.weight""", """classifier.weight"""), ("""head.bias""", """classifier.bias"""), ]) return rename_keys def _UpperCAmelCase ( a__ , a__ , a__=False): '''simple docstring''' for i in range(config.num_hidden_layers): if base_model: a_ : Tuple = """""" else: a_ : Any = """vit.""" # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) a_ : Dict = state_dict.pop(f'''blocks.{i}.attn.qkv.weight''') a_ : Optional[int] = state_dict.pop(f'''blocks.{i}.attn.qkv.bias''') # next, add query, keys and values (in that order) to the state dict a_ : Any = in_proj_weight[ : config.hidden_size, : ] a_ : List[Any] = in_proj_bias[: config.hidden_size] a_ : Optional[int] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] a_ : Any = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] a_ : Union[str, Any] = in_proj_weight[ -config.hidden_size :, : ] a_ : Dict = in_proj_bias[-config.hidden_size :] def _UpperCAmelCase ( a__): '''simple docstring''' a_ : Tuple = ["""head.weight""", """head.bias"""] for k in ignore_keys: state_dict.pop(A__ , A__) def _UpperCAmelCase ( a__ , a__ , a__): '''simple docstring''' a_ : List[str] = dct.pop(A__) a_ : Tuple = val def _UpperCAmelCase ( ): '''simple docstring''' a_ : Union[str, Any] = """http://images.cocodataset.org/val2017/000000039769.jpg""" a_ : str = Image.open(requests.get(A__ , stream=A__).raw) return im @torch.no_grad() def _UpperCAmelCase ( a__ , a__): '''simple docstring''' a_ : int = ViTConfig() a_ : int = False # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size if vit_name[-5:] == "in21k": a_ : int = True a_ : List[str] = int(vit_name[-1_2:-1_0]) a_ : List[Any] = int(vit_name[-9:-6]) else: a_ : Dict = 1_0_0_0 a_ : Dict = """huggingface/label-files""" a_ : Optional[int] = """imagenet-1k-id2label.json""" a_ : Optional[int] = json.load(open(hf_hub_download(A__ , A__ , repo_type="""dataset""") , """r""")) a_ : Optional[int] = {int(A__): v for k, v in idalabel.items()} a_ : Optional[int] = idalabel a_ : List[str] = {v: k for k, v in idalabel.items()} a_ : Optional[int] = int(vit_name[-6:-4]) a_ : List[Any] = int(vit_name[-3:]) # size of the architecture if "deit" in vit_name: if vit_name[9:].startswith("""tiny"""): a_ : List[Any] = 1_9_2 a_ : int = 7_6_8 a_ : Optional[Any] = 1_2 a_ : List[Any] = 3 elif vit_name[9:].startswith("""small"""): a_ : str = 3_8_4 a_ : Any = 1_5_3_6 a_ : Optional[int] = 1_2 a_ : Optional[int] = 6 else: pass else: if vit_name[4:].startswith("""small"""): a_ : Any = 7_6_8 a_ : Dict = 2_3_0_4 a_ : Any = 8 a_ : int = 8 elif vit_name[4:].startswith("""base"""): pass elif vit_name[4:].startswith("""large"""): a_ : Union[str, Any] = 1_0_2_4 a_ : Union[str, Any] = 4_0_9_6 a_ : int = 2_4 a_ : Optional[Any] = 1_6 elif vit_name[4:].startswith("""huge"""): a_ : Optional[int] = 1_2_8_0 a_ : str = 5_1_2_0 a_ : Any = 3_2 a_ : Union[str, Any] = 1_6 # load original model from timm a_ : int = timm.create_model(A__ , pretrained=A__) timm_model.eval() # load state_dict of original model, remove and rename some keys a_ : List[Any] = timm_model.state_dict() if base_model: remove_classification_head_(A__) a_ : Any = create_rename_keys(A__ , A__) for src, dest in rename_keys: rename_key(A__ , A__ , A__) read_in_q_k_v(A__ , A__ , A__) # load HuggingFace model if vit_name[-5:] == "in21k": a_ : List[Any] = ViTModel(A__).eval() else: a_ : Any = ViTForImageClassification(A__).eval() model.load_state_dict(A__) # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor if "deit" in vit_name: a_ : Optional[Any] = DeiTImageProcessor(size=config.image_size) else: a_ : List[Any] = ViTImageProcessor(size=config.image_size) a_ : Any = image_processor(images=prepare_img() , return_tensors="""pt""") a_ : int = encoding["""pixel_values"""] a_ : Union[str, Any] = model(A__) if base_model: a_ : List[str] = timm_model.forward_features(A__) assert timm_pooled_output.shape == outputs.pooler_output.shape assert torch.allclose(A__ , outputs.pooler_output , atol=1e-3) else: a_ : List[str] = timm_model(A__) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(A__ , outputs.logits , atol=1e-3) Path(A__).mkdir(exist_ok=A__) print(f'''Saving model {vit_name} to {pytorch_dump_folder_path}''') model.save_pretrained(A__) print(f'''Saving image processor to {pytorch_dump_folder_path}''') image_processor.save_pretrained(A__) if __name__ == "__main__": __snake_case : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--vit_name""", default="""vit_base_patch16_224""", type=str, help="""Name of the ViT timm model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) __snake_case : Tuple = parser.parse_args() convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)
248
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available _lowerCamelCase : Tuple = {"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Dict = [ "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "IBertForMaskedLM", "IBertForMultipleChoice", "IBertForQuestionAnswering", "IBertForSequenceClassification", "IBertForTokenClassification", "IBertModel", "IBertPreTrainedModel", ] if TYPE_CHECKING: from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ibert import ( IBERT_PRETRAINED_MODEL_ARCHIVE_LIST, IBertForMaskedLM, IBertForMultipleChoice, IBertForQuestionAnswering, IBertForSequenceClassification, IBertForTokenClassification, IBertModel, IBertPreTrainedModel, ) else: import sys _lowerCamelCase : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
def SCREAMING_SNAKE_CASE__ ( __a ): return "".join([hex(A__ )[2:].zfill(2 ).upper() for byte in list(A__ )] ) def SCREAMING_SNAKE_CASE__ ( __a ): # Check data validity, following RFC3548 # https://www.ietf.org/rfc/rfc3548.txt if (len(A__ ) % 2) != 0: raise ValueError( 'Base16 encoded data is invalid:\nData does not have an even number of hex digits.' ) # Check the character set - the standard base16 alphabet # is uppercase according to RFC3548 section 6 if not set(A__ ) <= set('0123456789ABCDEF' ): raise ValueError( 'Base16 encoded data is invalid:\nData is not uppercase hex or it contains invalid characters.' ) # For every two hexadecimal digits (= a byte), turn it into an integer. # Then, string the result together into bytes, and return it. return bytes(int(data[i] + data[i + 1] , 16 ) for i in range(0 , len(A__ ) , 2 ) ) if __name__ == "__main__": import doctest doctest.testmod()
327
'''simple docstring''' def __lowerCamelCase ( A__ = 10**9 ) -> int: """simple docstring""" UpperCamelCase = 1 UpperCamelCase = 2 UpperCamelCase = 0 UpperCamelCase = 0 UpperCamelCase = 0 while perimeter <= max_perimeter: perimeters_sum += perimeter prev_value += 2 * value value += prev_value UpperCamelCase = 2 * value + 2 if i % 2 == 0 else 2 * value - 2 i += 1 return perimeters_sum if __name__ == "__main__": print(f'''{solution() = }''')
28
0
import argparse import os import shutil from pathlib import Path import onnx import torch from packaging import version from torch.onnx import export from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline _snake_case = version.parse(version.parse(torch.__version__).base_version) < version.parse("1.11") def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase=False , ): '''simple docstring''' output_path.parent.mkdir(parents=A__ , exist_ok=A__ ) # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11, # so we check the torch version for backwards compatibility if is_torch_less_than_1_11: export( A__ , A__ , f=output_path.as_posix() , input_names=A__ , output_names=A__ , dynamic_axes=A__ , do_constant_folding=A__ , use_external_data_format=A__ , enable_onnx_checker=A__ , opset_version=A__ , ) else: export( A__ , A__ , f=output_path.as_posix() , input_names=A__ , output_names=A__ , dynamic_axes=A__ , do_constant_folding=A__ , opset_version=A__ , ) @torch.no_grad() def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase = False ): '''simple docstring''' _lowerCAmelCase : Optional[Any] = torch.floataa if fpaa else torch.floataa if fpaa and torch.cuda.is_available(): _lowerCAmelCase : str = "cuda" elif fpaa and not torch.cuda.is_available(): raise ValueError("`float16` model export is only supported on GPUs with CUDA" ) else: _lowerCAmelCase : int = "cpu" _lowerCAmelCase : Tuple = StableDiffusionPipeline.from_pretrained(A__ , torch_dtype=A__ ).to(A__ ) _lowerCAmelCase : List[str] = Path(A__ ) # TEXT ENCODER _lowerCAmelCase : List[Any] = pipeline.text_encoder.config.max_position_embeddings _lowerCAmelCase : List[Any] = pipeline.text_encoder.config.hidden_size _lowerCAmelCase : str = pipeline.tokenizer( "A sample prompt" , padding="max_length" , max_length=pipeline.tokenizer.model_max_length , truncation=A__ , return_tensors="pt" , ) onnx_export( pipeline.text_encoder , model_args=(text_input.input_ids.to(device=A__ , dtype=torch.intaa )) , output_path=output_path / "text_encoder" / "model.onnx" , ordered_input_names=["input_ids"] , output_names=["last_hidden_state", "pooler_output"] , dynamic_axes={ "input_ids": {0: "batch", 1: "sequence"}, } , opset=A__ , ) del pipeline.text_encoder # UNET _lowerCAmelCase : List[str] = pipeline.unet.config.in_channels _lowerCAmelCase : List[str] = pipeline.unet.config.sample_size _lowerCAmelCase : List[Any] = output_path / "unet" / "model.onnx" onnx_export( pipeline.unet , model_args=( torch.randn(2 , A__ , A__ , A__ ).to(device=A__ , dtype=A__ ), torch.randn(2 ).to(device=A__ , dtype=A__ ), torch.randn(2 , A__ , A__ ).to(device=A__ , dtype=A__ ), False, ) , output_path=A__ , ordered_input_names=["sample", "timestep", "encoder_hidden_states", "return_dict"] , output_names=["out_sample"] , dynamic_axes={ "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"}, "timestep": {0: "batch"}, "encoder_hidden_states": {0: "batch", 1: "sequence"}, } , opset=A__ , use_external_data_format=A__ , ) _lowerCAmelCase : Dict = str(unet_path.absolute().as_posix() ) _lowerCAmelCase : Optional[Any] = os.path.dirname(A__ ) _lowerCAmelCase : Union[str, Any] = onnx.load(A__ ) # clean up existing tensor files shutil.rmtree(A__ ) os.mkdir(A__ ) # collate external tensor files into one onnx.save_model( A__ , A__ , save_as_external_data=A__ , all_tensors_to_one_file=A__ , location="weights.pb" , convert_attribute=A__ , ) del pipeline.unet # VAE ENCODER _lowerCAmelCase : Dict = pipeline.vae _lowerCAmelCase : Any = vae_encoder.config.in_channels _lowerCAmelCase : List[Any] = vae_encoder.config.sample_size # need to get the raw tensor output (sample) from the encoder _lowerCAmelCase : List[str] = lambda _lowerCamelCase , _lowerCamelCase : vae_encoder.encode(A__ , A__ )[0].sample() onnx_export( A__ , model_args=( torch.randn(1 , A__ , A__ , A__ ).to(device=A__ , dtype=A__ ), False, ) , output_path=output_path / "vae_encoder" / "model.onnx" , ordered_input_names=["sample", "return_dict"] , output_names=["latent_sample"] , dynamic_axes={ "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"}, } , opset=A__ , ) # VAE DECODER _lowerCAmelCase : List[str] = pipeline.vae _lowerCAmelCase : str = vae_decoder.config.latent_channels _lowerCAmelCase : Optional[int] = vae_decoder.config.out_channels # forward only through the decoder part _lowerCAmelCase : Dict = vae_encoder.decode onnx_export( A__ , model_args=( torch.randn(1 , A__ , A__ , A__ ).to(device=A__ , dtype=A__ ), False, ) , output_path=output_path / "vae_decoder" / "model.onnx" , ordered_input_names=["latent_sample", "return_dict"] , output_names=["sample"] , dynamic_axes={ "latent_sample": {0: "batch", 1: "channels", 2: "height", 3: "width"}, } , opset=A__ , ) del pipeline.vae # SAFETY CHECKER if pipeline.safety_checker is not None: _lowerCAmelCase : Optional[int] = pipeline.safety_checker _lowerCAmelCase : Any = safety_checker.config.vision_config.num_channels _lowerCAmelCase : str = safety_checker.config.vision_config.image_size _lowerCAmelCase : List[Any] = safety_checker.forward_onnx onnx_export( pipeline.safety_checker , model_args=( torch.randn( 1 , A__ , A__ , A__ , ).to(device=A__ , dtype=A__ ), torch.randn(1 , A__ , A__ , A__ ).to(device=A__ , dtype=A__ ), ) , output_path=output_path / "safety_checker" / "model.onnx" , ordered_input_names=["clip_input", "images"] , output_names=["out_images", "has_nsfw_concepts"] , dynamic_axes={ "clip_input": {0: "batch", 1: "channels", 2: "height", 3: "width"}, "images": {0: "batch", 1: "height", 2: "width", 3: "channels"}, } , opset=A__ , ) del pipeline.safety_checker _lowerCAmelCase : Union[str, Any] = OnnxRuntimeModel.from_pretrained(output_path / "safety_checker" ) _lowerCAmelCase : List[str] = pipeline.feature_extractor else: _lowerCAmelCase : Any = None _lowerCAmelCase : Union[str, Any] = None _lowerCAmelCase : str = OnnxStableDiffusionPipeline( vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_encoder" ) , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_decoder" ) , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / "text_encoder" ) , tokenizer=pipeline.tokenizer , unet=OnnxRuntimeModel.from_pretrained(output_path / "unet" ) , scheduler=pipeline.scheduler , safety_checker=A__ , feature_extractor=A__ , requires_safety_checker=safety_checker is not None , ) onnx_pipeline.save_pretrained(A__ ) print("ONNX pipeline saved to" , A__ ) del pipeline del onnx_pipeline _lowerCAmelCase : Tuple = OnnxStableDiffusionPipeline.from_pretrained(A__ , provider="CPUExecutionProvider" ) print("ONNX pipeline is loadable" ) if __name__ == "__main__": _snake_case = argparse.ArgumentParser() parser.add_argument( "--model_path", type=str, required=True, help="Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).", ) parser.add_argument("--output_path", type=str, required=True, help="Path to the output model.") parser.add_argument( "--opset", default=14, type=int, help="The version of the ONNX operator set to use.", ) parser.add_argument("--fp16", action="store_true", default=False, help="Export the models in `float16` mode") _snake_case = parser.parse_args() convert_models(args.model_path, args.output_path, args.opset, args.fpaa)
36
'''simple docstring''' import math class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Union[str, Any] , UpperCamelCase__ : Optional[Any]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" UpperCamelCase = n UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # adjacency matrix for weight UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # dp[i][j] stores minimum distance from i to j def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = w def A ( self : str ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): UpperCamelCase = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": _lowerCamelCase : List[str] = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
28
0
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 lowerCAmelCase = get_tests_dir('''fixtures/test_sentencepiece.model''') if is_torch_available(): from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right lowerCAmelCase = 2_5_6_0_4_7 lowerCAmelCase = 2_5_6_1_4_5 @require_sentencepiece @require_tokenizers class A ( _a , unittest.TestCase ): UpperCamelCase_ : Union[str, Any] =NllbTokenizer UpperCamelCase_ : Optional[int] =NllbTokenizerFast UpperCamelCase_ : str =True UpperCamelCase_ : Tuple =True UpperCamelCase_ : Dict ={} def _A (self ): super().setUp() # We have a SentencePiece fixture for testing __lowercase= NllbTokenizer(UpperCamelCase__ , keep_accents=UpperCamelCase__ ) tokenizer.save_pretrained(self.tmpdirname ) def _A (self ): __lowercase= NllbTokenizer(UpperCamelCase__ , keep_accents=UpperCamelCase__ ) __lowercase= tokenizer.tokenize('This is a test' ) self.assertListEqual(UpperCamelCase__ , ['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(UpperCamelCase__ ) , [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] , ) __lowercase= tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( UpperCamelCase__ , [ 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', 'é', '.', ] , ) __lowercase= tokenizer.convert_tokens_to_ids(UpperCamelCase__ ) self.assertListEqual( UpperCamelCase__ , [ value + tokenizer.fairseq_offset for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4] ] , ) __lowercase= tokenizer.convert_ids_to_tokens(UpperCamelCase__ ) self.assertListEqual( UpperCamelCase__ , [ 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 _A (self ): __lowercase= (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})' ): __lowercase= self.rust_tokenizer_class.from_pretrained(UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= self.tokenizer_class.from_pretrained(UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= tempfile.mkdtemp() __lowercase= tokenizer_r.save_pretrained(UpperCamelCase__ ) __lowercase= tokenizer_p.save_pretrained(UpperCamelCase__ ) # 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 ) ) __lowercase= tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f ) self.assertSequenceEqual(UpperCamelCase__ , UpperCamelCase__ ) # Checks everything loads correctly in the same way __lowercase= tokenizer_r.from_pretrained(UpperCamelCase__ ) __lowercase= tokenizer_p.from_pretrained(UpperCamelCase__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase__ , UpperCamelCase__ ) ) shutil.rmtree(UpperCamelCase__ ) # Save tokenizer rust, legacy_format=True __lowercase= tempfile.mkdtemp() __lowercase= tokenizer_r.save_pretrained(UpperCamelCase__ , legacy_format=UpperCamelCase__ ) __lowercase= tokenizer_p.save_pretrained(UpperCamelCase__ ) # Checks it save with the same files self.assertSequenceEqual(UpperCamelCase__ , UpperCamelCase__ ) # Checks everything loads correctly in the same way __lowercase= tokenizer_r.from_pretrained(UpperCamelCase__ ) __lowercase= tokenizer_p.from_pretrained(UpperCamelCase__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase__ , UpperCamelCase__ ) ) shutil.rmtree(UpperCamelCase__ ) # Save tokenizer rust, legacy_format=False __lowercase= tempfile.mkdtemp() __lowercase= tokenizer_r.save_pretrained(UpperCamelCase__ , legacy_format=UpperCamelCase__ ) __lowercase= tokenizer_p.save_pretrained(UpperCamelCase__ ) # 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 __lowercase= tokenizer_r.from_pretrained(UpperCamelCase__ ) __lowercase= tokenizer_p.from_pretrained(UpperCamelCase__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(UpperCamelCase__ , UpperCamelCase__ ) ) shutil.rmtree(UpperCamelCase__ ) @require_torch def _A (self ): if not self.test_seqaseq: return __lowercase= self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): # Longer text that will definitely require truncation. __lowercase= [ ' 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.', ] __lowercase= [ 'Ş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: __lowercase= tokenizer.prepare_seqaseq_batch( src_texts=UpperCamelCase__ , tgt_texts=UpperCamelCase__ , max_length=3 , max_target_length=1_0 , 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] , 1_0 ) # max_target_length will default to max_length if not specified __lowercase= tokenizer.prepare_seqaseq_batch( UpperCamelCase__ , tgt_texts=UpperCamelCase__ , max_length=3 , return_tensors='pt' ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 3 ) __lowercase= tokenizer.prepare_seqaseq_batch( src_texts=UpperCamelCase__ , max_length=3 , max_target_length=1_0 , 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' , UpperCamelCase__ ) @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.' ) def _A (self ): pass def _A (self ): for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ): __lowercase= [AddedToken('<special>' , lstrip=UpperCamelCase__ )] __lowercase= self.rust_tokenizer_class.from_pretrained( UpperCamelCase__ , additional_special_tokens=UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= tokenizer_r.encode('Hey this is a <special> token' ) __lowercase= tokenizer_r.encode('<special>' , add_special_tokens=UpperCamelCase__ )[0] self.assertTrue(special_token_id in r_output ) if self.test_slow_tokenizer: __lowercase= self.rust_tokenizer_class.from_pretrained( UpperCamelCase__ , additional_special_tokens=UpperCamelCase__ , **UpperCamelCase__ , ) __lowercase= self.tokenizer_class.from_pretrained( UpperCamelCase__ , additional_special_tokens=UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= tokenizer_p.encode('Hey this is a <special> token' ) __lowercase= tokenizer_cr.encode('Hey this is a <special> token' ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertTrue(special_token_id in p_output ) self.assertTrue(special_token_id in cr_output ) @require_torch @require_sentencepiece @require_tokenizers class A ( unittest.TestCase ): UpperCamelCase_ : List[str] ='''facebook/nllb-200-distilled-600M''' UpperCamelCase_ : str =[ ''' UN Chief Says There Is No Military Solution in Syria''', ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''', ] UpperCamelCase_ : Dict =[ '''Şeful ONU declară că nu există o soluţie militară în Siria''', '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei''' ''' pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor''' ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''', ] UpperCamelCase_ : Optional[Any] =[ 256_047, 16_297, 134_408, 8_165, 248_066, 14_734, 950, 1_135, 105_721, 3_573, 83, 27_352, 108, 49_486, 2, ] @classmethod def _A (cls ): __lowercase= NllbTokenizer.from_pretrained( cls.checkpoint_name , src_lang='eng_Latn' , tgt_lang='ron_Latn' ) __lowercase= 1 return cls def _A (self ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab'] , 2_5_6_0_0_1 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn'] , 2_5_6_0_0_2 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn'] , 2_5_6_0_5_7 ) def _A (self ): __lowercase= self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , UpperCamelCase__ ) def _A (self ): self.assertIn(UpperCamelCase__ , self.tokenizer.all_special_ids ) # fmt: off __lowercase= [RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7] # fmt: on __lowercase= self.tokenizer.decode(UpperCamelCase__ , skip_special_tokens=UpperCamelCase__ ) __lowercase= self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertNotIn(self.tokenizer.eos_token , UpperCamelCase__ ) def _A (self ): __lowercase= ['this is gunna be a long sentence ' * 2_0] assert isinstance(src_text[0] , UpperCamelCase__ ) __lowercase= 1_0 __lowercase= self.tokenizer(UpperCamelCase__ , max_length=UpperCamelCase__ , truncation=UpperCamelCase__ ).input_ids[0] self.assertEqual(ids[-1] , 2 ) self.assertEqual(ids[0] , UpperCamelCase__ ) self.assertEqual(len(UpperCamelCase__ ) , UpperCamelCase__ ) def _A (self ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR'] ) , [2_5_6_2_0_3, 3] ) def _A (self ): __lowercase= tempfile.mkdtemp() __lowercase= self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(UpperCamelCase__ ) __lowercase= NllbTokenizer.from_pretrained(UpperCamelCase__ ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , UpperCamelCase__ ) @require_torch def _A (self ): __lowercase= self.tokenizer( self.src_text , text_target=self.tgt_text , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=len(self.expected_src_tokens ) , return_tensors='pt' , ) __lowercase= shift_tokens_right( batch['labels'] , self.tokenizer.pad_token_id , self.tokenizer.lang_code_to_id['ron_Latn'] ) self.assertIsInstance(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual((2, 1_5) , batch.input_ids.shape ) self.assertEqual((2, 1_5) , batch.attention_mask.shape ) __lowercase= batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , 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 _A (self ): __lowercase= self.tokenizer(self.src_text , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=3 , return_tensors='pt' ) __lowercase= self.tokenizer( text_target=self.tgt_text , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=1_0 , return_tensors='pt' ) __lowercase= targets['input_ids'] __lowercase= shift_tokens_right( UpperCamelCase__ , 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] , 1_0 ) @require_torch def _A (self ): __lowercase= self.tokenizer._build_translation_inputs( 'A test' , return_tensors='pt' , src_lang='eng_Latn' , tgt_lang='fra_Latn' ) self.assertEqual( nested_simplify(UpperCamelCase__ ) , { # A, test, EOS, en_XX 'input_ids': [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]], 'attention_mask': [[1, 1, 1, 1]], # ar_AR 'forced_bos_token_id': 2_5_6_0_5_7, } , ) @require_torch def _A (self ): __lowercase= True __lowercase= 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_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7] ) __lowercase= False __lowercase= 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 , [2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2] )
295
'''simple docstring''' _lowerCamelCase : int = "0.21.0" from .accelerator import Accelerator from .big_modeling import ( cpu_offload, cpu_offload_with_hook, disk_offload, dispatch_model, init_empty_weights, init_on_device, load_checkpoint_and_dispatch, ) from .data_loader import skip_first_batches from .launchers import debug_launcher, notebook_launcher from .state import PartialState from .utils import ( DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, FullyShardedDataParallelPlugin, GradScalerKwargs, InitProcessGroupKwargs, find_executable_batch_size, infer_auto_device_map, is_rich_available, load_checkpoint_in_model, synchronize_rng_states, ) if is_rich_available(): from .utils import rich
28
0
'''simple docstring''' def lowerCamelCase__ ( _A , _A , _A ): if n == 0: return 1 elif n % 2 == 1: return (binary_exponentiation(A__ , n - 1 , A__ ) * a) % mod else: a : Dict = binary_exponentiation(A__ , n / 2 , A__ ) return (b * b) % mod # a prime number lowerCAmelCase: Dict = 7_0_1 lowerCAmelCase: Dict = 1_0_0_0_0_0_0_0_0_0 lowerCAmelCase: Tuple = 1_0 # using binary exponentiation function, O(log(p)): print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p) print((a / b) % p == (a * b ** (p - 2)) % p)
297
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowerCamelCase : List[Any] = { "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"], "tokenization_m2m_100": ["M2M100Tokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : int = [ "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST", "M2M100ForConditionalGeneration", "M2M100Model", "M2M100PreTrainedModel", ] if TYPE_CHECKING: from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig from .tokenization_mam_aaa import MaMaaaTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mam_aaa import ( M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST, MaMaaaForConditionalGeneration, MaMaaaModel, MaMaaaPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
"""simple docstring""" from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a = {"configuration_focalnet": ["FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "FocalNetConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a = [ "FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST", "FocalNetForImageClassification", "FocalNetForMaskedImageModeling", "FocalNetBackbone", "FocalNetModel", "FocalNetPreTrainedModel", ] if TYPE_CHECKING: from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_focalnet import ( FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST, FocalNetBackbone, FocalNetForImageClassification, FocalNetForMaskedImageModeling, FocalNetModel, FocalNetPreTrainedModel, ) else: import sys a = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
315
'''simple docstring''' from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def __lowerCamelCase ( A__ , A__ , A__=1e-1_2 ) -> Dict: """simple docstring""" UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T return jnp.matmul(A__ , norm_emb_a.T ) class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = jnp.floataa def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = FlaxCLIPVisionModule(self.config.vision_config ) UpperCamelCase = nn.Dense(self.config.projection_dim , use_bias=UpperCamelCase__ , dtype=self.dtype ) UpperCamelCase = self.param('concept_embeds' , jax.nn.initializers.ones , (1_7, self.config.projection_dim) ) UpperCamelCase = self.param( 'special_care_embeds' , jax.nn.initializers.ones , (3, self.config.projection_dim) ) UpperCamelCase = self.param('concept_embeds_weights' , jax.nn.initializers.ones , (1_7,) ) UpperCamelCase = self.param('special_care_embeds_weights' , jax.nn.initializers.ones , (3,) ) def __call__( self : str , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = self.vision_model(UpperCamelCase__ )[1] UpperCamelCase = self.visual_projection(UpperCamelCase__ ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.special_care_embeds ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.concept_embeds ) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs UpperCamelCase = 0.0 UpperCamelCase = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(special_scores > 0 , axis=1 , keepdims=UpperCamelCase__ ) # Use a lower threshold if an image has any special care concept UpperCamelCase = is_special_care * 0.0_1 UpperCamelCase = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(concept_scores > 0 , axis=1 ) return has_nsfw_concepts class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = CLIPConfig _SCREAMING_SNAKE_CASE = """clip_input""" _SCREAMING_SNAKE_CASE = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , UpperCamelCase__ : CLIPConfig , UpperCamelCase__ : Optional[Tuple] = None , UpperCamelCase__ : int = 0 , UpperCamelCase__ : jnp.dtype = jnp.floataa , UpperCamelCase__ : bool = True , **UpperCamelCase__ : List[str] , ): """simple docstring""" if input_shape is None: UpperCamelCase = (1, 2_2_4, 2_2_4, 3) UpperCamelCase = self.module_class(config=UpperCamelCase__ , dtype=UpperCamelCase__ , **UpperCamelCase__ ) super().__init__(UpperCamelCase__ , UpperCamelCase__ , input_shape=UpperCamelCase__ , seed=UpperCamelCase__ , dtype=UpperCamelCase__ , _do_init=_do_init ) def A ( self : int , UpperCamelCase__ : jax.random.KeyArray , UpperCamelCase__ : Tuple , UpperCamelCase__ : FrozenDict = None ): """simple docstring""" UpperCamelCase = jax.random.normal(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase , UpperCamelCase = jax.random.split(UpperCamelCase__ ) UpperCamelCase = {'params': params_rng, 'dropout': dropout_rng} UpperCamelCase = self.module.init(UpperCamelCase__ , UpperCamelCase__ )['params'] return random_params def __call__( self : List[Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : dict = None , ): """simple docstring""" UpperCamelCase = jnp.transpose(UpperCamelCase__ , (0, 2, 3, 1) ) return self.module.apply( {'params': params or self.params} , jnp.array(UpperCamelCase__ , dtype=jnp.floataa ) , rngs={} , )
28
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available _snake_case = { "configuration_groupvit": [ "GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "GroupViTConfig", "GroupViTOnnxConfig", "GroupViTTextConfig", "GroupViTVisionConfig", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _snake_case = [ "GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST", "GroupViTModel", "GroupViTPreTrainedModel", "GroupViTTextModel", "GroupViTVisionModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _snake_case = [ "TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFGroupViTModel", "TFGroupViTPreTrainedModel", "TFGroupViTTextModel", "TFGroupViTVisionModel", ] if TYPE_CHECKING: from .configuration_groupvit import ( GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GroupViTConfig, GroupViTOnnxConfig, GroupViTTextConfig, GroupViTVisionConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_groupvit import ( GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST, GroupViTModel, GroupViTPreTrainedModel, GroupViTTextModel, GroupViTVisionModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_groupvit import ( TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST, TFGroupViTModel, TFGroupViTPreTrainedModel, TFGroupViTTextModel, TFGroupViTVisionModel, ) else: import sys _snake_case = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
26
'''simple docstring''' import warnings from ...utils import logging from .image_processing_chinese_clip import ChineseCLIPImageProcessor _lowerCamelCase : str = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" def __init__( self : Dict , *UpperCamelCase__ : List[Any] , **UpperCamelCase__ : List[Any] ): """simple docstring""" warnings.warn( 'The class ChineseCLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use ChineseCLIPImageProcessor instead.' , UpperCamelCase__ , ) super().__init__(*UpperCamelCase__ , **UpperCamelCase__ )
28
0
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: _A : Tuple = None _A : int = logging.get_logger(__name__) _A : Any = {"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"} _A : Union[str, Any] = { "vocab_file": { "facebook/mbart-large-en-ro": ( "https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model" ), "facebook/mbart-large-cc25": ( "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model" ), }, "tokenizer_file": { "facebook/mbart-large-en-ro": "https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json", "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json", }, } _A : str = { "facebook/mbart-large-en-ro": 10_24, "facebook/mbart-large-cc25": 10_24, } # fmt: off _A : List[str] = ["ar_AR", "cs_CZ", "de_DE", "en_XX", "es_XX", "et_EE", "fi_FI", "fr_XX", "gu_IN", "hi_IN", "it_IT", "ja_XX", "kk_KZ", "ko_KR", "lt_LT", "lv_LV", "my_MM", "ne_NP", "nl_XX", "ro_RO", "ru_RU", "si_LK", "tr_TR", "vi_VN", "zh_CN"] class __SCREAMING_SNAKE_CASE ( _a ): _UpperCAmelCase : Any = VOCAB_FILES_NAMES _UpperCAmelCase : str = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _UpperCAmelCase : Tuple = PRETRAINED_VOCAB_FILES_MAP _UpperCAmelCase : Tuple = ["input_ids", "attention_mask"] _UpperCAmelCase : Any = MBartTokenizer _UpperCAmelCase : int = [] _UpperCAmelCase : Tuple = [] def __init__( self : Optional[int] , A : int=None , A : Union[str, Any]=None , A : int="<s>" , A : str="</s>" , A : Optional[int]="</s>" , A : Tuple="<s>" , A : Optional[Any]="<unk>" , A : Dict="<pad>" , A : Optional[Any]="<mask>" , A : List[str]=None , A : List[str]=None , A : Any=None , **A : Union[str, Any] , ) ->str: lowerCamelCase__ : Any = AddedToken(UpperCamelCase__ , lstrip=UpperCamelCase__ , rstrip=UpperCamelCase__ ) if isinstance(UpperCamelCase__ , UpperCamelCase__ ) else mask_token super().__init__( vocab_file=UpperCamelCase__ , tokenizer_file=UpperCamelCase__ , bos_token=UpperCamelCase__ , eos_token=UpperCamelCase__ , sep_token=UpperCamelCase__ , cls_token=UpperCamelCase__ , unk_token=UpperCamelCase__ , pad_token=UpperCamelCase__ , mask_token=UpperCamelCase__ , src_lang=UpperCamelCase__ , tgt_lang=UpperCamelCase__ , additional_special_tokens=UpperCamelCase__ , **UpperCamelCase__ , ) lowerCamelCase__ : Dict = vocab_file lowerCamelCase__ : Union[str, Any] = False if not self.vocab_file else True lowerCamelCase__ : str = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({'''additional_special_tokens''': _additional_special_tokens} ) lowerCamelCase__ : Any = { lang_code: self.convert_tokens_to_ids(UpperCamelCase__ ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase__ : Tuple = src_lang if src_lang is not None else '''en_XX''' lowerCamelCase__ : List[str] = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase__ : List[str] = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def __lowerCamelCase ( self : str ) ->Any: return self._src_lang @src_lang.setter def __lowerCamelCase ( self : Optional[Any] , A : str ) ->Optional[int]: lowerCamelCase__ : Optional[Any] = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def __lowerCamelCase ( self : Dict , A : List[int] , A : Optional[List[int]] = None ) ->Tuple: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def __lowerCamelCase ( self : List[Any] , A : List[int] , A : Optional[List[int]] = None ) ->Optional[int]: lowerCamelCase__ : Optional[int] = [self.sep_token_id] lowerCamelCase__ : List[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] def __lowerCamelCase ( self : List[str] , A : str , A : str , A : Optional[str] , A : Optional[str] , **A : int ) ->Dict: if src_lang is None or tgt_lang is None: raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model''' ) lowerCamelCase__ : Dict = src_lang lowerCamelCase__ : List[str] = self(UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , return_tensors=UpperCamelCase__ , **UpperCamelCase__ ) lowerCamelCase__ : Optional[Any] = self.convert_tokens_to_ids(UpperCamelCase__ ) lowerCamelCase__ : Dict = tgt_lang_id return inputs def __lowerCamelCase ( self : str , A : List[str] , A : str = "en_XX" , A : Optional[List[str]] = None , A : str = "ro_RO" , **A : int , ) ->List[str]: lowerCamelCase__ : int = src_lang lowerCamelCase__ : List[str] = tgt_lang return super().prepare_seqaseq_batch(UpperCamelCase__ , UpperCamelCase__ , **UpperCamelCase__ ) def __lowerCamelCase ( self : int ) ->Dict: return self.set_src_lang_special_tokens(self.src_lang ) def __lowerCamelCase ( self : Union[str, Any] ) ->Union[str, Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def __lowerCamelCase ( self : Tuple , A : Any ) ->List[Any]: lowerCamelCase__ : Union[str, Any] = self.convert_tokens_to_ids(UpperCamelCase__ ) lowerCamelCase__ : List[str] = [] lowerCamelCase__ : Optional[Any] = [self.eos_token_id, self.cur_lang_code] lowerCamelCase__ : List[Any] = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase__ : Union[str, Any] = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase__ : Dict = processors.TemplateProcessing( single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str , pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def __lowerCamelCase ( self : List[str] , A : str ) ->Dict: lowerCamelCase__ : Optional[int] = self.convert_tokens_to_ids(UpperCamelCase__ ) lowerCamelCase__ : Any = [] lowerCamelCase__ : Optional[int] = [self.eos_token_id, self.cur_lang_code] lowerCamelCase__ : Any = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase__ : Tuple = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase__ : List[str] = processors.TemplateProcessing( single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str , pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def __lowerCamelCase ( self : Optional[int] , A : str , A : Optional[str] = None ) ->List[str]: 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(UpperCamelCase__ ): logger.error(F"Vocabulary path ({save_directory}) should be a directory." ) return lowerCamelCase__ : List[Any] = os.path.join( UpperCamelCase__ , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(UpperCamelCase__ ): copyfile(self.vocab_file , UpperCamelCase__ ) return (out_vocab_file,)
142
'''simple docstring''' import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed _lowerCamelCase : Optional[int] = logging.getLogger(__name__) def __lowerCamelCase ( A__=2 , A__=3 , A__=16 , A__ = 10 , A__ = 2 ) -> int: """simple docstring""" def get_dataset(A__ ): UpperCamelCase = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(A__ , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) return (train_dataloader, valid_dataloader) def __lowerCamelCase ( A__ , A__ , A__ , A__ , A__ , A__=None ) -> int: """simple docstring""" UpperCamelCase = [] for epoch in range(A__ ): # Train quickly model.train() for batch in dataloader: UpperCamelCase , UpperCamelCase = batch UpperCamelCase = model(A__ ) UpperCamelCase = torch.nn.functional.mse_loss(A__ , A__ ) accelerator.backward(A__ ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" def __init__( self : Tuple ): """simple docstring""" super().__init__() UpperCamelCase = nn.Parameter(torch.randn(1 ) ) UpperCamelCase = nn.Parameter(torch.randn(1 ) ) def A ( self : str , UpperCamelCase__ : Dict ): """simple docstring""" return x * self.a + self.b class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(total_limit=1 , project_dir=UpperCamelCase__ , automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def A ( self : Optional[int] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() # Train baseline UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial UpperCamelCase = os.path.join(UpperCamelCase__ , 'initial' ) accelerator.save_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything UpperCamelCase = os.path.join(UpperCamelCase__ , 'checkpoint' ) accelerator.save_state(UpperCamelCase__ ) # Load everything back in and make sure all states work accelerator.load_state(UpperCamelCase__ ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=UpperCamelCase__ ) UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = torch.tensor([1, 2, 3] ) UpperCamelCase = torch.tensor([2, 3, 4] ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(net.parameters() ) UpperCamelCase = Accelerator() with self.assertRaises(UpperCamelCase__ ) as ve: accelerator.register_for_checkpointing(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def A ( self : Dict ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase = torch.optim.lr_scheduler.StepLR(UpperCamelCase__ , step_size=1 , gamma=0.9_9 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() UpperCamelCase = scheduler.state_dict() train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) self.assertNotEqual(UpperCamelCase__ , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(UpperCamelCase__ , scheduler.state_dict() ) def A ( self : List[str] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ , total_limit=2 ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase = accelerator.prepare(UpperCamelCase__ ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def A ( self : Dict ): """simple docstring""" UpperCamelCase = ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )] execute_subprocess_async(UpperCamelCase__ , env=os.environ.copy() ) if __name__ == "__main__": _lowerCamelCase : Optional[int] = "/tmp/accelerate/state_checkpointing" _lowerCamelCase : Union[str, Any] = DummyModel() _lowerCamelCase : Optional[Any] = torch.optim.Adam(params=model.parameters(), lr=1e-3) _lowerCamelCase : List[Any] = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.99) _lowerCamelCase ,_lowerCamelCase : Tuple = dummy_dataloaders() _lowerCamelCase : List[Any] = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline _lowerCamelCase : Any = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision="no") if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) _lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase : Union[str, Any] = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) _lowerCamelCase ,_lowerCamelCase : Tuple = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: _lowerCamelCase : Any = group["params"][0].device break assert param_device.type == accelerator.device.type _lowerCamelCase : Tuple = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="cpu") for group in optimizer.param_groups: _lowerCamelCase : Optional[Any] = group["params"][0].device break assert ( param_device.type == torch.device("cpu").type ), f"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="on_device") for group in optimizer.param_groups: _lowerCamelCase : Dict = group["params"][0].device break assert ( param_device.type == accelerator.device.type ), f"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match="Unsupported optimizer map location passed"): accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="invalid") accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
28
0
'''simple docstring''' import os import zipfile import requests from get_ci_error_statistics import download_artifact, get_artifacts_links def A__ ( UpperCAmelCase_ , UpperCAmelCase_=7 ): _UpperCamelCase : Optional[int] = None if token is not None: _UpperCamelCase : str = {'Accept': 'application/vnd.github+json', 'Authorization': f'Bearer {token}'} # The id of a workflow (not of a workflow run) _UpperCamelCase : List[Any] = '636036' _UpperCamelCase : List[str] = f'https://api.github.com/repos/huggingface/transformers/actions/workflows/{workflow_id}/runs' # On `main` branch + event being `schedule` + not returning PRs + only `num_runs` results url += f'?branch=main&event=schedule&exclude_pull_requests=true&per_page={num_runs}' _UpperCamelCase : Optional[Any] = requests.get(A__ , headers=A__ ).json() return result["workflow_runs"] def A__ ( UpperCAmelCase_ ): _UpperCamelCase : Any = get_daily_ci_runs(A__ ) _UpperCamelCase : Dict = None for workflow_run in workflow_runs: if workflow_run["status"] == "completed": _UpperCamelCase : Union[str, Any] = workflow_run['id'] break return workflow_run_id def A__ ( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ): _UpperCamelCase : Tuple = get_last_daily_ci_runs(A__ ) if workflow_run_id is not None: _UpperCamelCase : List[str] = get_artifacts_links(worflow_run_id=A__ , token=A__ ) for artifact_name in artifact_names: if artifact_name in artifacts_links: _UpperCamelCase : List[Any] = artifacts_links[artifact_name] download_artifact( artifact_name=A__ , artifact_url=A__ , output_dir=A__ , token=A__ ) def A__ ( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ): get_last_daily_ci_artifacts(A__ , A__ , A__ ) _UpperCamelCase : int = {} for artifact_name in artifact_names: _UpperCamelCase : Union[str, Any] = os.path.join(A__ , f'{artifact_name}.zip' ) if os.path.isfile(A__ ): _UpperCamelCase : List[str] = {} with zipfile.ZipFile(A__ ) as z: for filename in z.namelist(): if not os.path.isdir(A__ ): # read the file with z.open(A__ ) as f: _UpperCamelCase : int = f.read().decode('UTF-8' ) return results
83
'''simple docstring''' import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration _lowerCamelCase : List[str] = 5_0000 _lowerCamelCase : Optional[int] = 5000 _lowerCamelCase ,_lowerCamelCase : int = os.path.split(__file__) _lowerCamelCase : str = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json")) @get_duration def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> int: """simple docstring""" for i in range(0 , len(A__ ) , A__ ): UpperCamelCase = dataset[i : i + batch_size] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> List[Any]: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ , A__ ) -> int: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(0 , A__ , A__ ): UpperCamelCase = dataset[i : i + batch_size] def __lowerCamelCase ( ) -> List[str]: """simple docstring""" UpperCamelCase = {'num examples': SPEED_TEST_N_EXAMPLES} UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted, {'type': 'pandas', 'length': SMALL_TEST}), (read_formatted, {'type': 'torch', 'length': SMALL_TEST}), (read_formatted, {'type': 'tensorflow', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print('generating dataset' ) UpperCamelCase = datasets.Features( {'list': datasets.Sequence(datasets.Value('float32' ) ), 'numbers': datasets.Value('float32' )} ) UpperCamelCase = generate_example_dataset( os.path.join(A__ , 'dataset.arrow' ) , A__ , num_examples=A__ , seq_shapes={'list': (100,)} , ) print('first set of iterations' ) for func, kwargs in functions: print(func.__name__ , str(A__ ) ) UpperCamelCase = func(A__ , **A__ ) print('shuffling dataset' ) UpperCamelCase = dataset.shuffle() print('Second set of iterations (after shuffling' ) for func, kwargs in functions_shuffled: print('shuffled ' , func.__name__ , str(A__ ) ) UpperCamelCase = func( A__ , **A__ ) with open(A__ , 'wb' ) as f: f.write(json.dumps(A__ ).encode('utf-8' ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
28
0
from abc import ABC, abstractmethod from argparse import ArgumentParser class A_ ( _a ): @staticmethod @abstractmethod def UpperCAmelCase ( UpperCAmelCase : ArgumentParser ) -> Union[str, Any]: raise NotImplementedError() @abstractmethod def UpperCAmelCase ( self : Any ) -> List[Any]: raise NotImplementedError()
322
'''simple docstring''' import absl # noqa: F401 # Here to have a nice missing dependency error message early on import nltk # noqa: F401 # Here to have a nice missing dependency error message early on import numpy # noqa: F401 # Here to have a nice missing dependency error message early on import six # noqa: F401 # Here to have a nice missing dependency error message early on from rouge_score import rouge_scorer, scoring import datasets _lowerCamelCase : List[str] = "\\n@inproceedings{lin-2004-rouge,\n title = \"{ROUGE}: A Package for Automatic Evaluation of Summaries\",\n author = \"Lin, Chin-Yew\",\n booktitle = \"Text Summarization Branches Out\",\n month = jul,\n year = \"2004\",\n address = \"Barcelona, Spain\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://www.aclweb.org/anthology/W04-1013\",\n pages = \"74--81\",\n}\n" _lowerCamelCase : Optional[int] = "\\nROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for\nevaluating automatic summarization and machine translation software in natural language processing.\nThe metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.\n\nNote that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.\n\nThis metrics is a wrapper around Google Research reimplementation of ROUGE:\nhttps://github.com/google-research/google-research/tree/master/rouge\n" _lowerCamelCase : str = "\nCalculates average rouge scores for a list of hypotheses and references\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n rouge_types: A list of rouge types to calculate.\n Valid names:\n `\"rouge{n}\"` (e.g. `\"rouge1\"`, `\"rouge2\"`) where: {n} is the n-gram based scoring,\n `\"rougeL\"`: Longest common subsequence based scoring.\n `\"rougeLSum\"`: rougeLsum splits text using `\"\n\"`.\n See details in https://github.com/huggingface/datasets/issues/617\n use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.\n use_aggregator: Return aggregates if this is set to True\nReturns:\n rouge1: rouge_1 (precision, recall, f1),\n rouge2: rouge_2 (precision, recall, f1),\n rougeL: rouge_l (precision, recall, f1),\n rougeLsum: rouge_lsum (precision, recall, f1)\nExamples:\n\n >>> rouge = datasets.load_metric('rouge')\n >>> predictions = [\"hello there\", \"general kenobi\"]\n >>> references = [\"hello there\", \"general kenobi\"]\n >>> results = rouge.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n ['rouge1', 'rouge2', 'rougeL', 'rougeLsum']\n >>> print(results[\"rouge1\"])\n AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0))\n >>> print(results[\"rouge1\"].mid.fmeasure)\n 1.0\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/google-research/google-research/tree/master/rouge'] , reference_urls=[ 'https://en.wikipedia.org/wiki/ROUGE_(metric)', 'https://github.com/google-research/google-research/tree/master/rouge', ] , ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : List[str]=None , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Optional[Any]=False ): """simple docstring""" if rouge_types is None: UpperCamelCase = ['rouge1', 'rouge2', 'rougeL', 'rougeLsum'] UpperCamelCase = rouge_scorer.RougeScorer(rouge_types=UpperCamelCase__ , use_stemmer=UpperCamelCase__ ) if use_aggregator: UpperCamelCase = scoring.BootstrapAggregator() else: UpperCamelCase = [] for ref, pred in zip(UpperCamelCase__ , UpperCamelCase__ ): UpperCamelCase = scorer.score(UpperCamelCase__ , UpperCamelCase__ ) if use_aggregator: aggregator.add_scores(UpperCamelCase__ ) else: scores.append(UpperCamelCase__ ) if use_aggregator: UpperCamelCase = aggregator.aggregate() else: UpperCamelCase = {} for key in scores[0]: UpperCamelCase = [score[key] for score in scores] return result
28
0
"""simple docstring""" from math import factorial, pi def snake_case_ ( A_ : Union[str, Any], A_ : Tuple = 30 ): '''simple docstring''' if not isinstance(A__, (int, float) ): raise ValueError('''maclaurin_sin() requires either an int or float for theta''' ) if not isinstance(A__, A__ ) or accuracy <= 0: raise ValueError('''maclaurin_sin() requires a positive int for accuracy''' ) _lowerCamelCase : Optional[Any] = float(A__ ) _lowerCamelCase : Dict = theta // (2 * pi) theta -= 2 * div * pi return sum( (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1 ) for r in range(A__ ) ) def snake_case_ ( A_ : Optional[Any], A_ : List[Any] = 30 ): '''simple docstring''' if not isinstance(A__, (int, float) ): raise ValueError('''maclaurin_cos() requires either an int or float for theta''' ) if not isinstance(A__, A__ ) or accuracy <= 0: raise ValueError('''maclaurin_cos() requires a positive int for accuracy''' ) _lowerCamelCase : Optional[int] = float(A__ ) _lowerCamelCase : Dict = theta // (2 * pi) theta -= 2 * div * pi return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r ) for r in range(A__ ) ) if __name__ == "__main__": import doctest doctest.testmod() print(maclaurin_sin(10)) print(maclaurin_sin(-10)) print(maclaurin_sin(10, 15)) print(maclaurin_sin(-10, 15)) print(maclaurin_cos(5)) print(maclaurin_cos(-5)) print(maclaurin_cos(10, 15)) print(maclaurin_cos(-10, 15))
72
'''simple docstring''' from PIL import Image def __lowerCamelCase ( A__ , A__ ) -> Image: """simple docstring""" def brightness(A__ ) -> float: return 128 + level + (c - 128) if not -255.0 <= level <= 255.0: raise ValueError('level must be between -255.0 (black) and 255.0 (white)' ) return img.point(A__ ) if __name__ == "__main__": # Load image with Image.open("image_data/lena.jpg") as img: # Change brightness to 100 _lowerCamelCase : List[str] = change_brightness(img, 100) brigt_img.save("image_data/lena_brightness.png", format="png")
28
0
from maths.is_square_free import is_square_free from maths.prime_factors import prime_factors def _UpperCAmelCase ( a__): '''simple docstring''' a_ : Optional[Any] = prime_factors(A__) if is_square_free(A__): return -1 if len(A__) % 2 else 1 return 0 if __name__ == "__main__": import doctest doctest.testmod()
248
'''simple docstring''' from . import ( albert, align, altclip, audio_spectrogram_transformer, auto, autoformer, bark, bart, barthez, bartpho, beit, bert, bert_generation, bert_japanese, bertweet, big_bird, bigbird_pegasus, biogpt, bit, blenderbot, blenderbot_small, blip, blip_a, bloom, bridgetower, byta, camembert, canine, chinese_clip, clap, clip, clipseg, codegen, conditional_detr, convbert, convnext, convnextva, cpm, cpmant, ctrl, cvt, dataavec, deberta, deberta_va, decision_transformer, deformable_detr, deit, deprecated, deta, detr, dialogpt, dinat, distilbert, dit, donut, dpr, dpt, efficientformer, efficientnet, electra, encodec, encoder_decoder, ernie, ernie_m, esm, falcon, flaubert, flava, fnet, focalnet, fsmt, funnel, git, glpn, gpta, gpt_bigcode, gpt_neo, gpt_neox, gpt_neox_japanese, gpt_swa, gptj, gptsan_japanese, graphormer, groupvit, herbert, hubert, ibert, imagegpt, informer, instructblip, jukebox, layoutlm, layoutlmva, layoutlmva, layoutxlm, led, levit, lilt, llama, longformer, longta, luke, lxmert, mam_aaa, marian, markuplm, maskaformer, maskformer, mbart, mbartaa, mega, megatron_bert, megatron_gpta, mgp_str, mluke, mobilebert, mobilenet_va, mobilenet_va, mobilevit, mobilevitva, mpnet, mra, mta, musicgen, mvp, nat, nezha, nllb, nllb_moe, nystromformer, oneformer, open_llama, openai, opt, owlvit, pegasus, pegasus_x, perceiver, phobert, pixastruct, plbart, poolformer, prophetnet, qdqbert, rag, realm, reformer, regnet, rembert, resnet, roberta, roberta_prelayernorm, roc_bert, roformer, rwkv, sam, segformer, sew, sew_d, speech_encoder_decoder, speech_to_text, speech_to_text_a, speechta, splinter, squeezebert, swiftformer, swin, swinasr, swinva, switch_transformers, ta, table_transformer, tapas, time_series_transformer, timesformer, timm_backbone, transfo_xl, trocr, tvlt, umta, unispeech, unispeech_sat, upernet, videomae, vilt, vision_encoder_decoder, vision_text_dual_encoder, visual_bert, vit, vit_hybrid, vit_mae, vit_msn, vivit, wavaveca, wavaveca_conformer, wavaveca_phoneme, wavaveca_with_lm, wavlm, whisper, x_clip, xglm, xlm, xlm_prophetnet, xlm_roberta, xlm_roberta_xl, xlnet, xmod, yolos, yoso, )
28
0
import dataclasses import json import warnings from dataclasses import dataclass, field from time import time from typing import List from ..utils import logging _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE__ ( __a=None , __a=None ): return field(default_factory=lambda: default , metadata=A__ ) @dataclass class SCREAMING_SNAKE_CASE_ : __magic_name__: Union[str, Any] = list_field( default=[] , metadata={ "help": ( "Model checkpoints to be provided to the AutoModel classes. Leave blank to benchmark the base version" " of all available models" ) } , ) __magic_name__: Dict = list_field( default=[8] , metadata={"help": "List of batch sizes for which memory and time performance will be evaluated"} ) __magic_name__: str = list_field( default=[8, 32, 128, 512] , metadata={"help": "List of sequence lengths for which memory and time performance will be evaluated"} , ) __magic_name__: Dict = field( default=_a , metadata={"help": "Whether to benchmark inference of model. Inference can be disabled via --no-inference."} , ) __magic_name__: Union[str, Any] = field( default=_a , metadata={"help": "Whether to run on available cuda devices. Cuda can be disabled via --no-cuda."} , ) __magic_name__: List[str] = field( default=_a , metadata={"help": "Whether to run on available tpu devices. TPU can be disabled via --no-tpu."} ) __magic_name__: Tuple = field(default=_a , metadata={"help": "Use FP16 to accelerate inference."} ) __magic_name__: Optional[int] = field(default=_a , metadata={"help": "Benchmark training of model"} ) __magic_name__: str = field(default=_a , metadata={"help": "Verbose memory tracing"} ) __magic_name__: str = field( default=_a , metadata={"help": "Whether to perform speed measurements. Speed measurements can be disabled via --no-speed."} , ) __magic_name__: Optional[int] = field( default=_a , metadata={ "help": "Whether to perform memory measurements. Memory measurements can be disabled via --no-memory" } , ) __magic_name__: Any = field(default=_a , metadata={"help": "Trace memory line by line"} ) __magic_name__: Any = field(default=_a , metadata={"help": "Save result to a CSV file"} ) __magic_name__: Optional[int] = field(default=_a , metadata={"help": "Save all print statements in a log file"} ) __magic_name__: Optional[Any] = field(default=_a , metadata={"help": "Whether to print environment information"} ) __magic_name__: Dict = field( default=_a , metadata={ "help": ( "Whether to use multiprocessing for memory and speed measurement. It is highly recommended to use" " multiprocessing for accurate CPU and GPU memory measurements. This option should only be disabled" " for debugging / testing and on TPU." ) } , ) __magic_name__: Optional[int] = field( default=F"inference_time_{round(time() )}.csv" , metadata={"help": "CSV filename used if saving time results to csv."} , ) __magic_name__: Tuple = field( default=F"inference_memory_{round(time() )}.csv" , metadata={"help": "CSV filename used if saving memory results to csv."} , ) __magic_name__: Optional[int] = field( default=F"train_time_{round(time() )}.csv" , metadata={"help": "CSV filename used if saving time results to csv for training."} , ) __magic_name__: int = field( default=F"train_memory_{round(time() )}.csv" , metadata={"help": "CSV filename used if saving memory results to csv for training."} , ) __magic_name__: Optional[Any] = field( default=F"env_info_{round(time() )}.csv" , metadata={"help": "CSV filename used if saving environment information."} , ) __magic_name__: List[str] = field( default=F"log_{round(time() )}.csv" , metadata={"help": "Log filename used if print statements are saved in log."} , ) __magic_name__: int = field(default=3 , metadata={"help": "Times an experiment will be run."} ) __magic_name__: Tuple = field( default=_a , metadata={ "help": ( "Instead of loading the model as defined in `config.architectures` if exists, just load the pretrain" " model weights." ) } , ) def UpperCAmelCase_ ( self : int ) -> Tuple: """simple docstring""" warnings.warn( F"""The class {self.__class__} is deprecated. Hugging Face Benchmarking utils""" ' are deprecated in general and it is advised to use external Benchmarking libraries ' ' to benchmark Transformer models.' , UpperCamelCase__ , ) def UpperCAmelCase_ ( self : int ) -> List[str]: """simple docstring""" return json.dumps(dataclasses.asdict(self ) , indent=2 ) @property def UpperCAmelCase_ ( self : List[str] ) -> Optional[Any]: """simple docstring""" if len(self.models ) <= 0: raise ValueError( 'Please make sure you provide at least one model name / model identifier, *e.g.* `--models' ' bert-base-cased` or `args.models = [\'bert-base-cased\'].' ) return self.models @property def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[Any]: """simple docstring""" if not self.multi_process: return False elif self.is_tpu: logger.info('Multiprocessing is currently not possible on TPU.' ) return False else: return True
327
'''simple docstring''' import unittest from transformers import MraConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_torch_available(): import torch from transformers import ( MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, MraModel, ) from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : Any=2 , UpperCamelCase__ : Union[str, Any]=8 , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Any=True , UpperCamelCase__ : str=True , UpperCamelCase__ : Dict=True , UpperCamelCase__ : List[Any]=9_9 , UpperCamelCase__ : List[Any]=1_6 , UpperCamelCase__ : List[str]=5 , UpperCamelCase__ : Dict=2 , UpperCamelCase__ : Optional[int]=3_6 , UpperCamelCase__ : str="gelu" , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Optional[int]=5_1_2 , UpperCamelCase__ : Dict=1_6 , UpperCamelCase__ : List[str]=2 , UpperCamelCase__ : Any=0.0_2 , UpperCamelCase__ : str=3 , UpperCamelCase__ : Tuple=4 , UpperCamelCase__ : Union[str, Any]=None , ): """simple docstring""" UpperCamelCase = parent UpperCamelCase = batch_size UpperCamelCase = seq_length UpperCamelCase = is_training UpperCamelCase = use_input_mask UpperCamelCase = use_token_type_ids UpperCamelCase = use_labels UpperCamelCase = vocab_size UpperCamelCase = hidden_size UpperCamelCase = num_hidden_layers UpperCamelCase = num_attention_heads UpperCamelCase = intermediate_size UpperCamelCase = hidden_act UpperCamelCase = hidden_dropout_prob UpperCamelCase = attention_probs_dropout_prob UpperCamelCase = max_position_embeddings UpperCamelCase = type_vocab_size UpperCamelCase = type_sequence_label_size UpperCamelCase = initializer_range UpperCamelCase = num_labels UpperCamelCase = num_choices UpperCamelCase = scope def A ( self : int ): """simple docstring""" UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase = None if self.use_input_mask: UpperCamelCase = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase = None if self.use_token_type_ids: UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCamelCase = 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] , self.num_choices ) UpperCamelCase = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def A ( self : Optional[int] ): """simple docstring""" return MraConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.get_config() UpperCamelCase = 3_0_0 return config def A ( self : Tuple ): """simple docstring""" ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = self.prepare_config_and_inputs() UpperCamelCase = True UpperCamelCase = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : int , UpperCamelCase__ : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : int , UpperCamelCase__ : List[str] , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = MraModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : List[str] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : str , UpperCamelCase__ : Dict , UpperCamelCase__ : Optional[Any] , ): """simple docstring""" UpperCamelCase = True UpperCamelCase = MraModel(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , encoder_attention_mask=UpperCamelCase__ , ) UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , ) UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : int , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[Any] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = MraForMaskedLM(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[str] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = MraForQuestionAnswering(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , start_positions=UpperCamelCase__ , end_positions=UpperCamelCase__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def A ( self : Optional[int] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForSequenceClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : int , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForTokenClassification(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def A ( self : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : str , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = self.num_choices UpperCamelCase = MraForMultipleChoice(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) 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( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def A ( self : int ): """simple docstring""" UpperCamelCase = self.prepare_config_and_inputs() ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = config_and_inputs UpperCamelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE ( _a , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( MraModel, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, ) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = () def A ( self : str ): """simple docstring""" UpperCamelCase = MraModelTester(self ) UpperCamelCase = ConfigTester(self , config_class=UpperCamelCase__ , hidden_size=3_7 ) def A ( self : str ): """simple docstring""" self.config_tester.run_common_tests() def A ( self : Optional[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : str ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: UpperCamelCase = type self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__ ) def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase__ ) def A ( self : Tuple ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__ ) @slow def A ( self : List[Any] ): """simple docstring""" for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase = MraModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) @unittest.skip(reason='MRA does not output attentions' ) def A ( self : List[str] ): """simple docstring""" return @require_torch class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" @slow def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = MraModel.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = torch.Size((1, 2_5_6, 7_6_8) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 2_5_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3' ) UpperCamelCase = torch.arange(4_0_9_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 4_0_9_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) )
28
0
import argparse import torch from transformers import BlenderbotConfig, BlenderbotForConditionalGeneration from transformers.utils import logging logging.set_verbosity_info() _snake_case = logging.get_logger(__name__) _snake_case = [ ["attention", "attn"], ["encoder_attention", "encoder_attn"], ["q_lin", "q_proj"], ["k_lin", "k_proj"], ["v_lin", "v_proj"], ["out_lin", "out_proj"], ["norm_embeddings", "layernorm_embedding"], ["position_embeddings", "embed_positions"], ["embeddings", "embed_tokens"], ["ffn.lin", "fc"], ] def A ( _lowerCamelCase ): '''simple docstring''' if k == "embeddings.weight": return "shared.weight" for parlai_name, hf_name in PATTERNS: _lowerCAmelCase : Optional[int] = k.replace(A__ , A__ ) if k.startswith("encoder" ): _lowerCAmelCase : Optional[Any] = k.replace(".attn" , ".self_attn" ) _lowerCAmelCase : List[str] = k.replace("norm1" , "self_attn_layer_norm" ) _lowerCAmelCase : Union[str, Any] = k.replace("norm2" , "final_layer_norm" ) elif k.startswith("decoder" ): _lowerCAmelCase : str = k.replace("norm1" , "self_attn_layer_norm" ) _lowerCAmelCase : Tuple = k.replace("norm2" , "encoder_attn_layer_norm" ) _lowerCAmelCase : int = k.replace("norm3" , "final_layer_norm" ) return k def A ( _lowerCamelCase ): '''simple docstring''' _lowerCAmelCase : int = [ "model.encoder.layernorm_embedding.weight", "model.encoder.layernorm_embedding.bias", "model.decoder.layernorm_embedding.weight", "model.decoder.layernorm_embedding.bias", ] for k in keys: _lowerCAmelCase : Optional[int] = sd.pop(A__ ) _lowerCAmelCase : List[str] = k.replace("layernorm_embedding" , "layer_norm" ) assert new_k not in sd _lowerCAmelCase : List[str] = v _snake_case = ["START"] @torch.no_grad() def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' _lowerCAmelCase : Optional[Any] = torch.load(A__ , map_location="cpu" ) _lowerCAmelCase : str = model["model"] _lowerCAmelCase : Tuple = BlenderbotConfig.from_json_file(A__ ) _lowerCAmelCase : Union[str, Any] = BlenderbotForConditionalGeneration(A__ ) _lowerCAmelCase : int = m.model.state_dict().keys() _lowerCAmelCase : Tuple = [] _lowerCAmelCase : Any = {} for k, v in sd.items(): if k in IGNORE_KEYS: continue _lowerCAmelCase : int = rename_state_dict_key(A__ ) if new_k not in valid_keys: failures.append([k, new_k] ) else: _lowerCAmelCase : Optional[int] = v if cfg.normalize_before: # Blenderbot-3B checkpoints. Rename layernorm_embedding -> layer_norm rename_layernorm_keys(A__ ) m.model.load_state_dict(A__ , strict=A__ ) m.half() m.save_pretrained(A__ ) if __name__ == "__main__": _snake_case = argparse.ArgumentParser() # Required parameters parser.add_argument("--src_path", type=str, help="like blenderbot-model.bin") parser.add_argument("--save_dir", default="hf_blenderbot", type=str, help="Where to save converted model.") parser.add_argument( "--hf_config_json", default="blenderbot-3b-config.json", type=str, help="Path to config to use" ) _snake_case = parser.parse_args() convert_parlai_checkpoint(args.src_path, args.save_dir, args.hf_config_json)
36
'''simple docstring''' import numpy as np import torch from torch.nn import CrossEntropyLoss from transformers import AutoModelForCausalLM, AutoTokenizer import datasets from datasets import logging _lowerCamelCase : Union[str, Any] = "\\n\n" _lowerCamelCase : List[str] = "\nPerplexity (PPL) is one of the most common metrics for evaluating language models.\nIt is defined as the exponentiated average negative log-likelihood of a sequence.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n" _lowerCamelCase : Dict = "\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n input_texts (list of str): input text, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to 'cuda' when available\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = [\"lorem ipsum\", \"Happy Birthday!\", \"Bienvenue\"]\n >>> results = perplexity.compute(model_id='gpt2',\n ... add_start_token=False,\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 78.22\n >>> print(round(results[\"perplexities\"][0], 2))\n 11.11\n\n Example 2:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = datasets.load_dataset(\"wikitext\",\n ... \"wikitext-2-raw-v1\",\n ... split=\"test\")[\"text\"][:50] # doctest:+ELLIPSIS\n [...]\n >>> input_texts = [s for s in input_texts if s!='']\n >>> results = perplexity.compute(model_id='gpt2',\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 60.35\n >>> print(round(results[\"perplexities\"][0], 2))\n 81.12\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Tuple ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'input_texts': datasets.Value('string' ), } ) , reference_urls=['https://huggingface.co/docs/transformers/perplexity'] , ) def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : int = 1_6 , UpperCamelCase__ : bool = True , UpperCamelCase__ : List[Any]=None ): """simple docstring""" if device is not None: assert device in ["gpu", "cpu", "cuda"], "device should be either gpu or cpu." if device == "gpu": UpperCamelCase = 'cuda' else: UpperCamelCase = 'cuda' if torch.cuda.is_available() else 'cpu' UpperCamelCase = AutoModelForCausalLM.from_pretrained(UpperCamelCase__ ) UpperCamelCase = model.to(UpperCamelCase__ ) UpperCamelCase = AutoTokenizer.from_pretrained(UpperCamelCase__ ) # if batch_size > 1 (which generally leads to padding being required), and # if there is not an already assigned pad_token, assign an existing # special token to also be the padding token if tokenizer.pad_token is None and batch_size > 1: UpperCamelCase = list(tokenizer.special_tokens_map_extended.values() ) # check that the model already has at least one special token defined assert ( len(UpperCamelCase__ ) > 0 ), "If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1." # assign one of the special tokens to also be the pad token tokenizer.add_special_tokens({'pad_token': existing_special_tokens[0]} ) if add_start_token: # leave room for <BOS> token to be added: assert ( tokenizer.bos_token is not None ), "Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False" UpperCamelCase = model.config.max_length - 1 else: UpperCamelCase = model.config.max_length UpperCamelCase = tokenizer( UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=UpperCamelCase__ , return_tensors='pt' , return_attention_mask=UpperCamelCase__ , ).to(UpperCamelCase__ ) UpperCamelCase = encodings['input_ids'] UpperCamelCase = encodings['attention_mask'] # check that each input is long enough: if add_start_token: assert torch.all(torch.ge(attn_masks.sum(1 ) , 1 ) ), "Each input text must be at least one token long." else: assert torch.all( torch.ge(attn_masks.sum(1 ) , 2 ) ), "When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings." UpperCamelCase = [] UpperCamelCase = CrossEntropyLoss(reduction='none' ) for start_index in logging.tqdm(range(0 , len(UpperCamelCase__ ) , UpperCamelCase__ ) ): UpperCamelCase = min(start_index + batch_size , len(UpperCamelCase__ ) ) UpperCamelCase = encoded_texts[start_index:end_index] UpperCamelCase = attn_masks[start_index:end_index] if add_start_token: UpperCamelCase = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0 ) ).to(UpperCamelCase__ ) UpperCamelCase = torch.cat([bos_tokens_tensor, encoded_batch] , dim=1 ) UpperCamelCase = torch.cat( [torch.ones(bos_tokens_tensor.size() , dtype=torch.intaa ).to(UpperCamelCase__ ), attn_mask] , dim=1 ) UpperCamelCase = encoded_batch with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ ).logits UpperCamelCase = out_logits[..., :-1, :].contiguous() UpperCamelCase = labels[..., 1:].contiguous() UpperCamelCase = attn_mask[..., 1:].contiguous() UpperCamelCase = torch.expa( (loss_fct(shift_logits.transpose(1 , 2 ) , UpperCamelCase__ ) * shift_attention_mask_batch).sum(1 ) / shift_attention_mask_batch.sum(1 ) ) ppls += perplexity_batch.tolist() return {"perplexities": ppls, "mean_perplexity": np.mean(UpperCamelCase__ )}
28
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 = { "andreasmadsen/efficient_mlm_m0.40": ( "https://huggingface.co/andreasmadsen/efficient_mlm_m0.40/resolve/main/config.json" ), } class A ( _a ): UpperCamelCase_ : str ='''roberta-prelayernorm''' def __init__(self , lowerCAmelCase=5_0_2_6_5 , lowerCAmelCase=7_6_8 , lowerCAmelCase=1_2 , lowerCAmelCase=1_2 , lowerCAmelCase=3_0_7_2 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=5_1_2 , lowerCAmelCase=2 , lowerCAmelCase=0.02 , lowerCAmelCase=1E-12 , lowerCAmelCase=1 , lowerCAmelCase=0 , lowerCAmelCase=2 , lowerCAmelCase="absolute" , lowerCAmelCase=True , lowerCAmelCase=None , **lowerCAmelCase , ): super().__init__(pad_token_id=UpperCamelCase__ , bos_token_id=UpperCamelCase__ , eos_token_id=UpperCamelCase__ , **UpperCamelCase__ ) __lowercase= vocab_size __lowercase= hidden_size __lowercase= num_hidden_layers __lowercase= num_attention_heads __lowercase= hidden_act __lowercase= intermediate_size __lowercase= hidden_dropout_prob __lowercase= attention_probs_dropout_prob __lowercase= max_position_embeddings __lowercase= type_vocab_size __lowercase= initializer_range __lowercase= layer_norm_eps __lowercase= position_embedding_type __lowercase= use_cache __lowercase= classifier_dropout class A ( _a ): @property def _A (self ): if self.task == "multiple-choice": __lowercase= {0: 'batch', 1: 'choice', 2: 'sequence'} else: __lowercase= {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
295
'''simple docstring''' def __lowerCamelCase ( A__ = 50 ) -> int: """simple docstring""" UpperCamelCase = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(f'''{solution() = }''')
28
0
'''simple docstring''' import numpy as np def lowerCamelCase__ ( _A ): return 1 / (1 + np.exp(-vector )) def lowerCamelCase__ ( _A ): return vector * sigmoid(1.702 * vector ) if __name__ == "__main__": import doctest doctest.testmod()
297
'''simple docstring''' def __lowerCamelCase ( A__ ) -> list: """simple docstring""" UpperCamelCase = len(A__ ) for i in range(1 , A__ ): UpperCamelCase = collection[i] UpperCamelCase = 0 UpperCamelCase = i - 1 while low <= high: UpperCamelCase = (low + high) // 2 if val < collection[mid]: UpperCamelCase = mid - 1 else: UpperCamelCase = mid + 1 for j in range(A__ , A__ , -1 ): UpperCamelCase = collection[j - 1] UpperCamelCase = val return collection if __name__ == "__main__": _lowerCamelCase : int = input("Enter numbers separated by a comma:\n").strip() _lowerCamelCase : Union[str, Any] = [int(item) for item in user_input.split(",")] print(binary_insertion_sort(unsorted))
28
0
"""simple docstring""" import copy import os from collections import OrderedDict from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union if TYPE_CHECKING: from ...processing_utils import ProcessorMixin from ...utils import TensorType from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging a = logging.get_logger(__name__) a = { "google/owlvit-base-patch32": "https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json", "google/owlvit-base-patch16": "https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json", "google/owlvit-large-patch14": "https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json", } class lowercase_ ( _a ): '''simple docstring''' UpperCAmelCase : str = '''owlvit_text_model''' def __init__( self : Optional[Any] , _UpperCAmelCase : Optional[Any]=49_408 , _UpperCAmelCase : Optional[int]=512 , _UpperCAmelCase : str=2_048 , _UpperCAmelCase : int=12 , _UpperCAmelCase : Union[str, Any]=8 , _UpperCAmelCase : List[Any]=16 , _UpperCAmelCase : Any="quick_gelu" , _UpperCAmelCase : Any=1E-5 , _UpperCAmelCase : Dict=0.0 , _UpperCAmelCase : Dict=0.02 , _UpperCAmelCase : Optional[int]=1.0 , _UpperCAmelCase : Union[str, Any]=0 , _UpperCAmelCase : Dict=49_406 , _UpperCAmelCase : str=49_407 , **_UpperCAmelCase : int , ): super().__init__(pad_token_id=UpperCamelCase__ , bos_token_id=UpperCamelCase__ , eos_token_id=UpperCamelCase__ , **UpperCamelCase__ ) _A = vocab_size _A = hidden_size _A = intermediate_size _A = num_hidden_layers _A = num_attention_heads _A = max_position_embeddings _A = hidden_act _A = layer_norm_eps _A = attention_dropout _A = initializer_range _A = initializer_factor @classmethod def lowerCAmelCase_ ( cls : List[str] , _UpperCAmelCase : Union[str, os.PathLike] , **_UpperCAmelCase : List[Any] ): cls._set_token_in_kwargs(UpperCamelCase__ ) _A , _A = cls.get_config_dict(UpperCamelCase__ , **UpperCamelCase__ ) # get the text config dict if we are loading from OwlViTConfig if config_dict.get('model_type' ) == "owlvit": _A = config_dict['text_config'] if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type ''' F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(UpperCamelCase__ , **UpperCamelCase__ ) class lowercase_ ( _a ): '''simple docstring''' UpperCAmelCase : str = '''owlvit_vision_model''' def __init__( self : Optional[int] , _UpperCAmelCase : Optional[int]=768 , _UpperCAmelCase : Dict=3_072 , _UpperCAmelCase : List[str]=12 , _UpperCAmelCase : str=12 , _UpperCAmelCase : Optional[Any]=3 , _UpperCAmelCase : Union[str, Any]=768 , _UpperCAmelCase : Optional[Any]=32 , _UpperCAmelCase : List[str]="quick_gelu" , _UpperCAmelCase : str=1E-5 , _UpperCAmelCase : str=0.0 , _UpperCAmelCase : List[Any]=0.02 , _UpperCAmelCase : List[Any]=1.0 , **_UpperCAmelCase : List[str] , ): super().__init__(**UpperCamelCase__ ) _A = hidden_size _A = intermediate_size _A = num_hidden_layers _A = num_attention_heads _A = num_channels _A = image_size _A = patch_size _A = hidden_act _A = layer_norm_eps _A = attention_dropout _A = initializer_range _A = initializer_factor @classmethod def lowerCAmelCase_ ( cls : Optional[int] , _UpperCAmelCase : Union[str, os.PathLike] , **_UpperCAmelCase : str ): cls._set_token_in_kwargs(UpperCamelCase__ ) _A , _A = cls.get_config_dict(UpperCamelCase__ , **UpperCamelCase__ ) # get the vision config dict if we are loading from OwlViTConfig if config_dict.get('model_type' ) == "owlvit": _A = config_dict['vision_config'] if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type ''' F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(UpperCamelCase__ , **UpperCamelCase__ ) class lowercase_ ( _a ): '''simple docstring''' UpperCAmelCase : Union[str, Any] = '''owlvit''' UpperCAmelCase : List[str] = True def __init__( self : Dict , _UpperCAmelCase : Union[str, Any]=None , _UpperCAmelCase : Any=None , _UpperCAmelCase : str=512 , _UpperCAmelCase : List[Any]=2.6592 , _UpperCAmelCase : List[Any]=True , **_UpperCAmelCase : List[Any] , ): super().__init__(**UpperCamelCase__ ) if text_config is None: _A = {} logger.info('text_config is None. Initializing the OwlViTTextConfig with default values.' ) if vision_config is None: _A = {} logger.info('vision_config is None. initializing the OwlViTVisionConfig with default values.' ) _A = OwlViTTextConfig(**UpperCamelCase__ ) _A = OwlViTVisionConfig(**UpperCamelCase__ ) _A = projection_dim _A = logit_scale_init_value _A = return_dict _A = 1.0 @classmethod def lowerCAmelCase_ ( cls : List[str] , _UpperCAmelCase : Union[str, os.PathLike] , **_UpperCAmelCase : Dict ): cls._set_token_in_kwargs(UpperCamelCase__ ) _A , _A = cls.get_config_dict(UpperCamelCase__ , **UpperCamelCase__ ) if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type ''' F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(UpperCamelCase__ , **UpperCamelCase__ ) @classmethod def lowerCAmelCase_ ( cls : int , _UpperCAmelCase : Dict , _UpperCAmelCase : Dict , **_UpperCAmelCase : Union[str, Any] ): _A = {} _A = text_config _A = vision_config return cls.from_dict(UpperCamelCase__ , **UpperCamelCase__ ) def lowerCAmelCase_ ( self : Optional[Any] ): _A = copy.deepcopy(self.__dict__ ) _A = self.text_config.to_dict() _A = self.vision_config.to_dict() _A = self.__class__.model_type return output class lowercase_ ( _a ): '''simple docstring''' @property def lowerCAmelCase_ ( self : Any ): return OrderedDict( [ ('input_ids', {0: 'batch', 1: 'sequence'}), ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ('attention_mask', {0: 'batch', 1: 'sequence'}), ] ) @property def lowerCAmelCase_ ( self : List[str] ): return OrderedDict( [ ('logits_per_image', {0: 'batch'}), ('logits_per_text', {0: 'batch'}), ('text_embeds', {0: 'batch'}), ('image_embeds', {0: 'batch'}), ] ) @property def lowerCAmelCase_ ( self : Optional[Any] ): return 1E-4 def lowerCAmelCase_ ( self : List[Any] , _UpperCAmelCase : "ProcessorMixin" , _UpperCAmelCase : int = -1 , _UpperCAmelCase : int = -1 , _UpperCAmelCase : Optional["TensorType"] = None , ): _A = super().generate_dummy_inputs( processor.tokenizer , batch_size=UpperCamelCase__ , seq_length=UpperCamelCase__ , framework=UpperCamelCase__ ) _A = super().generate_dummy_inputs( processor.image_processor , batch_size=UpperCamelCase__ , framework=UpperCamelCase__ ) return {**text_input_dict, **image_input_dict} @property def lowerCAmelCase_ ( self : str ): return 14
315
'''simple docstring''' import math from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass # Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->UnCLIP class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = None def __lowerCamelCase ( A__ , A__=0.999 , A__="cosine" , ) -> Tuple: """simple docstring""" if alpha_transform_type == "cosine": def alpha_bar_fn(A__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(A__ ): return math.exp(t * -12.0 ) else: raise ValueError(F"""Unsupported alpha_tranform_type: {alpha_transform_type}""" ) UpperCamelCase = [] for i in range(A__ ): UpperCamelCase = i / num_diffusion_timesteps UpperCamelCase = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(A__ ) / alpha_bar_fn(A__ ) , A__ ) ) return torch.tensor(A__ , dtype=torch.floataa ) class SCREAMING_SNAKE_CASE ( _a , _a ): """simple docstring""" @register_to_config def __init__( self : List[str] , UpperCamelCase__ : int = 1_0_0_0 , UpperCamelCase__ : str = "fixed_small_log" , UpperCamelCase__ : bool = True , UpperCamelCase__ : Optional[float] = 1.0 , UpperCamelCase__ : str = "epsilon" , UpperCamelCase__ : str = "squaredcos_cap_v2" , ): """simple docstring""" if beta_schedule != "squaredcos_cap_v2": raise ValueError('UnCLIPScheduler only supports `beta_schedule`: \'squaredcos_cap_v2\'' ) UpperCamelCase = betas_for_alpha_bar(UpperCamelCase__ ) UpperCamelCase = 1.0 - self.betas UpperCamelCase = torch.cumprod(self.alphas , dim=0 ) UpperCamelCase = torch.tensor(1.0 ) # standard deviation of the initial noise distribution UpperCamelCase = 1.0 # setable values UpperCamelCase = None UpperCamelCase = torch.from_numpy(np.arange(0 , UpperCamelCase__ )[::-1].copy() ) UpperCamelCase = variance_type def A ( self : Dict , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None ): """simple docstring""" return sample def A ( self : List[str] , UpperCamelCase__ : int , UpperCamelCase__ : Union[str, torch.device] = None ): """simple docstring""" UpperCamelCase = num_inference_steps UpperCamelCase = (self.config.num_train_timesteps - 1) / (self.num_inference_steps - 1) UpperCamelCase = (np.arange(0 , UpperCamelCase__ ) * step_ratio).round()[::-1].copy().astype(np.intaa ) UpperCamelCase = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) def A ( self : Dict , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any]=None , UpperCamelCase__ : Optional[int]=None , UpperCamelCase__ : Tuple=None ): """simple docstring""" if prev_timestep is None: UpperCamelCase = t - 1 UpperCamelCase = self.alphas_cumprod[t] UpperCamelCase = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one UpperCamelCase = 1 - alpha_prod_t UpperCamelCase = 1 - alpha_prod_t_prev if prev_timestep == t - 1: UpperCamelCase = self.betas[t] else: UpperCamelCase = 1 - alpha_prod_t / alpha_prod_t_prev # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf) # and sample from it to get previous sample # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample UpperCamelCase = beta_prod_t_prev / beta_prod_t * beta if variance_type is None: UpperCamelCase = self.config.variance_type # hacks - were probably added for training stability if variance_type == "fixed_small_log": UpperCamelCase = torch.log(torch.clamp(UpperCamelCase__ , min=1E-2_0 ) ) UpperCamelCase = torch.exp(0.5 * variance ) elif variance_type == "learned_range": # NOTE difference with DDPM scheduler UpperCamelCase = variance.log() UpperCamelCase = beta.log() UpperCamelCase = (predicted_variance + 1) / 2 UpperCamelCase = frac * max_log + (1 - frac) * min_log return variance def A ( self : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None , UpperCamelCase__ : str=None , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = timestep if model_output.shape[1] == sample.shape[1] * 2 and self.variance_type == "learned_range": UpperCamelCase , UpperCamelCase = torch.split(UpperCamelCase__ , sample.shape[1] , dim=1 ) else: UpperCamelCase = None # 1. compute alphas, betas if prev_timestep is None: UpperCamelCase = t - 1 UpperCamelCase = self.alphas_cumprod[t] UpperCamelCase = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one UpperCamelCase = 1 - alpha_prod_t UpperCamelCase = 1 - alpha_prod_t_prev if prev_timestep == t - 1: UpperCamelCase = self.betas[t] UpperCamelCase = self.alphas[t] else: UpperCamelCase = 1 - alpha_prod_t / alpha_prod_t_prev UpperCamelCase = 1 - beta # 2. compute predicted original sample from predicted noise also called # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf if self.config.prediction_type == "epsilon": UpperCamelCase = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 elif self.config.prediction_type == "sample": UpperCamelCase = model_output else: raise ValueError( f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `sample`""" ' for the UnCLIPScheduler.' ) # 3. Clip "predicted x_0" if self.config.clip_sample: UpperCamelCase = torch.clamp( UpperCamelCase__ , -self.config.clip_sample_range , self.config.clip_sample_range ) # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf UpperCamelCase = (alpha_prod_t_prev ** 0.5 * beta) / beta_prod_t UpperCamelCase = alpha ** 0.5 * beta_prod_t_prev / beta_prod_t # 5. Compute predicted previous sample µ_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf UpperCamelCase = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample # 6. Add noise UpperCamelCase = 0 if t > 0: UpperCamelCase = randn_tensor( model_output.shape , dtype=model_output.dtype , generator=UpperCamelCase__ , device=model_output.device ) UpperCamelCase = self._get_variance( UpperCamelCase__ , predicted_variance=UpperCamelCase__ , prev_timestep=UpperCamelCase__ , ) if self.variance_type == "fixed_small_log": UpperCamelCase = variance elif self.variance_type == "learned_range": UpperCamelCase = (0.5 * variance).exp() else: raise ValueError( f"""variance_type given as {self.variance_type} must be one of `fixed_small_log` or `learned_range`""" ' for the UnCLIPScheduler.' ) UpperCamelCase = variance * variance_noise UpperCamelCase = pred_prev_sample + variance if not return_dict: return (pred_prev_sample,) return UnCLIPSchedulerOutput(prev_sample=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : int , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.IntTensor , ): """simple docstring""" UpperCamelCase = self.alphas_cumprod.to(device=original_samples.device , dtype=original_samples.dtype ) UpperCamelCase = timesteps.to(original_samples.device ) UpperCamelCase = alphas_cumprod[timesteps] ** 0.5 UpperCamelCase = sqrt_alpha_prod.flatten() while len(sqrt_alpha_prod.shape ) < len(original_samples.shape ): UpperCamelCase = sqrt_alpha_prod.unsqueeze(-1 ) UpperCamelCase = (1 - alphas_cumprod[timesteps]) ** 0.5 UpperCamelCase = sqrt_one_minus_alpha_prod.flatten() while len(sqrt_one_minus_alpha_prod.shape ) < len(original_samples.shape ): UpperCamelCase = sqrt_one_minus_alpha_prod.unsqueeze(-1 ) UpperCamelCase = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise return noisy_samples
28
0
import argparse import logging import pickle import random import time import numpy as np from transformers import BertTokenizer, GPTaTokenizer, RobertaTokenizer logging.basicConfig( format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", datefmt="%m/%d/%Y %H:%M:%S", level=logging.INFO ) _snake_case = logging.getLogger(__name__) def lowerCAmelCase_ ( ): _A : List[str] = argparse.ArgumentParser( description="""Preprocess the data to avoid re-doing it several times by (tokenization + token_to_ids).""" ) parser.add_argument("""--file_path""",type=A__,default="""data/dump.txt""",help="""The path to the data.""" ) parser.add_argument("""--tokenizer_type""",type=A__,default="""bert""",choices=["""bert""", """roberta""", """gpt2"""] ) parser.add_argument("""--tokenizer_name""",type=A__,default="""bert-base-uncased""",help="""The tokenizer to use.""" ) parser.add_argument("""--dump_file""",type=A__,default="""data/dump""",help="""The dump file prefix.""" ) _A : Dict = parser.parse_args() logger.info(f'''Loading Tokenizer ({args.tokenizer_name})''' ) if args.tokenizer_type == "bert": _A : Optional[Any] = BertTokenizer.from_pretrained(args.tokenizer_name ) _A : Union[str, Any] = tokenizer.special_tokens_map["""cls_token"""] # `[CLS]` _A : Tuple = tokenizer.special_tokens_map["""sep_token"""] # `[SEP]` elif args.tokenizer_type == "roberta": _A : Optional[int] = RobertaTokenizer.from_pretrained(args.tokenizer_name ) _A : Optional[int] = tokenizer.special_tokens_map["""cls_token"""] # `<s>` _A : List[str] = tokenizer.special_tokens_map["""sep_token"""] # `</s>` elif args.tokenizer_type == "gpt2": _A : Tuple = GPTaTokenizer.from_pretrained(args.tokenizer_name ) _A : Union[str, Any] = tokenizer.special_tokens_map["""bos_token"""] # `<|endoftext|>` _A : List[Any] = tokenizer.special_tokens_map["""eos_token"""] # `<|endoftext|>` logger.info(f'''Loading text from {args.file_path}''' ) with open(args.file_path,"""r""",encoding="""utf8""" ) as fp: _A : int = fp.readlines() logger.info("""Start encoding""" ) logger.info(f'''{len(A__ )} examples to process.''' ) _A : Optional[Any] = [] _A : Optional[Any] = 0 _A : str = 10000 _A : int = time.time() for text in data: _A : List[str] = f'''{bos} {text.strip()} {sep}''' _A : int = tokenizer.encode(A__,add_special_tokens=A__ ) rslt.append(A__ ) iter += 1 if iter % interval == 0: _A : List[Any] = time.time() logger.info(f'''{iter} examples processed. - {(end-start):.2f}s/{interval}expl''' ) _A : List[Any] = time.time() logger.info("""Finished binarization""" ) logger.info(f'''{len(A__ )} examples processed.''' ) _A : str = f'''{args.dump_file}.{args.tokenizer_name}.pickle''' _A : Optional[int] = tokenizer.vocab_size if vocab_size < (1 << 16): _A : Any = [np.uintaa(A__ ) for d in rslt] else: _A : int = [np.intaa(A__ ) for d in rslt] random.shuffle(rslt_ ) logger.info(f'''Dump to {dp_file}''' ) with open(A__,"""wb""" ) as handle: pickle.dump(rslt_,A__,protocol=pickle.HIGHEST_PROTOCOL ) if __name__ == "__main__": main()
26
'''simple docstring''' import inspect import unittest from transformers import ConvNextConfig 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_backbone_common import BackboneTesterMixin 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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Optional[int] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Any=1_3 , UpperCamelCase__ : Optional[int]=3_2 , UpperCamelCase__ : Any=3 , UpperCamelCase__ : Tuple=4 , UpperCamelCase__ : str=[1_0, 2_0, 3_0, 4_0] , UpperCamelCase__ : str=[2, 2, 3, 2] , UpperCamelCase__ : Dict=True , UpperCamelCase__ : List[str]=True , UpperCamelCase__ : str=3_7 , UpperCamelCase__ : Union[str, Any]="gelu" , UpperCamelCase__ : Dict=1_0 , UpperCamelCase__ : Union[str, Any]=0.0_2 , UpperCamelCase__ : int=["stage2", "stage3", "stage4"] , UpperCamelCase__ : List[str]=[2, 3, 4] , UpperCamelCase__ : Any=None , ): """simple docstring""" UpperCamelCase = parent UpperCamelCase = batch_size UpperCamelCase = image_size UpperCamelCase = num_channels UpperCamelCase = num_stages UpperCamelCase = hidden_sizes UpperCamelCase = depths UpperCamelCase = is_training UpperCamelCase = use_labels UpperCamelCase = intermediate_size UpperCamelCase = hidden_act UpperCamelCase = num_labels UpperCamelCase = initializer_range UpperCamelCase = out_features UpperCamelCase = out_indices UpperCamelCase = scope def A ( self : Union[str, Any] ): """simple docstring""" UpperCamelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCamelCase = None if self.use_labels: UpperCamelCase = ids_tensor([self.batch_size] , self.num_labels ) UpperCamelCase = self.get_config() return config, pixel_values, labels def A ( self : List[str] ): """simple docstring""" return ConvNextConfig( num_channels=self.num_channels , hidden_sizes=self.hidden_sizes , depths=self.depths , num_stages=self.num_stages , hidden_act=self.hidden_act , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , out_features=self.out_features , out_indices=self.out_indices , num_labels=self.num_labels , ) def A ( self : Union[str, Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : str ): """simple docstring""" UpperCamelCase = ConvNextModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2) , ) def A ( self : List[str] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : int ): """simple docstring""" UpperCamelCase = ConvNextForImageClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A ( self : Tuple , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : str ): """simple docstring""" UpperCamelCase = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # verify hidden states self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[1], 4, 4] ) # verify channels self.parent.assertEqual(len(model.channels ) , len(config.out_features ) ) self.parent.assertListEqual(model.channels , config.hidden_sizes[1:] ) # verify backbone works with out_features=None UpperCamelCase = None UpperCamelCase = ConvNextBackbone(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , 1 ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[-1], 1, 1] ) # verify channels self.parent.assertEqual(len(model.channels ) , 1 ) self.parent.assertListEqual(model.channels , [config.hidden_sizes[-1]] ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.prepare_config_and_inputs() UpperCamelCase , UpperCamelCase , UpperCamelCase = config_and_inputs UpperCamelCase = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE ( _a , _a , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( ConvNextModel, ConvNextForImageClassification, ConvNextBackbone, ) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE = ( {"""feature-extraction""": ConvNextModel, """image-classification""": ConvNextForImageClassification} if is_torch_available() else {} ) _SCREAMING_SNAKE_CASE = True _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False def A ( self : Tuple ): """simple docstring""" UpperCamelCase = ConvNextModelTester(self ) UpperCamelCase = ConfigTester(self , config_class=UpperCamelCase__ , has_text_modality=UpperCamelCase__ , hidden_size=3_7 ) def A ( self : List[str] ): """simple docstring""" self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def A ( self : Optional[int] ): """simple docstring""" return @unittest.skip(reason='ConvNext does not use inputs_embeds' ) def A ( self : List[str] ): """simple docstring""" pass @unittest.skip(reason='ConvNext does not support input and output embeddings' ) def A ( self : List[Any] ): """simple docstring""" pass @unittest.skip(reason='ConvNext does not use feedforward chunking' ) def A ( self : Optional[int] ): """simple docstring""" pass def A ( self : Any ): """simple docstring""" UpperCamelCase , UpperCamelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase = model_class(UpperCamelCase__ ) 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] , UpperCamelCase__ ) def A ( self : Union[str, Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : Tuple ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*UpperCamelCase__ ) def A ( self : Optional[Any] ): """simple docstring""" def check_hidden_states_output(UpperCamelCase__ : Dict , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple ): UpperCamelCase = model_class(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() with torch.no_grad(): UpperCamelCase = model(**self._prepare_for_class(UpperCamelCase__ , UpperCamelCase__ ) ) UpperCamelCase = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states UpperCamelCase = self.model_tester.num_stages self.assertEqual(len(UpperCamelCase__ ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) UpperCamelCase , UpperCamelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase = True check_hidden_states_output(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCamelCase = True check_hidden_states_output(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Dict ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ ) @slow def A ( self : Dict ): """simple docstring""" for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase = ConvNextModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) def __lowerCamelCase ( ) -> Any: """simple docstring""" UpperCamelCase = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" @cached_property def A ( self : Optional[Any] ): """simple docstring""" return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' ).to(UpperCamelCase__ ) UpperCamelCase = self.default_image_processor UpperCamelCase = prepare_img() UpperCamelCase = image_processor(images=UpperCamelCase__ , return_tensors='pt' ).to(UpperCamelCase__ ) # forward pass with torch.no_grad(): UpperCamelCase = model(**UpperCamelCase__ ) # verify the logits UpperCamelCase = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1] ).to(UpperCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , UpperCamelCase__ , atol=1E-4 ) ) @require_torch class SCREAMING_SNAKE_CASE ( unittest.TestCase , _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = (ConvNextBackbone,) if is_torch_available() else () _SCREAMING_SNAKE_CASE = ConvNextConfig _SCREAMING_SNAKE_CASE = False def A ( self : Tuple ): """simple docstring""" UpperCamelCase = ConvNextModelTester(self )
28
0
import torch from diffusers import KDPMaDiscreteScheduler from diffusers.utils import torch_device from .test_schedulers import SchedulerCommonTest class __SCREAMING_SNAKE_CASE ( _a ): _UpperCAmelCase : Tuple = (KDPMaDiscreteScheduler,) _UpperCAmelCase : Optional[Any] = 1_0 def __lowerCamelCase ( self : int , **A : Dict ) ->str: lowerCamelCase__ : Any = { '''num_train_timesteps''': 1_1_0_0, '''beta_start''': 0.00_01, '''beta_end''': 0.02, '''beta_schedule''': '''linear''', } config.update(**UpperCamelCase__ ) return config def __lowerCamelCase ( self : Dict ) ->Any: for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]: self.check_over_configs(num_train_timesteps=UpperCamelCase__ ) def __lowerCamelCase ( self : int ) ->Union[str, Any]: for beta_start, beta_end in zip([0.0_00_01, 0.00_01, 0.0_01] , [0.00_02, 0.0_02, 0.02] ): self.check_over_configs(beta_start=UpperCamelCase__ , beta_end=UpperCamelCase__ ) def __lowerCamelCase ( self : List[str] ) ->Union[str, Any]: for schedule in ["linear", "scaled_linear"]: self.check_over_configs(beta_schedule=UpperCamelCase__ ) def __lowerCamelCase ( self : Union[str, Any] ) ->Tuple: for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=UpperCamelCase__ ) def __lowerCamelCase ( self : Dict ) ->int: lowerCamelCase__ : Dict = self.scheduler_classes[0] lowerCamelCase__ : Optional[Any] = self.get_scheduler_config(prediction_type='''v_prediction''' ) lowerCamelCase__ : List[Any] = scheduler_class(**UpperCamelCase__ ) scheduler.set_timesteps(self.num_inference_steps ) lowerCamelCase__ : str = self.dummy_model() lowerCamelCase__ : Optional[Any] = self.dummy_sample_deter * scheduler.init_noise_sigma lowerCamelCase__ : Optional[Any] = sample.to(UpperCamelCase__ ) for i, t in enumerate(scheduler.timesteps ): lowerCamelCase__ : int = scheduler.scale_model_input(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : List[Any] = model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : List[Any] = scheduler.step(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : List[str] = output.prev_sample lowerCamelCase__ : int = torch.sum(torch.abs(UpperCamelCase__ ) ) lowerCamelCase__ : Optional[Any] = torch.mean(torch.abs(UpperCamelCase__ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 4.6_934e-07 ) < 1e-2 assert abs(result_mean.item() - 6.1_112e-10 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 4.693_428_650_170_972e-07 ) < 1e-2 assert abs(result_mean.item() - 0.00_02 ) < 1e-3 def __lowerCamelCase ( self : Tuple ) ->List[str]: if torch_device == "mps": return lowerCamelCase__ : Optional[int] = self.scheduler_classes[0] lowerCamelCase__ : List[str] = self.get_scheduler_config() lowerCamelCase__ : Tuple = scheduler_class(**UpperCamelCase__ ) scheduler.set_timesteps(self.num_inference_steps ) lowerCamelCase__ : str = self.dummy_model() lowerCamelCase__ : Union[str, Any] = self.dummy_sample_deter * scheduler.init_noise_sigma lowerCamelCase__ : List[str] = sample.to(UpperCamelCase__ ) for i, t in enumerate(scheduler.timesteps ): lowerCamelCase__ : str = scheduler.scale_model_input(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : Dict = model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : Tuple = scheduler.step(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : Any = output.prev_sample lowerCamelCase__ : Tuple = torch.sum(torch.abs(UpperCamelCase__ ) ) lowerCamelCase__ : Optional[int] = torch.mean(torch.abs(UpperCamelCase__ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.02_66 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.02_66 ) < 1e-3 def __lowerCamelCase ( self : str ) ->Dict: if torch_device == "mps": return lowerCamelCase__ : Optional[Any] = self.scheduler_classes[0] lowerCamelCase__ : Tuple = self.get_scheduler_config() lowerCamelCase__ : str = scheduler_class(**UpperCamelCase__ ) scheduler.set_timesteps(self.num_inference_steps , device=UpperCamelCase__ ) lowerCamelCase__ : Optional[int] = self.dummy_model() lowerCamelCase__ : Tuple = self.dummy_sample_deter.to(UpperCamelCase__ ) * scheduler.init_noise_sigma for t in scheduler.timesteps: lowerCamelCase__ : Tuple = scheduler.scale_model_input(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : Union[str, Any] = model(UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : str = scheduler.step(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) lowerCamelCase__ : Optional[int] = output.prev_sample lowerCamelCase__ : Optional[Any] = torch.sum(torch.abs(UpperCamelCase__ ) ) lowerCamelCase__ : str = torch.mean(torch.abs(UpperCamelCase__ ) ) if str(UpperCamelCase__ ).startswith('''cpu''' ): # The following sum varies between 148 and 156 on mps. Why? assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.02_66 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.02_66 ) < 1e-3
142
'''simple docstring''' import argparse from collections import OrderedDict from pathlib import Path import torch from huggingface_hub import hf_hub_download from PIL import Image from torchvision.transforms import functional as F from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : int = logging.get_logger(__name__) # here we list all keys to be renamed (original name on the left, our name on the right) _lowerCamelCase : int = [] for i in range(6): # 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 encoder + 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.encoder.norm.weight", "encoder.layernorm.weight"), ("transformer.encoder.norm.bias", "encoder.layernorm.bias"), ("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"), ] ) def __lowerCamelCase ( A__ , A__ , A__ ) -> Dict: """simple docstring""" UpperCamelCase = state_dict.pop(A__ ) UpperCamelCase = val def __lowerCamelCase ( A__ ) -> int: """simple docstring""" UpperCamelCase = OrderedDict() for key, value in state_dict.items(): if "backbone.0.body" in key: UpperCamelCase = key.replace('backbone.0.body' , 'backbone.conv_encoder.model' ) UpperCamelCase = value else: UpperCamelCase = value return new_state_dict def __lowerCamelCase ( A__ ) -> Dict: """simple docstring""" UpperCamelCase = '' # 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[:256, :] UpperCamelCase = in_proj_bias[:256] UpperCamelCase = in_proj_weight[256:512, :] UpperCamelCase = in_proj_bias[256:512] UpperCamelCase = in_proj_weight[-256:, :] UpperCamelCase = in_proj_bias[-256:] # 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[:256, :] UpperCamelCase = in_proj_bias[:256] UpperCamelCase = in_proj_weight[256:512, :] UpperCamelCase = in_proj_bias[256:512] UpperCamelCase = in_proj_weight[-256:, :] UpperCamelCase = in_proj_bias[-256:] # 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[:256, :] UpperCamelCase = in_proj_bias_cross_attn[:256] UpperCamelCase = in_proj_weight_cross_attn[256:512, :] UpperCamelCase = in_proj_bias_cross_attn[256:512] UpperCamelCase = in_proj_weight_cross_attn[-256:, :] UpperCamelCase = in_proj_bias_cross_attn[-256:] def __lowerCamelCase ( A__ , A__ ) -> Optional[int]: """simple docstring""" UpperCamelCase , UpperCamelCase = image.size UpperCamelCase = max(A__ , A__ ) UpperCamelCase = 800 if 'detection' in checkpoint_url else 1_000 UpperCamelCase = target_max_size / current_max_size UpperCamelCase = image.resize((int(round(scale * width ) ), int(round(scale * height ) )) ) return resized_image def __lowerCamelCase ( A__ ) -> List[Any]: """simple docstring""" UpperCamelCase = F.to_tensor(A__ ) UpperCamelCase = F.normalize(A__ , mean=[0.485, 0.456, 0.406] , std=[0.229, 0.224, 0.225] ) return image @torch.no_grad() def __lowerCamelCase ( A__ , A__ , A__ ) -> Optional[Any]: """simple docstring""" logger.info('Converting model...' ) # load original state dict UpperCamelCase = torch.hub.load_state_dict_from_url(A__ , map_location='cpu' ) # rename keys for src, dest in rename_keys: rename_key(A__ , A__ , A__ ) UpperCamelCase = rename_backbone_keys(A__ ) # query, key and value matrices need special treatment read_in_q_k_v(A__ ) # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them UpperCamelCase = 'model.' for key in state_dict.copy().keys(): if not key.startswith('class_labels_classifier' ) and not key.startswith('bbox_predictor' ): UpperCamelCase = state_dict.pop(A__ ) UpperCamelCase = val # create HuggingFace model and load state dict UpperCamelCase = TableTransformerConfig( backbone='resnet18' , mask_loss_coefficient=1 , dice_loss_coefficient=1 , ce_loss_coefficient=1 , bbox_loss_coefficient=5 , giou_loss_coefficient=2 , eos_coefficient=0.4 , class_cost=1 , bbox_cost=5 , giou_cost=2 , ) if "detection" in checkpoint_url: UpperCamelCase = 15 UpperCamelCase = 2 UpperCamelCase = {0: 'table', 1: 'table rotated'} UpperCamelCase = idalabel UpperCamelCase = {v: k for k, v in idalabel.items()} else: UpperCamelCase = 125 UpperCamelCase = 6 UpperCamelCase = { 0: 'table', 1: 'table column', 2: 'table row', 3: 'table column header', 4: 'table projected row header', 5: 'table spanning cell', } UpperCamelCase = idalabel UpperCamelCase = {v: k for k, v in idalabel.items()} UpperCamelCase = DetrImageProcessor( format='coco_detection' , max_size=800 if 'detection' in checkpoint_url else 1_000 ) UpperCamelCase = TableTransformerForObjectDetection(A__ ) model.load_state_dict(A__ ) model.eval() # verify our conversion UpperCamelCase = 'example_pdf.png' if 'detection' in checkpoint_url else 'example_table.png' UpperCamelCase = hf_hub_download(repo_id='nielsr/example-pdf' , repo_type='dataset' , filename=A__ ) UpperCamelCase = Image.open(A__ ).convert('RGB' ) UpperCamelCase = normalize(resize(A__ , A__ ) ).unsqueeze(0 ) UpperCamelCase = model(A__ ) if "detection" in checkpoint_url: UpperCamelCase = (1, 15, 3) UpperCamelCase = torch.tensor( [[-6.7_897, -16.9_985, 6.7_937], [-8.0_186, -22.2_192, 6.9_677], [-7.3_117, -21.0_708, 7.4_055]] ) UpperCamelCase = torch.tensor([[0.4_867, 0.1_767, 0.6_732], [0.6_718, 0.4_479, 0.3_830], [0.4_716, 0.1_760, 0.6_364]] ) else: UpperCamelCase = (1, 125, 7) UpperCamelCase = torch.tensor( [[-18.1_430, -8.3_214, 4.8_274], [-18.4_685, -7.1_361, -4.2_667], [-26.3_693, -9.3_429, -4.9_962]] ) UpperCamelCase = torch.tensor([[0.4_983, 0.5_595, 0.9_440], [0.4_916, 0.6_315, 0.5_954], [0.6_108, 0.8_637, 0.1_135]] ) assert outputs.logits.shape == expected_shape assert torch.allclose(outputs.logits[0, :3, :3] , A__ , atol=1e-4 ) assert torch.allclose(outputs.pred_boxes[0, :3, :3] , A__ , 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(A__ ).mkdir(exist_ok=A__ ) model.save_pretrained(A__ ) image_processor.save_pretrained(A__ ) if push_to_hub: # Push model to HF hub logger.info('Pushing model to the hub...' ) UpperCamelCase = ( 'microsoft/table-transformer-detection' if 'detection' in checkpoint_url else 'microsoft/table-transformer-structure-recognition' ) model.push_to_hub(A__ ) image_processor.push_to_hub(A__ ) if __name__ == "__main__": _lowerCamelCase : List[str] = argparse.ArgumentParser() parser.add_argument( "--checkpoint_url", default="https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth", type=str, choices=[ "https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth", "https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth", ], help="URL of the Table Transformer checkpoint 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 or not to push the converted model to the 🤗 hub." ) _lowerCamelCase : int = parser.parse_args() convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
28
0
'''simple docstring''' from __future__ import annotations def A__ ( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , ): _UpperCamelCase : Optional[Any] = len(A__ ) # If row is equal to the size of the board it means there are a queen in each row in # the current board (possible_board) if row == n: # We convert the variable possible_board that looks like this: [1, 3, 0, 2] to # this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . '] boards.append(['. ' * i + 'Q ' + '. ' * (n - 1 - i) for i in possible_board] ) return # We iterate each column in the row to find all possible results in each row for col in range(A__ ): # We apply that we learned previously. First we check that in the current board # (possible_board) there are not other same value because if there is it means # that there are a collision in vertical. Then we apply the two formulas we # learned before: # # 45º: y - x = b or 45: row - col = b # 135º: y + x = b or row + col = b. # # And we verify if the results of this two formulas not exist in their variables # respectively. (diagonal_right_collisions, diagonal_left_collisions) # # If any or these are True it means there is a collision so we continue to the # next value in the for loop. if ( col in possible_board or row - col in diagonal_right_collisions or row + col in diagonal_left_collisions ): continue # If it is False we call dfs function again and we update the inputs depth_first_search( [*possible_board, col] , [*diagonal_right_collisions, row - col] , [*diagonal_left_collisions, row + col] , A__ , A__ , ) def A__ ( UpperCAmelCase_ ): _UpperCamelCase : Tuple = [] depth_first_search([] , [] , [] , A__ , A__ ) # Print all the boards for board in boards: for column in board: print(A__ ) print('' ) print(len(A__ ) , 'solutions were found.' ) if __name__ == "__main__": import doctest doctest.testmod() n_queens_solution(4)
83
'''simple docstring''' from io import BytesIO from typing import List, Union import requests from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_decord_available(): import numpy as np from decord import VideoReader if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING _lowerCamelCase : Any = logging.get_logger(__name__) @add_end_docstrings(_a ) class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" def __init__( self : Any , *UpperCamelCase__ : Dict , **UpperCamelCase__ : Union[str, Any] ): """simple docstring""" super().__init__(*UpperCamelCase__ , **UpperCamelCase__ ) requires_backends(self , 'decord' ) self.check_model_type(UpperCamelCase__ ) def A ( self : Optional[int] , UpperCamelCase__ : Optional[int]=None , UpperCamelCase__ : Optional[Any]=None , UpperCamelCase__ : Optional[Any]=None ): """simple docstring""" UpperCamelCase = {} if frame_sampling_rate is not None: UpperCamelCase = frame_sampling_rate if num_frames is not None: UpperCamelCase = num_frames UpperCamelCase = {} if top_k is not None: UpperCamelCase = top_k return preprocess_params, {}, postprocess_params def __call__( self : List[str] , UpperCamelCase__ : Union[str, List[str]] , **UpperCamelCase__ : Dict ): """simple docstring""" return super().__call__(UpperCamelCase__ , **UpperCamelCase__ ) def A ( self : Tuple , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple=None , UpperCamelCase__ : Tuple=1 ): """simple docstring""" if num_frames is None: UpperCamelCase = self.model.config.num_frames if video.startswith('http://' ) or video.startswith('https://' ): UpperCamelCase = BytesIO(requests.get(UpperCamelCase__ ).content ) UpperCamelCase = VideoReader(UpperCamelCase__ ) videoreader.seek(0 ) UpperCamelCase = 0 UpperCamelCase = num_frames * frame_sampling_rate - 1 UpperCamelCase = np.linspace(UpperCamelCase__ , UpperCamelCase__ , num=UpperCamelCase__ , dtype=np.intaa ) UpperCamelCase = videoreader.get_batch(UpperCamelCase__ ).asnumpy() UpperCamelCase = list(UpperCamelCase__ ) UpperCamelCase = self.image_processor(UpperCamelCase__ , return_tensors=self.framework ) return model_inputs def A ( self : Union[str, Any] , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = self.model(**UpperCamelCase__ ) return model_outputs def A ( self : int , UpperCamelCase__ : str , UpperCamelCase__ : List[Any]=5 ): """simple docstring""" if top_k > self.model.config.num_labels: UpperCamelCase = self.model.config.num_labels if self.framework == "pt": UpperCamelCase = model_outputs.logits.softmax(-1 )[0] UpperCamelCase , UpperCamelCase = probs.topk(UpperCamelCase__ ) else: raise ValueError(f"""Unsupported framework: {self.framework}""" ) UpperCamelCase = scores.tolist() UpperCamelCase = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(UpperCamelCase__ , UpperCamelCase__ )]
28
0
from PIL import Image def _a ( SCREAMING_SNAKE_CASE : Optional[Any] , SCREAMING_SNAKE_CASE : List[Any] ) -> Image: """simple docstring""" def brightness(SCREAMING_SNAKE_CASE : int ) -> float: return 1_28 + level + (c - 1_28) if not -2_5_5.0 <= level <= 2_5_5.0: raise ValueError('level must be between -255.0 (black) and 255.0 (white)' ) return img.point(A__ ) if __name__ == "__main__": # Load image with Image.open('''image_data/lena.jpg''') as img: # Change brightness to 100 _a = change_brightness(img, 1_0_0) brigt_img.save('''image_data/lena_brightness.png''', format='''png''')
322
'''simple docstring''' import os from itertools import chain from random import randrange, shuffle import pytest from .sola import PokerHand _lowerCamelCase : Optional[int] = ( "4S 3H 2C 7S 5H", "9D 8H 2C 6S 7H", "2D 6D 9D TH 7D", "TC 8C 2S JH 6C", "JH 8S TH AH QH", "TS KS 5S 9S AC", "KD 6S 9D TH AD", "KS 8D 4D 9S 4S", # pair "8C 4S KH JS 4D", # pair "QH 8H KD JH 8S", # pair "KC 4H KS 2H 8D", # pair "KD 4S KC 3H 8S", # pair "AH 8S AS KC JH", # pair "3H 4C 4H 3S 2H", # 2 pairs "5S 5D 2C KH KH", # 2 pairs "3C KH 5D 5S KH", # 2 pairs "AS 3C KH AD KH", # 2 pairs "7C 7S 3S 7H 5S", # 3 of a kind "7C 7S KH 2H 7H", # 3 of a kind "AC KH QH AH AS", # 3 of a kind "2H 4D 3C AS 5S", # straight (low ace) "3C 5C 4C 2C 6H", # straight "6S 8S 7S 5H 9H", # straight "JS QS 9H TS KH", # straight "QC KH TS JS AH", # straight (high ace) "8C 9C 5C 3C TC", # flush "3S 8S 9S 5S KS", # flush "4C 5C 9C 8C KC", # flush "JH 8H AH KH QH", # flush "3D 2H 3H 2C 2D", # full house "2H 2C 3S 3H 3D", # full house "KH KC 3S 3H 3D", # full house "JC 6H JS JD JH", # 4 of a kind "JC 7H JS JD JH", # 4 of a kind "JC KH JS JD JH", # 4 of a kind "2S AS 4S 5S 3S", # straight flush (low ace) "2D 6D 3D 4D 5D", # straight flush "5C 6C 3C 7C 4C", # straight flush "JH 9H TH KH QH", # straight flush "JH AH TH KH QH", # royal flush (high ace straight flush) ) _lowerCamelCase : Union[str, Any] = ( ("2H 3H 4H 5H 6H", "KS AS TS QS JS", "Loss"), ("2H 3H 4H 5H 6H", "AS AD AC AH JD", "Win"), ("AS AH 2H AD AC", "JS JD JC JH 3D", "Win"), ("2S AH 2H AS AC", "JS JD JC JH AD", "Loss"), ("2S AH 2H AS AC", "2H 3H 5H 6H 7H", "Win"), ("AS 3S 4S 8S 2S", "2H 3H 5H 6H 7H", "Win"), ("2H 3H 5H 6H 7H", "2S 3H 4H 5S 6C", "Win"), ("2S 3H 4H 5S 6C", "3D 4C 5H 6H 2S", "Tie"), ("2S 3H 4H 5S 6C", "AH AC 5H 6H AS", "Win"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H AS", "Loss"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H 7S", "Win"), ("6S AD 7H 4S AS", "AH AC 5H 6H 7S", "Loss"), ("2S AH 4H 5S KC", "AH AC 5H 6H 7S", "Loss"), ("2S 3H 6H 7S 9C", "7H 3C TH 6H 9S", "Loss"), ("4S 5H 6H TS AC", "3S 5H 6H TS AC", "Win"), ("2S AH 4H 5S 6C", "AD 4C 5H 6H 2C", "Tie"), ("AS AH 3H AD AC", "AS AH 2H AD AC", "Win"), ("AH AC 5H 5C QS", "AH AC 5H 5C KS", "Loss"), ("AH AC 5H 5C QS", "KH KC 5H 5C QS", "Win"), ("7C 7S KH 2H 7H", "3C 3S AH 2H 3H", "Win"), ("3C 3S AH 2H 3H", "7C 7S KH 2H 7H", "Loss"), ("6H 5H 4H 3H 2H", "5H 4H 3H 2H AH", "Win"), ("5H 4H 3H 2H AH", "5H 4H 3H 2H AH", "Tie"), ("5H 4H 3H 2H AH", "6H 5H 4H 3H 2H", "Loss"), ("AH AD KS KC AC", "AH KD KH AC KC", "Win"), ("2H 4D 3C AS 5S", "2H 4D 3C 6S 5S", "Loss"), ("2H 3S 3C 3H 2S", "3S 3C 2S 2H 2D", "Win"), ("4D 6D 5D 2D JH", "3S 8S 3H TC KH", "Loss"), ("4S 6C 8S 3S 7S", "AD KS 2D 7D 7C", "Loss"), ("6S 4C 7H 8C 3H", "5H JC AH 9D 9C", "Loss"), ("9D 9H JH TC QH", "3C 2S JS 5C 7H", "Win"), ("2H TC 8S AD 9S", "4H TS 7H 2C 5C", "Win"), ("9D 3S 2C 7S 7C", "JC TD 3C TC 9H", "Loss"), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", True), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", False), ("AS 3S 4S 8S 2S", True), ) _lowerCamelCase : Dict = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", False), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", True), ) _lowerCamelCase : Optional[Any] = ( ("2H 4D 3C AS 5S", True, [5, 4, 3, 2, 14]), ("2H 5D 3C AS 5S", False, [14, 5, 5, 3, 2]), ("JH QD KC AS TS", False, [14, 13, 12, 11, 10]), ("9D 3S 2C 7S 7C", False, [9, 7, 7, 3, 2]), ) _lowerCamelCase : List[Any] = ( ("JH AH TH KH QH", 0), ("JH 9H TH KH QH", 0), ("JC KH JS JD JH", 7), ("KH KC 3S 3H 3D", 6), ("8C 9C 5C 3C TC", 0), ("JS QS 9H TS KH", 0), ("7C 7S KH 2H 7H", 3), ("3C KH 5D 5S KH", 2), ("QH 8H KD JH 8S", 1), ("2D 6D 9D TH 7D", 0), ) _lowerCamelCase : List[str] = ( ("JH AH TH KH QH", 23), ("JH 9H TH KH QH", 22), ("JC KH JS JD JH", 21), ("KH KC 3S 3H 3D", 20), ("8C 9C 5C 3C TC", 19), ("JS QS 9H TS KH", 18), ("7C 7S KH 2H 7H", 17), ("3C KH 5D 5S KH", 16), ("QH 8H KD JH 8S", 15), ("2D 6D 9D TH 7D", 14), ) def __lowerCamelCase ( ) -> Optional[Any]: """simple docstring""" UpperCamelCase , UpperCamelCase = randrange(len(A__ ) ), randrange(len(A__ ) ) UpperCamelCase = ['Loss', 'Tie', 'Win'][(play >= oppo) + (play > oppo)] UpperCamelCase , UpperCamelCase = SORTED_HANDS[play], SORTED_HANDS[oppo] return hand, other, expected def __lowerCamelCase ( A__ = 100 ) -> Optional[Any]: """simple docstring""" return (generate_random_hand() for _ in range(A__ )) @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_flush() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" assert PokerHand(A__ )._is_straight() == expected @pytest.mark.parametrize('hand, expected, card_values' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> str: """simple docstring""" UpperCamelCase = PokerHand(A__ ) assert player._is_five_high_straight() == expected assert player._card_values == card_values @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> Dict: """simple docstring""" assert PokerHand(A__ )._is_same_kind() == expected @pytest.mark.parametrize('hand, expected' , A__ ) def __lowerCamelCase ( A__ , A__ ) -> str: """simple docstring""" assert PokerHand(A__ )._hand_type == expected @pytest.mark.parametrize('hand, other, expected' , A__ ) def __lowerCamelCase ( A__ , A__ , A__ ) -> Tuple: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected @pytest.mark.parametrize('hand, other, expected' , generate_random_hands() ) def __lowerCamelCase ( A__ , A__ , A__ ) -> List[str]: """simple docstring""" assert PokerHand(A__ ).compare_with(PokerHand(A__ ) ) == expected def __lowerCamelCase ( ) -> str: """simple docstring""" UpperCamelCase = [PokerHand(A__ ) for hand in SORTED_HANDS] UpperCamelCase = poker_hands.copy() shuffle(A__ ) UpperCamelCase = chain(sorted(A__ ) ) for index, hand in enumerate(A__ ): assert hand == poker_hands[index] def __lowerCamelCase ( ) -> Optional[int]: """simple docstring""" # Test that five high straights are compared correctly. UpperCamelCase = [PokerHand('2D AC 3H 4H 5S' ), PokerHand('2S 3H 4H 5S 6C' )] pokerhands.sort(reverse=A__ ) assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C" def __lowerCamelCase ( ) -> str: """simple docstring""" # Multiple calls to five_high_straight function should still return True # and shouldn't mutate the list in every call other than the first. UpperCamelCase = PokerHand('2C 4S AS 3D 5C' ) UpperCamelCase = True UpperCamelCase = [5, 4, 3, 2, 14] for _ in range(10 ): assert pokerhand._is_five_high_straight() == expected assert pokerhand._card_values == expected_card_values def __lowerCamelCase ( ) -> List[str]: """simple docstring""" # Problem number 54 from Project Euler # Testing from poker_hands.txt file UpperCamelCase = 0 UpperCamelCase = os.path.abspath(os.path.dirname(A__ ) ) UpperCamelCase = os.path.join(A__ , 'poker_hands.txt' ) with open(A__ ) as file_hand: for line in file_hand: UpperCamelCase = line[:14].strip() UpperCamelCase = line[15:].strip() UpperCamelCase , UpperCamelCase = PokerHand(A__ ), PokerHand(A__ ) UpperCamelCase = player.compare_with(A__ ) if output == "Win": answer += 1 assert answer == 376
28
0
"""simple docstring""" from ...utils import is_torch_available, is_transformers_available if is_transformers_available() and is_torch_available(): from .pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings, VQDiffusionPipeline
72
'''simple docstring''' from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = None class SCREAMING_SNAKE_CASE ( _a , _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = 2 @register_to_config def __init__( self : Union[str, Any] , UpperCamelCase__ : float = 0.0_2 , UpperCamelCase__ : float = 1_0_0 , UpperCamelCase__ : float = 1.0_0_7 , UpperCamelCase__ : float = 8_0 , UpperCamelCase__ : float = 0.0_5 , UpperCamelCase__ : float = 5_0 , ): """simple docstring""" UpperCamelCase = sigma_max # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : Optional[int] = None ): """simple docstring""" return sample def A ( self : Union[str, Any] , UpperCamelCase__ : int , UpperCamelCase__ : Union[str, torch.device] = None ): """simple docstring""" UpperCamelCase = num_inference_steps UpperCamelCase = np.arange(0 , self.num_inference_steps )[::-1].copy() UpperCamelCase = torch.from_numpy(UpperCamelCase__ ).to(UpperCamelCase__ ) UpperCamelCase = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in self.timesteps ] UpperCamelCase = torch.tensor(UpperCamelCase__ , dtype=torch.floataa , device=UpperCamelCase__ ) def A ( self : Dict , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : Optional[torch.Generator] = None ): """simple docstring""" if self.config.s_min <= sigma <= self.config.s_max: UpperCamelCase = min(self.config.s_churn / self.num_inference_steps , 2**0.5 - 1 ) else: UpperCamelCase = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCamelCase = self.config.s_noise * randn_tensor(sample.shape , generator=UpperCamelCase__ ).to(sample.device ) UpperCamelCase = sigma + gamma * sigma UpperCamelCase = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def A ( self : str , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_hat + sigma_hat * model_output UpperCamelCase = (sample_hat - pred_original_sample) / sigma_hat UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : List[Any] , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : float , UpperCamelCase__ : float , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : torch.FloatTensor , UpperCamelCase__ : bool = True , ): """simple docstring""" UpperCamelCase = sample_prev + sigma_prev * model_output UpperCamelCase = (sample_prev - pred_original_sample) / sigma_prev UpperCamelCase = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative) return KarrasVeOutput( prev_sample=UpperCamelCase__ , derivative=UpperCamelCase__ , pred_original_sample=UpperCamelCase__ ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : int , UpperCamelCase__ : str ): """simple docstring""" raise NotImplementedError()
28
0
import platform from argparse import ArgumentParser import huggingface_hub from .. import __version__ as version from ..utils import is_accelerate_available, is_torch_available, is_transformers_available, is_xformers_available from . import BaseDiffusersCLICommand def _UpperCAmelCase ( a__): '''simple docstring''' return EnvironmentCommand() class A__(_a ): """simple docstring""" @staticmethod def UpperCamelCase__ ( _lowercase ) -> Optional[Any]: a_ : List[Any] = parser.add_parser("""env""" ) download_parser.set_defaults(func=UpperCamelCase__ ) def UpperCamelCase__ ( self ) -> str: a_ : List[str] = huggingface_hub.__version__ a_ : List[str] = """not installed""" a_ : Union[str, Any] = """NA""" if is_torch_available(): import torch a_ : Any = torch.__version__ a_ : List[str] = torch.cuda.is_available() a_ : Tuple = """not installed""" if is_transformers_available(): import transformers a_ : str = transformers.__version__ a_ : Tuple = """not installed""" if is_accelerate_available(): import accelerate a_ : Optional[Any] = accelerate.__version__ a_ : int = """not installed""" if is_xformers_available(): import xformers a_ : str = xformers.__version__ a_ : List[str] = { """`diffusers` version""": version, """Platform""": platform.platform(), """Python version""": platform.python_version(), """PyTorch version (GPU?)""": F'''{pt_version} ({pt_cuda_available})''', """Huggingface_hub version""": hub_version, """Transformers version""": transformers_version, """Accelerate version""": accelerate_version, """xFormers version""": xformers_version, """Using GPU in script?""": """<fill in>""", """Using distributed or parallel set-up in script?""": """<fill in>""", } print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n""" ) print(self.format_dict(UpperCamelCase__ ) ) return info @staticmethod def UpperCamelCase__ ( _lowercase ) -> Optional[int]: return "\n".join([F'''- {prop}: {val}''' for prop, val in d.items()] ) + "\n"
248
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available _lowerCamelCase : Tuple = {"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Dict = [ "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "IBertForMaskedLM", "IBertForMultipleChoice", "IBertForQuestionAnswering", "IBertForSequenceClassification", "IBertForTokenClassification", "IBertModel", "IBertPreTrainedModel", ] if TYPE_CHECKING: from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ibert import ( IBERT_PRETRAINED_MODEL_ARCHIVE_LIST, IBertForMaskedLM, IBertForMultipleChoice, IBertForQuestionAnswering, IBertForSequenceClassification, IBertForTokenClassification, IBertModel, IBertPreTrainedModel, ) else: import sys _lowerCamelCase : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
import numpy as np from sklearn.datasets import fetch_california_housing from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.model_selection import train_test_split from xgboost import XGBRegressor def SCREAMING_SNAKE_CASE__ ( __a ): return (data["data"], data["target"]) def SCREAMING_SNAKE_CASE__ ( __a , __a , __a ): snake_case_ : Optional[Any] = XGBRegressor(verbosity=0 , random_state=42 ) xgb.fit(A__ , A__ ) # Predict target for test data snake_case_ : List[Any] = xgb.predict(A__ ) snake_case_ : List[str] = predictions.reshape(len(A__ ) , 1 ) return predictions def SCREAMING_SNAKE_CASE__ ( ): snake_case_ : Any = fetch_california_housing() snake_case_ ,snake_case_ : Dict = data_handling(A__ ) snake_case_ ,snake_case_ ,snake_case_ ,snake_case_ : Union[str, Any] = train_test_split( A__ , A__ , test_size=0.25 , random_state=1 ) snake_case_ : Tuple = xgboost(A__ , A__ , A__ ) # Error printing print(f"""Mean Absolute Error : {mean_absolute_error(A__ , A__ )}""" ) print(f"""Mean Square Error : {mean_squared_error(A__ , A__ )}""" ) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
327
'''simple docstring''' def __lowerCamelCase ( A__ = 10**9 ) -> int: """simple docstring""" UpperCamelCase = 1 UpperCamelCase = 2 UpperCamelCase = 0 UpperCamelCase = 0 UpperCamelCase = 0 while perimeter <= max_perimeter: perimeters_sum += perimeter prev_value += 2 * value value += prev_value UpperCamelCase = 2 * value + 2 if i % 2 == 0 else 2 * value - 2 i += 1 return perimeters_sum if __name__ == "__main__": print(f'''{solution() = }''')
28
0
import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration _snake_case = 5_0000 _snake_case = 5000 _snake_case = os.path.split(__file__) _snake_case = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json")) @get_duration def A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' for i in range(A__ ): _lowerCAmelCase : List[Any] = dataset[i] @get_duration def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' for i in range(0 , len(A__ ) , A__ ): _lowerCAmelCase : Dict = dataset[i : i + batch_size] @get_duration def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' with dataset.formatted_as(type=A__ ): for i in range(A__ ): _lowerCAmelCase : List[Any] = dataset[i] @get_duration def A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' with dataset.formatted_as(type=A__ ): for i in range(0 , A__ , A__ ): _lowerCAmelCase : List[Any] = dataset[i : i + batch_size] def A ( ): '''simple docstring''' _lowerCAmelCase : Dict = {"num examples": SPEED_TEST_N_EXAMPLES} _lowerCAmelCase : List[Any] = [ (read, {"length": SMALL_TEST}), (read, {"length": SPEED_TEST_N_EXAMPLES}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1_000}), (read_formatted, {"type": "numpy", "length": SMALL_TEST}), (read_formatted, {"type": "pandas", "length": SMALL_TEST}), (read_formatted, {"type": "torch", "length": SMALL_TEST}), (read_formatted, {"type": "tensorflow", "length": SMALL_TEST}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1_000}), ] _lowerCAmelCase : str = [ (read, {"length": SMALL_TEST}), (read, {"length": SPEED_TEST_N_EXAMPLES}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1_000}), (read_formatted, {"type": "numpy", "length": SMALL_TEST}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1_000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print("generating dataset" ) _lowerCAmelCase : str = datasets.Features( {"list": datasets.Sequence(datasets.Value("float32" ) ), "numbers": datasets.Value("float32" )} ) _lowerCAmelCase : int = generate_example_dataset( os.path.join(A__ , "dataset.arrow" ) , A__ , num_examples=A__ , seq_shapes={"list": (100,)} , ) print("first set of iterations" ) for func, kwargs in functions: print(func.__name__ , str(A__ ) ) _lowerCAmelCase : Union[str, Any] = func(A__ , **A__ ) print("shuffling dataset" ) _lowerCAmelCase : Union[str, Any] = dataset.shuffle() print("Second set of iterations (after shuffling" ) for func, kwargs in functions_shuffled: print("shuffled " , func.__name__ , str(A__ ) ) _lowerCAmelCase : List[str] = func( A__ , **A__ ) with open(A__ , "wb" ) as f: f.write(json.dumps(A__ ).encode("utf-8" ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
36
'''simple docstring''' import math class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Union[str, Any] , UpperCamelCase__ : Optional[Any]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" UpperCamelCase = n UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # adjacency matrix for weight UpperCamelCase = [ [math.inf for j in range(0 , UpperCamelCase__ )] for i in range(0 , UpperCamelCase__ ) ] # dp[i][j] stores minimum distance from i to j def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = w def A ( self : str ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): UpperCamelCase = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def A ( self : Optional[Any] , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": _lowerCamelCase : List[str] = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
28
0
import json import os import subprocess import unittest from ast import literal_eval import pytest from parameterized import parameterized, parameterized_class from . import is_sagemaker_available if is_sagemaker_available(): from sagemaker import Session, TrainingJobAnalytics from sagemaker.huggingface import HuggingFace @pytest.mark.skipif( literal_eval(os.getenv('''TEST_SAGEMAKER''' , '''False''' ) ) is not True , reason='''Skipping test because should only be run when releasing minor transformers version''' , ) @pytest.mark.usefixtures('''sm_env''' ) @parameterized_class( [ { '''framework''': '''pytorch''', '''script''': '''run_glue_model_parallelism.py''', '''model_name_or_path''': '''roberta-large''', '''instance_type''': '''ml.p3dn.24xlarge''', '''results''': {'''train_runtime''': 1_600, '''eval_accuracy''': 0.3, '''eval_loss''': 1.2}, }, { '''framework''': '''pytorch''', '''script''': '''run_glue.py''', '''model_name_or_path''': '''roberta-large''', '''instance_type''': '''ml.p3dn.24xlarge''', '''results''': {'''train_runtime''': 1_600, '''eval_accuracy''': 0.3, '''eval_loss''': 1.2}, }, ] ) class A ( unittest.TestCase ): def _A (self ): if self.framework == "pytorch": subprocess.run( f'cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py'.split() , encoding='utf-8' , check=UpperCamelCase__ , ) assert hasattr(self , 'env' ) def _A (self , lowerCAmelCase ): __lowercase= { 'enabled': True, 'processes_per_host': 8, } __lowercase= { 'enabled': True, 'parameters': { 'microbatches': 4, 'placement_strategy': 'spread', 'pipeline': 'interleaved', 'optimize': 'speed', 'partitions': 4, 'ddp': True, }, } __lowercase= {'smdistributed': {'modelparallel': smp_options}, 'mpi': mpi_options} __lowercase= 'trainer' if self.script == 'run_glue.py' else 'smtrainer' # creates estimator return HuggingFace( entry_point=self.script , source_dir=self.env.test_path , role=self.env.role , image_uri=self.env.image_uri , base_job_name=f'{self.env.base_job_name}-{instance_count}-smp-{name_extension}' , instance_count=UpperCamelCase__ , instance_type=self.instance_type , debugger_hook_config=UpperCamelCase__ , hyperparameters={ **self.env.hyperparameters, 'model_name_or_path': self.model_name_or_path, 'max_steps': 5_0_0, } , metric_definitions=self.env.metric_definitions , distribution=UpperCamelCase__ , py_version='py36' , ) def _A (self , lowerCAmelCase ): TrainingJobAnalytics(UpperCamelCase__ ).export_csv(f'{self.env.test_path}/{job_name}_metrics.csv' ) @parameterized.expand([(1,)] ) def _A (self , lowerCAmelCase ): __lowercase= self.create_estimator(UpperCamelCase__ ) # run training estimator.fit() # result dataframe __lowercase= TrainingJobAnalytics(estimator.latest_training_job.name ).dataframe() # extract kpis __lowercase= list(result_metrics_df[result_metrics_df.metric_name == 'eval_accuracy']['value'] ) __lowercase= list(result_metrics_df[result_metrics_df.metric_name == 'eval_loss']['value'] ) # get train time from SageMaker job, this includes starting, preprocessing, stopping __lowercase= ( Session().describe_training_job(estimator.latest_training_job.name ).get('TrainingTimeInSeconds' , 9_9_9_9_9_9 ) ) # assert kpis assert train_runtime <= self.results["train_runtime"] assert all(t >= self.results['eval_accuracy'] for t in eval_accuracy ) assert all(t <= self.results['eval_loss'] for t in eval_loss ) # dump tests result into json file to share in PR with open(f'{estimator.latest_training_job.name}.json' , 'w' ) as outfile: json.dump({'train_time': train_runtime, 'eval_accuracy': eval_accuracy, 'eval_loss': eval_loss} , UpperCamelCase__ )
295
'''simple docstring''' _lowerCamelCase : int = "0.21.0" from .accelerator import Accelerator from .big_modeling import ( cpu_offload, cpu_offload_with_hook, disk_offload, dispatch_model, init_empty_weights, init_on_device, load_checkpoint_and_dispatch, ) from .data_loader import skip_first_batches from .launchers import debug_launcher, notebook_launcher from .state import PartialState from .utils import ( DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, FullyShardedDataParallelPlugin, GradScalerKwargs, InitProcessGroupKwargs, find_executable_batch_size, infer_auto_device_map, is_rich_available, load_checkpoint_in_model, synchronize_rng_states, ) if is_rich_available(): from .utils import rich
28
0
'''simple docstring''' import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from timm import create_model from timm.data import resolve_data_config from timm.data.transforms_factory import create_transform from transformers import BitConfig, BitForImageClassification, BitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() lowerCAmelCase: Optional[Any] = logging.get_logger(__name__) def lowerCamelCase__ ( _A ): a : Optional[Any] = 'huggingface/label-files' a : Tuple = 'imagenet-1k-id2label.json' a : int = json.load(open(hf_hub_download(A__ , A__ , repo_type='dataset' ) , 'r' ) ) a : Union[str, Any] = {int(A__ ): v for k, v in idalabel.items()} a : Dict = {v: k for k, v in idalabel.items()} a : Optional[Any] = 'std_conv' if 'bit' in model_name else False # note that when using BiT as backbone for ViT-hybrid checkpoints, # one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same", # config.conv_layer = "std_conv_same" a : str = BitConfig( conv_layer=A__ , num_labels=1000 , idalabel=A__ , labelaid=A__ , ) return config def lowerCamelCase__ ( _A ): if "stem.conv" in name: a : Dict = name.replace('stem.conv' , 'bit.embedder.convolution' ) if "blocks" in name: a : Optional[Any] = name.replace('blocks' , 'layers' ) if "head.fc" in name: a : Tuple = name.replace('head.fc' , 'classifier.1' ) if name.startswith('norm' ): a : Optional[Any] = 'bit.' + name if "bit" not in name and "classifier" not in name: a : str = 'bit.encoder.' + name return name def lowerCamelCase__ ( ): a : List[str] = 'http://images.cocodataset.org/val2017/000000039769.jpg' a : Union[str, Any] = Image.open(requests.get(A__ , stream=A__ ).raw ) return im @torch.no_grad() def lowerCamelCase__ ( _A , _A , _A=False ): a : Any = get_config(A__ ) # load original model from timm a : Dict = create_model(A__ , pretrained=A__ ) timm_model.eval() # load state_dict of original model a : Dict = timm_model.state_dict() for key in state_dict.copy().keys(): a : Tuple = state_dict.pop(A__ ) a : Optional[int] = val.squeeze() if 'head' in key else val # load HuggingFace model a : Optional[Any] = BitForImageClassification(A__ ) model.eval() model.load_state_dict(A__ ) # create image processor a : Optional[Any] = create_transform(**resolve_data_config({} , model=A__ ) ) a : List[str] = transform.transforms a : Tuple = { 'bilinear': PILImageResampling.BILINEAR, 'bicubic': PILImageResampling.BICUBIC, 'nearest': PILImageResampling.NEAREST, } a : Dict = BitImageProcessor( do_resize=A__ , size={'shortest_edge': timm_transforms[0].size} , resample=pillow_resamplings[timm_transforms[0].interpolation.value] , do_center_crop=A__ , crop_size={'height': timm_transforms[1].size[0], 'width': timm_transforms[1].size[1]} , do_normalize=A__ , image_mean=timm_transforms[-1].mean.tolist() , image_std=timm_transforms[-1].std.tolist() , ) a : List[str] = prepare_img() a : Union[str, Any] = transform(A__ ).unsqueeze(0 ) a : List[Any] = processor(A__ , return_tensors='pt' ).pixel_values # verify pixel values assert torch.allclose(A__ , A__ ) # verify logits with torch.no_grad(): a : List[str] = model(A__ ) a : Dict = outputs.logits print('Logits:' , logits[0, :3] ) print('Predicted class:' , model.config.idalabel[logits.argmax(-1 ).item()] ) a : Union[str, Any] = timm_model(A__ ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(A__ , outputs.logits , atol=1E-3 ) print('Looks ok!' ) if pytorch_dump_folder_path is not None: Path(A__ ).mkdir(exist_ok=A__ ) print(f"""Saving model {model_name} and processor to {pytorch_dump_folder_path}""" ) model.save_pretrained(A__ ) processor.save_pretrained(A__ ) if push_to_hub: print(f"""Pushing model {model_name} and processor to the hub""" ) model.push_to_hub(f"""ybelkada/{model_name}""" ) processor.push_to_hub(f"""ybelkada/{model_name}""" ) if __name__ == "__main__": lowerCAmelCase: Any = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='resnetv2_50x1_bitm', type=str, help='Name of the BiT timm model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether to push the model to the hub.', ) lowerCAmelCase: Tuple = parser.parse_args() convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
297
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowerCamelCase : List[Any] = { "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"], "tokenization_m2m_100": ["M2M100Tokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : int = [ "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST", "M2M100ForConditionalGeneration", "M2M100Model", "M2M100PreTrainedModel", ] if TYPE_CHECKING: from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig from .tokenization_mam_aaa import MaMaaaTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mam_aaa import ( M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST, MaMaaaForConditionalGeneration, MaMaaaModel, MaMaaaPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
28
0
"""simple docstring""" import warnings from typing import List, Optional, Union from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType class lowercase_ ( _a ): '''simple docstring''' UpperCAmelCase : Dict = ['''image_processor''', '''tokenizer'''] UpperCAmelCase : List[Any] = '''ViltImageProcessor''' UpperCAmelCase : Any = ('''BertTokenizer''', '''BertTokenizerFast''') def __init__( self : Any , _UpperCAmelCase : int=None , _UpperCAmelCase : List[Any]=None , **_UpperCAmelCase : str ): _A = None if "feature_extractor" in kwargs: warnings.warn( 'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`' ' instead.' , UpperCamelCase__ , ) _A = kwargs.pop('feature_extractor' ) _A = 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__(UpperCamelCase__ , UpperCamelCase__ ) _A = self.image_processor def __call__( self : Tuple , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , _UpperCAmelCase : bool = True , _UpperCAmelCase : Union[bool, str, PaddingStrategy] = False , _UpperCAmelCase : Union[bool, str, TruncationStrategy] = None , _UpperCAmelCase : Optional[int] = None , _UpperCAmelCase : int = 0 , _UpperCAmelCase : Optional[int] = None , _UpperCAmelCase : Optional[bool] = None , _UpperCAmelCase : Optional[bool] = None , _UpperCAmelCase : bool = False , _UpperCAmelCase : bool = False , _UpperCAmelCase : bool = False , _UpperCAmelCase : bool = False , _UpperCAmelCase : bool = True , _UpperCAmelCase : Optional[Union[str, TensorType]] = None , **_UpperCAmelCase : Optional[Any] , ): _A = self.tokenizer( text=UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=UpperCamelCase__ , stride=UpperCamelCase__ , pad_to_multiple_of=UpperCamelCase__ , return_token_type_ids=UpperCamelCase__ , return_attention_mask=UpperCamelCase__ , return_overflowing_tokens=UpperCamelCase__ , return_special_tokens_mask=UpperCamelCase__ , return_offsets_mapping=UpperCamelCase__ , return_length=UpperCamelCase__ , verbose=UpperCamelCase__ , return_tensors=UpperCamelCase__ , **UpperCamelCase__ , ) # add pixel_values + pixel_mask _A = self.image_processor(UpperCamelCase__ , return_tensors=UpperCamelCase__ ) encoding.update(UpperCamelCase__ ) return encoding def lowerCAmelCase_ ( self : int , *_UpperCAmelCase : List[Any] , **_UpperCAmelCase : str ): return self.tokenizer.batch_decode(*UpperCamelCase__ , **UpperCamelCase__ ) def lowerCAmelCase_ ( self : Tuple , *_UpperCAmelCase : Optional[int] , **_UpperCAmelCase : Optional[int] ): return self.tokenizer.decode(*UpperCamelCase__ , **UpperCamelCase__ ) @property def lowerCAmelCase_ ( self : str ): _A = self.tokenizer.model_input_names _A = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) @property def lowerCAmelCase_ ( self : Union[str, Any] ): warnings.warn( '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.' , UpperCamelCase__ , ) return self.image_processor_class @property def lowerCAmelCase_ ( self : Optional[Any] ): warnings.warn( '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.' , UpperCamelCase__ , ) return self.image_processor
315
'''simple docstring''' from typing import Optional, Tuple import jax import jax.numpy as jnp from flax import linen as nn from flax.core.frozen_dict import FrozenDict from transformers import CLIPConfig, FlaxPreTrainedModel from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule def __lowerCamelCase ( A__ , A__ , A__=1e-1_2 ) -> Dict: """simple docstring""" UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T UpperCamelCase = jnp.divide(emb_a.T , jnp.clip(jnp.linalg.norm(A__ , axis=1 ) , a_min=A__ ) ).T return jnp.matmul(A__ , norm_emb_a.T ) class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" _SCREAMING_SNAKE_CASE = 42 _SCREAMING_SNAKE_CASE = jnp.floataa def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = FlaxCLIPVisionModule(self.config.vision_config ) UpperCamelCase = nn.Dense(self.config.projection_dim , use_bias=UpperCamelCase__ , dtype=self.dtype ) UpperCamelCase = self.param('concept_embeds' , jax.nn.initializers.ones , (1_7, self.config.projection_dim) ) UpperCamelCase = self.param( 'special_care_embeds' , jax.nn.initializers.ones , (3, self.config.projection_dim) ) UpperCamelCase = self.param('concept_embeds_weights' , jax.nn.initializers.ones , (1_7,) ) UpperCamelCase = self.param('special_care_embeds_weights' , jax.nn.initializers.ones , (3,) ) def __call__( self : str , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = self.vision_model(UpperCamelCase__ )[1] UpperCamelCase = self.visual_projection(UpperCamelCase__ ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.special_care_embeds ) UpperCamelCase = jax_cosine_distance(UpperCamelCase__ , self.concept_embeds ) # increase this value to create a stronger `nfsw` filter # at the cost of increasing the possibility of filtering benign image inputs UpperCamelCase = 0.0 UpperCamelCase = special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(special_scores > 0 , axis=1 , keepdims=UpperCamelCase__ ) # Use a lower threshold if an image has any special care concept UpperCamelCase = is_special_care * 0.0_1 UpperCamelCase = cos_dist - self.concept_embeds_weights[None, :] + special_adjustment UpperCamelCase = jnp.round(UpperCamelCase__ , 3 ) UpperCamelCase = jnp.any(concept_scores > 0 , axis=1 ) return has_nsfw_concepts class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" _SCREAMING_SNAKE_CASE = CLIPConfig _SCREAMING_SNAKE_CASE = """clip_input""" _SCREAMING_SNAKE_CASE = FlaxStableDiffusionSafetyCheckerModule def __init__( self : Union[str, Any] , UpperCamelCase__ : CLIPConfig , UpperCamelCase__ : Optional[Tuple] = None , UpperCamelCase__ : int = 0 , UpperCamelCase__ : jnp.dtype = jnp.floataa , UpperCamelCase__ : bool = True , **UpperCamelCase__ : List[str] , ): """simple docstring""" if input_shape is None: UpperCamelCase = (1, 2_2_4, 2_2_4, 3) UpperCamelCase = self.module_class(config=UpperCamelCase__ , dtype=UpperCamelCase__ , **UpperCamelCase__ ) super().__init__(UpperCamelCase__ , UpperCamelCase__ , input_shape=UpperCamelCase__ , seed=UpperCamelCase__ , dtype=UpperCamelCase__ , _do_init=_do_init ) def A ( self : int , UpperCamelCase__ : jax.random.KeyArray , UpperCamelCase__ : Tuple , UpperCamelCase__ : FrozenDict = None ): """simple docstring""" UpperCamelCase = jax.random.normal(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase , UpperCamelCase = jax.random.split(UpperCamelCase__ ) UpperCamelCase = {'params': params_rng, 'dropout': dropout_rng} UpperCamelCase = self.module.init(UpperCamelCase__ , UpperCamelCase__ )['params'] return random_params def __call__( self : List[Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : dict = None , ): """simple docstring""" UpperCamelCase = jnp.transpose(UpperCamelCase__ , (0, 2, 3, 1) ) return self.module.apply( {'params': params or self.params} , jnp.array(UpperCamelCase__ , dtype=jnp.floataa ) , rngs={} , )
28
0
from typing import List, Union import numpy as np from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, logging from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline _snake_case = logging.get_logger(__name__) class lowercase ( _a ): def a__ ( self , _a ) -> int: if isinstance(UpperCamelCase__ , UpperCamelCase__ ): _A : Any = [label.strip() for label in labels.split(""",""" ) if label.strip()] return labels def __call__( self , _a , _a , _a ) -> List[Any]: if len(UpperCamelCase__ ) == 0 or len(UpperCamelCase__ ) == 0: raise ValueError("""You must include at least one label and at least one sequence.""" ) if hypothesis_template.format(labels[0] ) == hypothesis_template: raise ValueError( ( """The provided hypothesis_template \"{}\" was not able to be formatted with the target labels. """ """Make sure the passed template includes formatting syntax such as {{}} where the label should go.""" ).format(UpperCamelCase__ ) ) if isinstance(UpperCamelCase__ , UpperCamelCase__ ): _A : Any = [sequences] _A : List[Any] = [] for sequence in sequences: sequence_pairs.extend([[sequence, hypothesis_template.format(UpperCamelCase__ )] for label in labels] ) return sequence_pairs, sequences @add_end_docstrings(_a ) class lowercase ( _a ): def __init__( self , _a=ZeroShotClassificationArgumentHandler() , *_a , **_a ) -> Union[str, Any]: _A : List[str] = args_parser super().__init__(*UpperCamelCase__ , **UpperCamelCase__ ) if self.entailment_id == -1: logger.warning( """Failed to determine \'entailment\' label id from the label2id mapping in the model config. Setting to """ """-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.""" ) @property def a__ ( self ) -> List[str]: for label, ind in self.model.config.labelaid.items(): if label.lower().startswith("""entail""" ): return ind return -1 def a__ ( self , _a , _a=True , _a=True , _a=TruncationStrategy.ONLY_FIRST , **_a ) -> Tuple: _A : int = self.framework if self.tokenizer.pad_token is None: # Override for tokenizers not supporting padding logger.error( """Tokenizer was not supporting padding necessary for zero-shot, attempting to use """ """ `pad_token=eos_token`""" ) _A : Tuple = self.tokenizer.eos_token try: _A : Any = self.tokenizer( UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , return_tensors=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , ) except Exception as e: if "too short" in str(UpperCamelCase__ ): # tokenizers might yell that we want to truncate # to a value that is not even reached by the input. # In that case we don't want to truncate. # It seems there's not a really better way to catch that # exception. _A : List[str] = self.tokenizer( UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , return_tensors=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=TruncationStrategy.DO_NOT_TRUNCATE , ) else: raise e return inputs def a__ ( self , **_a ) -> Dict: if kwargs.get("""multi_class""" , UpperCamelCase__ ) is not None: _A : Optional[Any] = kwargs["""multi_class"""] logger.warning( """The `multi_class` argument has been deprecated and renamed to `multi_label`. """ """`multi_class` will be removed in a future version of Transformers.""" ) _A : str = {} if "candidate_labels" in kwargs: _A : List[str] = self._args_parser._parse_labels(kwargs["""candidate_labels"""] ) if "hypothesis_template" in kwargs: _A : Optional[int] = kwargs["""hypothesis_template"""] _A : Union[str, Any] = {} if "multi_label" in kwargs: _A : Any = kwargs["""multi_label"""] return preprocess_params, {}, postprocess_params def __call__( self , _a , *_a , **_a , ) -> int: if len(UpperCamelCase__ ) == 0: pass elif len(UpperCamelCase__ ) == 1 and "candidate_labels" not in kwargs: _A : Optional[int] = args[0] else: raise ValueError(F'''Unable to understand extra arguments {args}''' ) return super().__call__(UpperCamelCase__ , **UpperCamelCase__ ) def a__ ( self , _a , _a=None , _a="This example is {}." ) -> Any: _A , _A : Dict = self._args_parser(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) for i, (candidate_label, sequence_pair) in enumerate(zip(UpperCamelCase__ , UpperCamelCase__ ) ): _A : Union[str, Any] = self._parse_and_tokenize([sequence_pair] ) yield { "candidate_label": candidate_label, "sequence": sequences[0], "is_last": i == len(UpperCamelCase__ ) - 1, **model_input, } def a__ ( self , _a ) -> Optional[Any]: _A : List[str] = inputs["""candidate_label"""] _A : Optional[int] = inputs["""sequence"""] _A : int = {k: inputs[k] for k in self.tokenizer.model_input_names} _A : List[str] = self.model(**UpperCamelCase__ ) _A : Union[str, Any] = { """candidate_label""": candidate_label, """sequence""": sequence, """is_last""": inputs["""is_last"""], **outputs, } return model_outputs def a__ ( self , _a , _a=False ) -> List[Any]: _A : Optional[int] = [outputs["""candidate_label"""] for outputs in model_outputs] _A : int = [outputs["""sequence"""] for outputs in model_outputs] _A : Union[str, Any] = np.concatenate([output["""logits"""].numpy() for output in model_outputs] ) _A : Any = logits.shape[0] _A : Tuple = len(UpperCamelCase__ ) _A : Optional[int] = N // n _A : Optional[Any] = logits.reshape((num_sequences, n, -1) ) if multi_label or len(UpperCamelCase__ ) == 1: # softmax over the entailment vs. contradiction dim for each label independently _A : List[Any] = self.entailment_id _A : List[Any] = -1 if entailment_id == 0 else 0 _A : Dict = reshaped_outputs[..., [contradiction_id, entailment_id]] _A : Tuple = np.exp(UpperCamelCase__ ) / np.exp(UpperCamelCase__ ).sum(-1 , keepdims=UpperCamelCase__ ) _A : Any = scores[..., 1] else: # softmax the "entailment" logits over all candidate labels _A : Optional[int] = reshaped_outputs[..., self.entailment_id] _A : Optional[int] = np.exp(UpperCamelCase__ ) / np.exp(UpperCamelCase__ ).sum(-1 , keepdims=UpperCamelCase__ ) _A : str = list(reversed(scores[0].argsort() ) ) return { "sequence": sequences[0], "labels": [candidate_labels[i] for i in top_inds], "scores": scores[0, top_inds].tolist(), }
26
'''simple docstring''' import warnings from ...utils import logging from .image_processing_chinese_clip import ChineseCLIPImageProcessor _lowerCamelCase : str = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE ( _a ): """simple docstring""" def __init__( self : Dict , *UpperCamelCase__ : List[Any] , **UpperCamelCase__ : List[Any] ): """simple docstring""" warnings.warn( 'The class ChineseCLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use ChineseCLIPImageProcessor instead.' , UpperCamelCase__ , ) super().__init__(*UpperCamelCase__ , **UpperCamelCase__ )
28
0
import gc import random import tempfile import unittest import numpy as np import torch from PIL import Image from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMInverseScheduler, DDIMScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, StableDiffusionDiffEditPipeline, UNetaDConditionModel, ) from diffusers.utils import load_image, slow from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class __SCREAMING_SNAKE_CASE ( _a ,_a ,unittest.TestCase ): _UpperCAmelCase : List[Any] = StableDiffusionDiffEditPipeline _UpperCAmelCase : int = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"} _UpperCAmelCase : Any = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"} _UpperCAmelCase : str = frozenset( [] ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess _UpperCAmelCase : int = frozenset([] ) def __lowerCamelCase ( self : Dict ) ->List[Any]: torch.manual_seed(0 ) lowerCamelCase__ : Optional[Any] = 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 , attention_head_dim=(2, 4) , use_linear_projection=UpperCamelCase__ , ) lowerCamelCase__ : str = DDIMScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , clip_sample=UpperCamelCase__ , set_alpha_to_one=UpperCamelCase__ , ) lowerCamelCase__ : Union[str, Any] = DDIMInverseScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , clip_sample=UpperCamelCase__ , set_alpha_to_zero=UpperCamelCase__ , ) torch.manual_seed(0 ) lowerCamelCase__ : Dict = 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 , sample_size=1_2_8 , ) torch.manual_seed(0 ) lowerCamelCase__ : Tuple = 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 , hidden_act='''gelu''' , projection_dim=5_1_2 , ) lowerCamelCase__ : int = CLIPTextModel(UpperCamelCase__ ) lowerCamelCase__ : str = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) lowerCamelCase__ : Optional[int] = { '''unet''': unet, '''scheduler''': scheduler, '''inverse_scheduler''': inverse_scheduler, '''vae''': vae, '''text_encoder''': text_encoder, '''tokenizer''': tokenizer, '''safety_checker''': None, '''feature_extractor''': None, } return components def __lowerCamelCase ( self : Any , A : str , A : List[Any]=0 ) ->Tuple: lowerCamelCase__ : List[str] = floats_tensor((1, 1_6, 1_6) , rng=random.Random(UpperCamelCase__ ) ).to(UpperCamelCase__ ) lowerCamelCase__ : Union[str, Any] = floats_tensor((1, 2, 4, 1_6, 1_6) , rng=random.Random(UpperCamelCase__ ) ).to(UpperCamelCase__ ) if str(UpperCamelCase__ ).startswith('''mps''' ): lowerCamelCase__ : str = torch.manual_seed(UpperCamelCase__ ) else: lowerCamelCase__ : Dict = torch.Generator(device=UpperCamelCase__ ).manual_seed(UpperCamelCase__ ) lowerCamelCase__ : Union[str, Any] = { '''prompt''': '''a dog and a newt''', '''mask_image''': mask, '''image_latents''': latents, '''generator''': generator, '''num_inference_steps''': 2, '''inpaint_strength''': 1.0, '''guidance_scale''': 6.0, '''output_type''': '''numpy''', } return inputs def __lowerCamelCase ( self : Union[str, Any] , A : List[Any] , A : Union[str, Any]=0 ) ->Union[str, Any]: lowerCamelCase__ : int = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(UpperCamelCase__ ) ).to(UpperCamelCase__ ) lowerCamelCase__ : Optional[Any] = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCamelCase__ : List[str] = Image.fromarray(np.uinta(UpperCamelCase__ ) ).convert('''RGB''' ) if str(UpperCamelCase__ ).startswith('''mps''' ): lowerCamelCase__ : Dict = torch.manual_seed(UpperCamelCase__ ) else: lowerCamelCase__ : str = torch.Generator(device=UpperCamelCase__ ).manual_seed(UpperCamelCase__ ) lowerCamelCase__ : Tuple = { '''image''': image, '''source_prompt''': '''a cat and a frog''', '''target_prompt''': '''a dog and a newt''', '''generator''': generator, '''num_inference_steps''': 2, '''num_maps_per_mask''': 2, '''mask_encode_strength''': 1.0, '''guidance_scale''': 6.0, '''output_type''': '''numpy''', } return inputs def __lowerCamelCase ( self : Any , A : Optional[int] , A : List[Any]=0 ) ->Union[str, Any]: lowerCamelCase__ : Any = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(UpperCamelCase__ ) ).to(UpperCamelCase__ ) lowerCamelCase__ : Union[str, Any] = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCamelCase__ : List[Any] = Image.fromarray(np.uinta(UpperCamelCase__ ) ).convert('''RGB''' ) if str(UpperCamelCase__ ).startswith('''mps''' ): lowerCamelCase__ : List[Any] = torch.manual_seed(UpperCamelCase__ ) else: lowerCamelCase__ : int = torch.Generator(device=UpperCamelCase__ ).manual_seed(UpperCamelCase__ ) lowerCamelCase__ : Tuple = { '''image''': image, '''prompt''': '''a cat and a frog''', '''generator''': generator, '''num_inference_steps''': 2, '''inpaint_strength''': 1.0, '''guidance_scale''': 6.0, '''decode_latents''': True, '''output_type''': '''numpy''', } return inputs def __lowerCamelCase ( self : List[Any] ) ->str: if not hasattr(self.pipeline_class , '''_optional_components''' ): return lowerCamelCase__ : Optional[Any] = self.get_dummy_components() lowerCamelCase__ : str = self.pipeline_class(**UpperCamelCase__ ) pipe.to(UpperCamelCase__ ) pipe.set_progress_bar_config(disable=UpperCamelCase__ ) # set all optional components to None and update pipeline config accordingly for optional_component in pipe._optional_components: setattr(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components} ) lowerCamelCase__ : List[str] = self.get_dummy_inputs(UpperCamelCase__ ) lowerCamelCase__ : Optional[int] = pipe(**UpperCamelCase__ )[0] with tempfile.TemporaryDirectory() as tmpdir: pipe.save_pretrained(UpperCamelCase__ ) lowerCamelCase__ : Optional[Any] = self.pipeline_class.from_pretrained(UpperCamelCase__ ) pipe_loaded.to(UpperCamelCase__ ) pipe_loaded.set_progress_bar_config(disable=UpperCamelCase__ ) for optional_component in pipe._optional_components: self.assertTrue( getattr(UpperCamelCase__ , UpperCamelCase__ ) is None , F"`{optional_component}` did not stay set to None after loading." , ) lowerCamelCase__ : Dict = self.get_dummy_inputs(UpperCamelCase__ ) lowerCamelCase__ : Optional[int] = pipe_loaded(**UpperCamelCase__ )[0] lowerCamelCase__ : Union[str, Any] = np.abs(output - output_loaded ).max() self.assertLess(UpperCamelCase__ , 1e-4 ) def __lowerCamelCase ( self : List[str] ) ->List[str]: lowerCamelCase__ : Tuple = '''cpu''' lowerCamelCase__ : List[str] = self.get_dummy_components() lowerCamelCase__ : Any = self.pipeline_class(**UpperCamelCase__ ) pipe.to(UpperCamelCase__ ) pipe.set_progress_bar_config(disable=UpperCamelCase__ ) lowerCamelCase__ : str = self.get_dummy_mask_inputs(UpperCamelCase__ ) lowerCamelCase__ : Union[str, Any] = pipe.generate_mask(**UpperCamelCase__ ) lowerCamelCase__ : str = mask[0, -3:, -3:] self.assertEqual(mask.shape , (1, 1_6, 1_6) ) lowerCamelCase__ : Optional[Any] = np.array([0] * 9 ) lowerCamelCase__ : List[str] = np.abs(mask_slice.flatten() - expected_slice ).max() self.assertLessEqual(UpperCamelCase__ , 1e-3 ) self.assertEqual(mask[0, -3, -4] , 0 ) def __lowerCamelCase ( self : Dict ) ->str: lowerCamelCase__ : Tuple = '''cpu''' lowerCamelCase__ : Tuple = self.get_dummy_components() lowerCamelCase__ : int = self.pipeline_class(**UpperCamelCase__ ) pipe.to(UpperCamelCase__ ) pipe.set_progress_bar_config(disable=UpperCamelCase__ ) lowerCamelCase__ : str = self.get_dummy_inversion_inputs(UpperCamelCase__ ) lowerCamelCase__ : Tuple = pipe.invert(**UpperCamelCase__ ).images lowerCamelCase__ : str = image[0, -1, -3:, -3:] self.assertEqual(image.shape , (2, 3_2, 3_2, 3) ) lowerCamelCase__ : List[Any] = np.array( [0.51_50, 0.51_34, 0.50_43, 0.53_76, 0.46_94, 0.5_10_50, 0.50_15, 0.44_07, 0.47_99] , ) lowerCamelCase__ : str = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(UpperCamelCase__ , 1e-3 ) def __lowerCamelCase ( self : List[Any] ) ->Tuple: super().test_inference_batch_single_identical(expected_max_diff=5e-3 ) def __lowerCamelCase ( self : Tuple ) ->List[str]: lowerCamelCase__ : int = '''cpu''' lowerCamelCase__ : Optional[int] = self.get_dummy_components() lowerCamelCase__ : int = {'''beta_start''': 0.0_00_85, '''beta_end''': 0.0_12, '''beta_schedule''': '''scaled_linear'''} lowerCamelCase__ : Tuple = DPMSolverMultistepScheduler(**UpperCamelCase__ ) lowerCamelCase__ : int = DPMSolverMultistepInverseScheduler(**UpperCamelCase__ ) lowerCamelCase__ : Optional[Any] = self.pipeline_class(**UpperCamelCase__ ) pipe.to(UpperCamelCase__ ) pipe.set_progress_bar_config(disable=UpperCamelCase__ ) lowerCamelCase__ : Dict = self.get_dummy_inversion_inputs(UpperCamelCase__ ) lowerCamelCase__ : Dict = pipe.invert(**UpperCamelCase__ ).images lowerCamelCase__ : Dict = image[0, -1, -3:, -3:] self.assertEqual(image.shape , (2, 3_2, 3_2, 3) ) lowerCamelCase__ : Dict = np.array( [0.51_50, 0.51_34, 0.50_43, 0.53_76, 0.46_94, 0.5_10_50, 0.50_15, 0.44_07, 0.47_99] , ) lowerCamelCase__ : Optional[Any] = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(UpperCamelCase__ , 1e-3 ) @require_torch_gpu @slow class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCamelCase ( self : str ) ->Dict: super().tearDown() gc.collect() torch.cuda.empty_cache() @classmethod def __lowerCamelCase ( cls : Union[str, Any] ) ->Optional[Any]: lowerCamelCase__ : Dict = load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png''' ) lowerCamelCase__ : Union[str, Any] = raw_image.convert('''RGB''' ).resize((7_6_8, 7_6_8) ) lowerCamelCase__ : Any = raw_image def __lowerCamelCase ( self : Tuple ) ->Union[str, Any]: lowerCamelCase__ : List[str] = torch.manual_seed(0 ) lowerCamelCase__ : int = StableDiffusionDiffEditPipeline.from_pretrained( '''stabilityai/stable-diffusion-2-1''' , safety_checker=UpperCamelCase__ , torch_dtype=torch.floataa ) lowerCamelCase__ : Dict = DDIMScheduler.from_config(pipe.scheduler.config ) lowerCamelCase__ : List[Any] = DDIMInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=UpperCamelCase__ ) lowerCamelCase__ : List[Any] = '''a bowl of fruit''' lowerCamelCase__ : Union[str, Any] = '''a bowl of pears''' lowerCamelCase__ : int = pipe.generate_mask( image=self.raw_image , source_prompt=UpperCamelCase__ , target_prompt=UpperCamelCase__ , generator=UpperCamelCase__ , ) lowerCamelCase__ : List[Any] = pipe.invert( prompt=UpperCamelCase__ , image=self.raw_image , inpaint_strength=0.7 , generator=UpperCamelCase__ ).latents lowerCamelCase__ : Optional[Any] = pipe( prompt=UpperCamelCase__ , mask_image=UpperCamelCase__ , image_latents=UpperCamelCase__ , generator=UpperCamelCase__ , negative_prompt=UpperCamelCase__ , inpaint_strength=0.7 , output_type='''numpy''' , ).images[0] lowerCamelCase__ : Dict = ( np.array( load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/diffedit/pears.png''' ).resize((7_6_8, 7_6_8) ) ) / 2_5_5 ) assert np.abs((expected_image - image).max() ) < 5e-1 def __lowerCamelCase ( self : Optional[int] ) ->Tuple: lowerCamelCase__ : Dict = torch.manual_seed(0 ) lowerCamelCase__ : Tuple = StableDiffusionDiffEditPipeline.from_pretrained( '''stabilityai/stable-diffusion-2-1''' , safety_checker=UpperCamelCase__ , torch_dtype=torch.floataa ) lowerCamelCase__ : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) lowerCamelCase__ : Dict = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=UpperCamelCase__ ) lowerCamelCase__ : List[Any] = '''a bowl of fruit''' lowerCamelCase__ : int = '''a bowl of pears''' lowerCamelCase__ : str = pipe.generate_mask( image=self.raw_image , source_prompt=UpperCamelCase__ , target_prompt=UpperCamelCase__ , generator=UpperCamelCase__ , ) lowerCamelCase__ : Optional[Any] = pipe.invert( prompt=UpperCamelCase__ , image=self.raw_image , inpaint_strength=0.7 , generator=UpperCamelCase__ , num_inference_steps=2_5 , ).latents lowerCamelCase__ : Any = pipe( prompt=UpperCamelCase__ , mask_image=UpperCamelCase__ , image_latents=UpperCamelCase__ , generator=UpperCamelCase__ , negative_prompt=UpperCamelCase__ , inpaint_strength=0.7 , num_inference_steps=2_5 , output_type='''numpy''' , ).images[0] lowerCamelCase__ : List[Any] = ( np.array( load_image( '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/diffedit/pears.png''' ).resize((7_6_8, 7_6_8) ) ) / 2_5_5 ) assert np.abs((expected_image - image).max() ) < 5e-1
142
'''simple docstring''' import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed _lowerCamelCase : Optional[int] = logging.getLogger(__name__) def __lowerCamelCase ( A__=2 , A__=3 , A__=16 , A__ = 10 , A__ = 2 ) -> int: """simple docstring""" def get_dataset(A__ ): UpperCamelCase = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(A__ , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = get_dataset(A__ ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) UpperCamelCase = DataLoader(A__ , shuffle=A__ , batch_size=A__ , num_workers=4 ) return (train_dataloader, valid_dataloader) def __lowerCamelCase ( A__ , A__ , A__ , A__ , A__ , A__=None ) -> int: """simple docstring""" UpperCamelCase = [] for epoch in range(A__ ): # Train quickly model.train() for batch in dataloader: UpperCamelCase , UpperCamelCase = batch UpperCamelCase = model(A__ ) UpperCamelCase = torch.nn.functional.mse_loss(A__ , A__ ) accelerator.backward(A__ ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class SCREAMING_SNAKE_CASE ( nn.Module ): """simple docstring""" def __init__( self : Tuple ): """simple docstring""" super().__init__() UpperCamelCase = nn.Parameter(torch.randn(1 ) ) UpperCamelCase = nn.Parameter(torch.randn(1 ) ) def A ( self : str , UpperCamelCase__ : Dict ): """simple docstring""" return x * self.a + self.b class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(total_limit=1 , project_dir=UpperCamelCase__ , automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def A ( self : Optional[int] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() # Train baseline UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial UpperCamelCase = os.path.join(UpperCamelCase__ , 'initial' ) accelerator.save_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = Accelerator() UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything UpperCamelCase = os.path.join(UpperCamelCase__ , 'checkpoint' ) accelerator.save_state(UpperCamelCase__ ) # Load everything back in and make sure all states work accelerator.load_state(UpperCamelCase__ ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Union[str, Any] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() UpperCamelCase = train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=UpperCamelCase__ ) UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = train(2 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ((UpperCamelCase) , (UpperCamelCase)) = model.a.item(), model.b.item() UpperCamelCase = optimizer.state_dict() self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) self.assertEqual(UpperCamelCase__ , UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = torch.tensor([1, 2, 3] ) UpperCamelCase = torch.tensor([2, 3, 4] ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(net.parameters() ) UpperCamelCase = Accelerator() with self.assertRaises(UpperCamelCase__ ) as ve: accelerator.register_for_checkpointing(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) UpperCamelCase = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def A ( self : Dict ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCamelCase = torch.optim.lr_scheduler.StepLR(UpperCamelCase__ , step_size=1 , gamma=0.9_9 ) UpperCamelCase , UpperCamelCase = dummy_dataloaders() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase = accelerator.prepare( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) # Save initial accelerator.save_state() UpperCamelCase = scheduler.state_dict() train(3 , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) self.assertNotEqual(UpperCamelCase__ , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(UpperCamelCase__ , scheduler.state_dict() ) def A ( self : List[str] ): """simple docstring""" with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCamelCase = DummyModel() UpperCamelCase = ProjectConfiguration(automatic_checkpoint_naming=UpperCamelCase__ , total_limit=2 ) # Train baseline UpperCamelCase = Accelerator(project_dir=UpperCamelCase__ , project_config=UpperCamelCase__ ) UpperCamelCase = accelerator.prepare(UpperCamelCase__ ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(UpperCamelCase__ , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def A ( self : Dict ): """simple docstring""" UpperCamelCase = ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )] execute_subprocess_async(UpperCamelCase__ , env=os.environ.copy() ) if __name__ == "__main__": _lowerCamelCase : Optional[int] = "/tmp/accelerate/state_checkpointing" _lowerCamelCase : Union[str, Any] = DummyModel() _lowerCamelCase : Optional[Any] = torch.optim.Adam(params=model.parameters(), lr=1e-3) _lowerCamelCase : List[Any] = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.99) _lowerCamelCase ,_lowerCamelCase : Tuple = dummy_dataloaders() _lowerCamelCase : List[Any] = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline _lowerCamelCase : Any = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision="no") if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) _lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase : Union[str, Any] = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) _lowerCamelCase ,_lowerCamelCase : Tuple = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: _lowerCamelCase : Any = group["params"][0].device break assert param_device.type == accelerator.device.type _lowerCamelCase : Tuple = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="cpu") for group in optimizer.param_groups: _lowerCamelCase : Optional[Any] = group["params"][0].device break assert ( param_device.type == torch.device("cpu").type ), f"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="on_device") for group in optimizer.param_groups: _lowerCamelCase : Dict = group["params"][0].device break assert ( param_device.type == accelerator.device.type ), f"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match="Unsupported optimizer map location passed"): accelerator.load_state(os.path.join(savedir, "checkpoints", "checkpoint_0"), map_location="invalid") accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
28
0
'''simple docstring''' from abc import ABC, abstractmethod from argparse import ArgumentParser class lowercase__ ( _a ): @staticmethod @abstractmethod def UpperCamelCase_ ( lowerCamelCase__ : ArgumentParser ): '''simple docstring''' raise NotImplementedError() @abstractmethod def UpperCamelCase_ ( self : List[str] ): '''simple docstring''' raise NotImplementedError()
83
'''simple docstring''' import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration _lowerCamelCase : List[str] = 5_0000 _lowerCamelCase : Optional[int] = 5000 _lowerCamelCase ,_lowerCamelCase : int = os.path.split(__file__) _lowerCamelCase : str = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json")) @get_duration def __lowerCamelCase ( A__ , A__ ) -> Any: """simple docstring""" for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> int: """simple docstring""" for i in range(0 , len(A__ ) , A__ ): UpperCamelCase = dataset[i : i + batch_size] @get_duration def __lowerCamelCase ( A__ , A__ , A__ ) -> List[Any]: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(A__ ): UpperCamelCase = dataset[i] @get_duration def __lowerCamelCase ( A__ , A__ , A__ , A__ ) -> int: """simple docstring""" with dataset.formatted_as(type=A__ ): for i in range(0 , A__ , A__ ): UpperCamelCase = dataset[i : i + batch_size] def __lowerCamelCase ( ) -> List[str]: """simple docstring""" UpperCamelCase = {'num examples': SPEED_TEST_N_EXAMPLES} UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted, {'type': 'pandas', 'length': SMALL_TEST}), (read_formatted, {'type': 'torch', 'length': SMALL_TEST}), (read_formatted, {'type': 'tensorflow', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] UpperCamelCase = [ (read, {'length': SMALL_TEST}), (read, {'length': SPEED_TEST_N_EXAMPLES}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}), (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}), (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}), (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print('generating dataset' ) UpperCamelCase = datasets.Features( {'list': datasets.Sequence(datasets.Value('float32' ) ), 'numbers': datasets.Value('float32' )} ) UpperCamelCase = generate_example_dataset( os.path.join(A__ , 'dataset.arrow' ) , A__ , num_examples=A__ , seq_shapes={'list': (100,)} , ) print('first set of iterations' ) for func, kwargs in functions: print(func.__name__ , str(A__ ) ) UpperCamelCase = func(A__ , **A__ ) print('shuffling dataset' ) UpperCamelCase = dataset.shuffle() print('Second set of iterations (after shuffling' ) for func, kwargs in functions_shuffled: print('shuffled ' , func.__name__ , str(A__ ) ) UpperCamelCase = func( A__ , **A__ ) with open(A__ , 'wb' ) as f: f.write(json.dumps(A__ ).encode('utf-8' ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
28
0
from typing import Tuple, Union from ...modeling_outputs import BackboneOutput from ...modeling_utils import PreTrainedModel from ...utils import is_timm_available, is_torch_available, requires_backends from ...utils.backbone_utils import BackboneMixin from .configuration_timm_backbone import TimmBackboneConfig if is_timm_available(): import timm if is_torch_available(): from torch import Tensor class A_ ( _a , _a ): _lowercase : List[str] = 'pixel_values' _lowercase : Optional[int] = False _lowercase : Any = TimmBackboneConfig def __init__( self : str , UpperCAmelCase : List[Any] , **UpperCAmelCase : Optional[Any] ) -> int: requires_backends(self , 'timm' ) super().__init__(UpperCamelCase__ ) __lowerCAmelCase: List[str] = config if config.backbone is None: raise ValueError('backbone is not set in the config. Please set it to a timm model name.' ) if config.backbone not in timm.list_models(): raise ValueError(F'''backbone {config.backbone} is not supported by timm.''' ) if hasattr(UpperCamelCase__ , 'out_features' ) and config.out_features is not None: raise ValueError('out_features is not supported by TimmBackbone. Please use out_indices instead.' ) __lowerCAmelCase: List[str] = getattr(UpperCamelCase__ , 'use_pretrained_backbone' , UpperCamelCase__ ) if pretrained is None: raise ValueError('use_pretrained_backbone is not set in the config. Please set it to True or False.' ) # We just take the final layer by default. This matches the default for the transformers models. __lowerCAmelCase: Tuple = config.out_indices if getattr(UpperCamelCase__ , 'out_indices' , UpperCamelCase__ ) is not None else (-1,) __lowerCAmelCase: List[Any] = timm.create_model( config.backbone , pretrained=UpperCamelCase__ , features_only=config.features_only , in_chans=config.num_channels , out_indices=UpperCamelCase__ , **UpperCamelCase__ , ) # These are used to control the output of the model when called. If output_hidden_states is True, then # return_layers is modified to include all layers. __lowerCAmelCase: Tuple = self._backbone.return_layers __lowerCAmelCase: int = {layer['module']: str(UpperCamelCase__ ) for i, layer in enumerate(self._backbone.feature_info.info )} super()._init_backbone(UpperCamelCase__ ) @classmethod def UpperCAmelCase ( cls : List[Any] , UpperCAmelCase : Any , *UpperCAmelCase : List[str] , **UpperCAmelCase : Optional[Any] ) -> int: requires_backends(cls , ['vision', 'timm'] ) from ...models.timm_backbone import TimmBackboneConfig __lowerCAmelCase: List[str] = kwargs.pop('config' , TimmBackboneConfig() ) __lowerCAmelCase: Optional[Any] = kwargs.pop('use_timm_backbone' , UpperCamelCase__ ) if not use_timm: raise ValueError('use_timm_backbone must be True for timm backbones' ) __lowerCAmelCase: List[str] = kwargs.pop('num_channels' , config.num_channels ) __lowerCAmelCase: Union[str, Any] = kwargs.pop('features_only' , config.features_only ) __lowerCAmelCase: Optional[Any] = kwargs.pop('use_pretrained_backbone' , config.use_pretrained_backbone ) __lowerCAmelCase: Tuple = kwargs.pop('out_indices' , config.out_indices ) __lowerCAmelCase: Dict = TimmBackboneConfig( backbone=UpperCamelCase__ , num_channels=UpperCamelCase__ , features_only=UpperCamelCase__ , use_pretrained_backbone=UpperCamelCase__ , out_indices=UpperCamelCase__ , ) return super()._from_config(UpperCamelCase__ , **UpperCamelCase__ ) def UpperCAmelCase ( self : Optional[int] , UpperCAmelCase : Dict ) -> Any: pass def UpperCAmelCase ( self : str , UpperCAmelCase : str , UpperCAmelCase : Optional[int]=None , UpperCAmelCase : Optional[Any]=None , UpperCAmelCase : Optional[Any]=None , **UpperCAmelCase : Union[str, Any] ) -> str: __lowerCAmelCase: int = return_dict if return_dict is not None else self.config.use_return_dict __lowerCAmelCase: List[str] = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) __lowerCAmelCase: List[str] = output_attentions if output_attentions is not None else self.config.output_attentions if output_attentions: raise ValueError('Cannot output attentions for timm backbones at the moment' ) if output_hidden_states: # We modify the return layers to include all the stages of the backbone __lowerCAmelCase: Tuple = self._all_layers __lowerCAmelCase: Dict = self._backbone(UpperCamelCase__ , **UpperCamelCase__ ) __lowerCAmelCase: Tuple = self._return_layers __lowerCAmelCase: Tuple = tuple(hidden_states[i] for i in self.out_indices ) else: __lowerCAmelCase: List[Any] = self._backbone(UpperCamelCase__ , **UpperCamelCase__ ) __lowerCAmelCase: List[Any] = None __lowerCAmelCase: List[Any] = tuple(UpperCamelCase__ ) __lowerCAmelCase: Optional[Any] = tuple(UpperCamelCase__ ) if hidden_states is not None else None if not return_dict: __lowerCAmelCase: Dict = (feature_maps,) if output_hidden_states: __lowerCAmelCase: List[Any] = output + (hidden_states,) return output return BackboneOutput(feature_maps=UpperCamelCase__ , hidden_states=UpperCamelCase__ , attentions=UpperCamelCase__ )
322
'''simple docstring''' import absl # noqa: F401 # Here to have a nice missing dependency error message early on import nltk # noqa: F401 # Here to have a nice missing dependency error message early on import numpy # noqa: F401 # Here to have a nice missing dependency error message early on import six # noqa: F401 # Here to have a nice missing dependency error message early on from rouge_score import rouge_scorer, scoring import datasets _lowerCamelCase : List[str] = "\\n@inproceedings{lin-2004-rouge,\n title = \"{ROUGE}: A Package for Automatic Evaluation of Summaries\",\n author = \"Lin, Chin-Yew\",\n booktitle = \"Text Summarization Branches Out\",\n month = jul,\n year = \"2004\",\n address = \"Barcelona, Spain\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://www.aclweb.org/anthology/W04-1013\",\n pages = \"74--81\",\n}\n" _lowerCamelCase : Optional[int] = "\\nROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for\nevaluating automatic summarization and machine translation software in natural language processing.\nThe metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.\n\nNote that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.\n\nThis metrics is a wrapper around Google Research reimplementation of ROUGE:\nhttps://github.com/google-research/google-research/tree/master/rouge\n" _lowerCamelCase : str = "\nCalculates average rouge scores for a list of hypotheses and references\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n rouge_types: A list of rouge types to calculate.\n Valid names:\n `\"rouge{n}\"` (e.g. `\"rouge1\"`, `\"rouge2\"`) where: {n} is the n-gram based scoring,\n `\"rougeL\"`: Longest common subsequence based scoring.\n `\"rougeLSum\"`: rougeLsum splits text using `\"\n\"`.\n See details in https://github.com/huggingface/datasets/issues/617\n use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.\n use_aggregator: Return aggregates if this is set to True\nReturns:\n rouge1: rouge_1 (precision, recall, f1),\n rouge2: rouge_2 (precision, recall, f1),\n rougeL: rouge_l (precision, recall, f1),\n rougeLsum: rouge_lsum (precision, recall, f1)\nExamples:\n\n >>> rouge = datasets.load_metric('rouge')\n >>> predictions = [\"hello there\", \"general kenobi\"]\n >>> references = [\"hello there\", \"general kenobi\"]\n >>> results = rouge.compute(predictions=predictions, references=references)\n >>> print(list(results.keys()))\n ['rouge1', 'rouge2', 'rougeL', 'rougeLsum']\n >>> print(results[\"rouge1\"])\n AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0))\n >>> print(results[\"rouge1\"].mid.fmeasure)\n 1.0\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Union[str, Any] ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/google-research/google-research/tree/master/rouge'] , reference_urls=[ 'https://en.wikipedia.org/wiki/ROUGE_(metric)', 'https://github.com/google-research/google-research/tree/master/rouge', ] , ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : List[str]=None , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Optional[Any]=False ): """simple docstring""" if rouge_types is None: UpperCamelCase = ['rouge1', 'rouge2', 'rougeL', 'rougeLsum'] UpperCamelCase = rouge_scorer.RougeScorer(rouge_types=UpperCamelCase__ , use_stemmer=UpperCamelCase__ ) if use_aggregator: UpperCamelCase = scoring.BootstrapAggregator() else: UpperCamelCase = [] for ref, pred in zip(UpperCamelCase__ , UpperCamelCase__ ): UpperCamelCase = scorer.score(UpperCamelCase__ , UpperCamelCase__ ) if use_aggregator: aggregator.add_scores(UpperCamelCase__ ) else: scores.append(UpperCamelCase__ ) if use_aggregator: UpperCamelCase = aggregator.aggregate() else: UpperCamelCase = {} for key in scores[0]: UpperCamelCase = [score[key] for score in scores] return result
28
0
"""simple docstring""" import glob import os import random from string import ascii_lowercase, digits import cva import numpy as np # Parrameters lowerCAmelCase__ = (720, 1280) # Height, Width lowerCAmelCase__ = (0.4, 0.6) # if height or width lower than this scale, drop it. lowerCAmelCase__ = 1 / 100 lowerCAmelCase__ = "" lowerCAmelCase__ = "" lowerCAmelCase__ = "" lowerCAmelCase__ = 250 def snake_case_ ( ): '''simple docstring''' _lowerCamelCase , _lowerCamelCase : Optional[Any] = get_dataset(A__, A__ ) for index in range(A__ ): _lowerCamelCase : Optional[Any] = random.sample(range(len(A__ ) ), 4 ) _lowerCamelCase , _lowerCamelCase , _lowerCamelCase : Any = update_image_and_anno( A__, A__, A__, A__, A__, filter_scale=A__, ) # Get random string code: '7b7ad245cdff75241935e4dd860f3bad' _lowerCamelCase : str = random_chars(32 ) _lowerCamelCase : Union[str, Any] = path.split(os.sep )[-1].rsplit('''.''', 1 )[0] _lowerCamelCase : Tuple = F'''{OUTPUT_DIR}/{file_name}_MOSAIC_{letter_code}''' cva.imwrite(F'''{file_root}.jpg''', A__, [cva.IMWRITE_JPEG_QUALITY, 85] ) print(F'''Succeeded {index+1}/{NUMBER_IMAGES} with {file_name}''' ) _lowerCamelCase : Optional[Any] = [] for anno in new_annos: _lowerCamelCase : Optional[int] = anno[3] - anno[1] _lowerCamelCase : List[str] = anno[4] - anno[2] _lowerCamelCase : int = anno[1] + width / 2 _lowerCamelCase : Dict = anno[2] + height / 2 _lowerCamelCase : List[Any] = F'''{anno[0]} {x_center} {y_center} {width} {height}''' annos_list.append(A__ ) with open(F'''{file_root}.txt''', '''w''' ) as outfile: outfile.write('''\n'''.join(line for line in annos_list ) ) def snake_case_ ( A_ : List[Any], A_ : List[Any] ): '''simple docstring''' _lowerCamelCase : str = [] _lowerCamelCase : Optional[Any] = [] for label_file in glob.glob(os.path.join(A__, '''*.txt''' ) ): _lowerCamelCase : List[str] = label_file.split(os.sep )[-1].rsplit('''.''', 1 )[0] with open(A__ ) as in_file: _lowerCamelCase : List[str] = in_file.readlines() _lowerCamelCase : Optional[Any] = os.path.join(A__, F'''{label_name}.jpg''' ) _lowerCamelCase : Tuple = [] for obj_list in obj_lists: _lowerCamelCase : int = obj_list.rstrip('''\n''' ).split(''' ''' ) _lowerCamelCase : Optional[int] = float(obj[1] ) - float(obj[3] ) / 2 _lowerCamelCase : str = float(obj[2] ) - float(obj[4] ) / 2 _lowerCamelCase : Dict = float(obj[1] ) + float(obj[3] ) / 2 _lowerCamelCase : int = float(obj[2] ) + float(obj[4] ) / 2 boxes.append([int(obj[0] ), xmin, ymin, xmax, ymax] ) if not boxes: continue img_paths.append(A__ ) labels.append(A__ ) return img_paths, labels def snake_case_ ( A_ : Optional[Any], A_ : Dict, A_ : Optional[int], A_ : Optional[Any], A_ : Tuple, A_ : int = 0.0, ): '''simple docstring''' _lowerCamelCase : Union[str, Any] = np.zeros([output_size[0], output_size[1], 3], dtype=np.uinta ) _lowerCamelCase : str = scale_range[0] + random.random() * (scale_range[1] - scale_range[0]) _lowerCamelCase : Dict = scale_range[0] + random.random() * (scale_range[1] - scale_range[0]) _lowerCamelCase : Dict = int(scale_x * output_size[1] ) _lowerCamelCase : Optional[int] = int(scale_y * output_size[0] ) _lowerCamelCase : str = [] _lowerCamelCase : List[str] = [] for i, index in enumerate(A__ ): _lowerCamelCase : List[Any] = all_img_list[index] path_list.append(A__ ) _lowerCamelCase : Any = all_annos[index] _lowerCamelCase : str = cva.imread(A__ ) if i == 0: # top-left _lowerCamelCase : Union[str, Any] = cva.resize(A__, (divid_point_x, divid_point_y) ) _lowerCamelCase : Any = img for bbox in img_annos: _lowerCamelCase : List[Any] = bbox[1] * scale_x _lowerCamelCase : Optional[int] = bbox[2] * scale_y _lowerCamelCase : Any = bbox[3] * scale_x _lowerCamelCase : List[Any] = bbox[4] * scale_y new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) elif i == 1: # top-right _lowerCamelCase : Optional[int] = cva.resize(A__, (output_size[1] - divid_point_x, divid_point_y) ) _lowerCamelCase : Optional[Any] = img for bbox in img_annos: _lowerCamelCase : str = scale_x + bbox[1] * (1 - scale_x) _lowerCamelCase : Union[str, Any] = bbox[2] * scale_y _lowerCamelCase : List[Any] = scale_x + bbox[3] * (1 - scale_x) _lowerCamelCase : Dict = bbox[4] * scale_y new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) elif i == 2: # bottom-left _lowerCamelCase : str = cva.resize(A__, (divid_point_x, output_size[0] - divid_point_y) ) _lowerCamelCase : Optional[Any] = img for bbox in img_annos: _lowerCamelCase : Dict = bbox[1] * scale_x _lowerCamelCase : List[Any] = scale_y + bbox[2] * (1 - scale_y) _lowerCamelCase : Optional[int] = bbox[3] * scale_x _lowerCamelCase : Dict = scale_y + bbox[4] * (1 - scale_y) new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) else: # bottom-right _lowerCamelCase : Tuple = cva.resize( A__, (output_size[1] - divid_point_x, output_size[0] - divid_point_y) ) _lowerCamelCase : Tuple = img for bbox in img_annos: _lowerCamelCase : Any = scale_x + bbox[1] * (1 - scale_x) _lowerCamelCase : Optional[Any] = scale_y + bbox[2] * (1 - scale_y) _lowerCamelCase : List[str] = scale_x + bbox[3] * (1 - scale_x) _lowerCamelCase : Any = scale_y + bbox[4] * (1 - scale_y) new_anno.append([bbox[0], xmin, ymin, xmax, ymax] ) # Remove bounding box small than scale of filter if filter_scale > 0: _lowerCamelCase : Dict = [ anno for anno in new_anno if filter_scale < (anno[3] - anno[1]) and filter_scale < (anno[4] - anno[2]) ] return output_img, new_anno, path_list[0] def snake_case_ ( A_ : Optional[Any] ): '''simple docstring''' assert number_char > 1, "The number of character should greater than 1" _lowerCamelCase : List[Any] = ascii_lowercase + digits return "".join(random.choice(A__ ) for _ in range(A__ ) ) if __name__ == "__main__": main() print('''DONE ✅''')
72
'''simple docstring''' from PIL import Image def __lowerCamelCase ( A__ , A__ ) -> Image: """simple docstring""" def brightness(A__ ) -> float: return 128 + level + (c - 128) if not -255.0 <= level <= 255.0: raise ValueError('level must be between -255.0 (black) and 255.0 (white)' ) return img.point(A__ ) if __name__ == "__main__": # Load image with Image.open("image_data/lena.jpg") as img: # Change brightness to 100 _lowerCamelCase : List[str] = change_brightness(img, 100) brigt_img.save("image_data/lena_brightness.png", format="png")
28
0
from __future__ import annotations class A__: """simple docstring""" def __init__( self , _lowercase , _lowercase ) -> Optional[Any]: a_ , a_ : List[Any] = text, pattern a_ , a_ : List[Any] = len(UpperCamelCase__ ), len(UpperCamelCase__ ) def UpperCamelCase__ ( self , _lowercase ) -> List[str]: for i in range(self.patLen - 1 , -1 , -1 ): if char == self.pattern[i]: return i return -1 def UpperCamelCase__ ( self , _lowercase ) -> Dict: for i in range(self.patLen - 1 , -1 , -1 ): if self.pattern[i] != self.text[current_pos + i]: return current_pos + i return -1 def UpperCamelCase__ ( self ) -> str: a_ : Optional[Any] = [] for i in range(self.textLen - self.patLen + 1 ): a_ : Tuple = self.mismatch_in_text(UpperCamelCase__ ) if mismatch_index == -1: positions.append(UpperCamelCase__ ) else: a_ : Optional[Any] = self.match_in_pattern(self.text[mismatch_index] ) a_ : str = ( mismatch_index - match_index ) # shifting index lgtm [py/multiple-definition] return positions __snake_case : Optional[int] = "ABAABA" __snake_case : List[Any] = "AB" __snake_case : Union[str, Any] = BoyerMooreSearch(text, pattern) __snake_case : Optional[int] = bms.bad_character_heuristic() if len(positions) == 0: print("""No match found""") else: print("""Pattern found in following positions: """) print(positions)
248
'''simple docstring''' from . import ( albert, align, altclip, audio_spectrogram_transformer, auto, autoformer, bark, bart, barthez, bartpho, beit, bert, bert_generation, bert_japanese, bertweet, big_bird, bigbird_pegasus, biogpt, bit, blenderbot, blenderbot_small, blip, blip_a, bloom, bridgetower, byta, camembert, canine, chinese_clip, clap, clip, clipseg, codegen, conditional_detr, convbert, convnext, convnextva, cpm, cpmant, ctrl, cvt, dataavec, deberta, deberta_va, decision_transformer, deformable_detr, deit, deprecated, deta, detr, dialogpt, dinat, distilbert, dit, donut, dpr, dpt, efficientformer, efficientnet, electra, encodec, encoder_decoder, ernie, ernie_m, esm, falcon, flaubert, flava, fnet, focalnet, fsmt, funnel, git, glpn, gpta, gpt_bigcode, gpt_neo, gpt_neox, gpt_neox_japanese, gpt_swa, gptj, gptsan_japanese, graphormer, groupvit, herbert, hubert, ibert, imagegpt, informer, instructblip, jukebox, layoutlm, layoutlmva, layoutlmva, layoutxlm, led, levit, lilt, llama, longformer, longta, luke, lxmert, mam_aaa, marian, markuplm, maskaformer, maskformer, mbart, mbartaa, mega, megatron_bert, megatron_gpta, mgp_str, mluke, mobilebert, mobilenet_va, mobilenet_va, mobilevit, mobilevitva, mpnet, mra, mta, musicgen, mvp, nat, nezha, nllb, nllb_moe, nystromformer, oneformer, open_llama, openai, opt, owlvit, pegasus, pegasus_x, perceiver, phobert, pixastruct, plbart, poolformer, prophetnet, qdqbert, rag, realm, reformer, regnet, rembert, resnet, roberta, roberta_prelayernorm, roc_bert, roformer, rwkv, sam, segformer, sew, sew_d, speech_encoder_decoder, speech_to_text, speech_to_text_a, speechta, splinter, squeezebert, swiftformer, swin, swinasr, swinva, switch_transformers, ta, table_transformer, tapas, time_series_transformer, timesformer, timm_backbone, transfo_xl, trocr, tvlt, umta, unispeech, unispeech_sat, upernet, videomae, vilt, vision_encoder_decoder, vision_text_dual_encoder, visual_bert, vit, vit_hybrid, vit_mae, vit_msn, vivit, wavaveca, wavaveca_conformer, wavaveca_phoneme, wavaveca_with_lm, wavlm, whisper, x_clip, xglm, xlm, xlm_prophetnet, xlm_roberta, xlm_roberta_xl, xlnet, xmod, yolos, yoso, )
28
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 ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel from transformers.utils import logging logging.set_verbosity_info() _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE__ ( __a , __a=False ): snake_case_ : List[str] = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f"""blocks.{i}.norm1.weight""", f"""vit.encoder.layer.{i}.layernorm_before.weight""") ) rename_keys.append((f"""blocks.{i}.norm1.bias""", f"""vit.encoder.layer.{i}.layernorm_before.bias""") ) rename_keys.append((f"""blocks.{i}.attn.proj.weight""", f"""vit.encoder.layer.{i}.attention.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.attn.proj.bias""", f"""vit.encoder.layer.{i}.attention.output.dense.bias""") ) rename_keys.append((f"""blocks.{i}.norm2.weight""", f"""vit.encoder.layer.{i}.layernorm_after.weight""") ) rename_keys.append((f"""blocks.{i}.norm2.bias""", f"""vit.encoder.layer.{i}.layernorm_after.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.weight""", f"""vit.encoder.layer.{i}.intermediate.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc1.bias""", f"""vit.encoder.layer.{i}.intermediate.dense.bias""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.weight""", f"""vit.encoder.layer.{i}.output.dense.weight""") ) rename_keys.append((f"""blocks.{i}.mlp.fc2.bias""", f"""vit.encoder.layer.{i}.output.dense.bias""") ) # projection layer + position embeddings rename_keys.extend( [ ('cls_token', 'vit.embeddings.cls_token'), ('patch_embed.proj.weight', 'vit.embeddings.patch_embeddings.projection.weight'), ('patch_embed.proj.bias', 'vit.embeddings.patch_embeddings.projection.bias'), ('pos_embed', 'vit.embeddings.position_embeddings'), ] ) if base_model: # layernorm + pooler rename_keys.extend( [ ('norm.weight', 'layernorm.weight'), ('norm.bias', 'layernorm.bias'), ] ) # if just the base model, we should remove "vit" from all keys that start with "vit" snake_case_ : List[Any] = [(pair[0], pair[1][4:]) if pair[1].startswith('vit' ) else pair for pair in rename_keys] else: # layernorm + classification head rename_keys.extend( [ ('norm.weight', 'vit.layernorm.weight'), ('norm.bias', 'vit.layernorm.bias'), ('head.weight', 'classifier.weight'), ('head.bias', 'classifier.bias'), ] ) return rename_keys def SCREAMING_SNAKE_CASE__ ( __a , __a , __a=False ): for i in range(config.num_hidden_layers ): if base_model: snake_case_ : Optional[int] = '' else: snake_case_ : List[str] = 'vit.' # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) snake_case_ : Any = state_dict.pop(f"""blocks.{i}.attn.qkv.weight""" ) snake_case_ : Tuple = state_dict.pop(f"""blocks.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict snake_case_ : Tuple = in_proj_weight[ : config.hidden_size, : ] snake_case_ : Tuple = in_proj_bias[: config.hidden_size] snake_case_ : List[Any] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] snake_case_ : Union[str, Any] = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] snake_case_ : str = in_proj_weight[ -config.hidden_size :, : ] snake_case_ : Dict = in_proj_bias[-config.hidden_size :] def SCREAMING_SNAKE_CASE__ ( __a ): snake_case_ : Optional[int] = ['head.weight', 'head.bias'] for k in ignore_keys: state_dict.pop(A__ , A__ ) def SCREAMING_SNAKE_CASE__ ( __a , __a , __a ): snake_case_ : int = dct.pop(A__ ) snake_case_ : Dict = val def SCREAMING_SNAKE_CASE__ ( ): snake_case_ : str = 'http://images.cocodataset.org/val2017/000000039769.jpg' snake_case_ : Any = Image.open(requests.get(A__ , stream=A__ ).raw ) return im @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( __a , __a , __a=True ): snake_case_ : List[str] = ViTConfig() # patch_size if model_name[-1] == "8": snake_case_ : Optional[Any] = 8 # set labels if required if not base_model: snake_case_ : Any = 10_00 snake_case_ : Optional[int] = 'huggingface/label-files' snake_case_ : List[Any] = 'imagenet-1k-id2label.json' snake_case_ : List[Any] = json.load(open(hf_hub_download(A__ , A__ , repo_type='dataset' ) , 'r' ) ) snake_case_ : int = {int(A__ ): v for k, v in idalabel.items()} snake_case_ : str = idalabel snake_case_ : List[Any] = {v: k for k, v in idalabel.items()} # size of the architecture if model_name in ["dino_vits8", "dino_vits16"]: snake_case_ : Union[str, Any] = 3_84 snake_case_ : Optional[Any] = 15_36 snake_case_ : str = 12 snake_case_ : Optional[int] = 6 # load original model from torch hub snake_case_ : Any = torch.hub.load('facebookresearch/dino:main' , A__ ) original_model.eval() # load state_dict of original model, remove and rename some keys snake_case_ : List[str] = original_model.state_dict() if base_model: remove_classification_head_(A__ ) snake_case_ : Optional[int] = create_rename_keys(A__ , base_model=A__ ) for src, dest in rename_keys: rename_key(A__ , A__ , A__ ) read_in_q_k_v(A__ , A__ , A__ ) # load HuggingFace model if base_model: snake_case_ : str = ViTModel(A__ , add_pooling_layer=A__ ).eval() else: snake_case_ : Any = ViTForImageClassification(A__ ).eval() model.load_state_dict(A__ ) # Check outputs on an image, prepared by ViTImageProcessor snake_case_ : str = ViTImageProcessor() snake_case_ : List[Any] = image_processor(images=prepare_img() , return_tensors='pt' ) snake_case_ : Any = encoding['pixel_values'] snake_case_ : Union[str, Any] = model(A__ ) if base_model: snake_case_ : Optional[Any] = original_model(A__ ) assert torch.allclose(A__ , outputs.last_hidden_state[:, 0, :] , atol=1E-1 ) else: snake_case_ : Any = original_model(A__ ) assert logits.shape == outputs.logits.shape assert torch.allclose(A__ , outputs.logits , atol=1E-3 ) Path(A__ ).mkdir(exist_ok=A__ ) print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(A__ ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(A__ ) if __name__ == "__main__": _SCREAMING_SNAKE_CASE = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""dino_vitb16""", type=str, help="""Name of the model trained with DINO you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--base_model""", action="""store_true""", help="""Whether to only convert the base model (no projection head weights).""", ) parser.set_defaults(base_model=True) _SCREAMING_SNAKE_CASE = parser.parse_args() convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)
327
'''simple docstring''' import unittest from transformers import MraConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_torch_available(): import torch from transformers import ( MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, MraModel, ) from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST class SCREAMING_SNAKE_CASE : """simple docstring""" def __init__( self : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : Any=2 , UpperCamelCase__ : Union[str, Any]=8 , UpperCamelCase__ : List[Any]=True , UpperCamelCase__ : Any=True , UpperCamelCase__ : str=True , UpperCamelCase__ : Dict=True , UpperCamelCase__ : List[Any]=9_9 , UpperCamelCase__ : List[Any]=1_6 , UpperCamelCase__ : List[str]=5 , UpperCamelCase__ : Dict=2 , UpperCamelCase__ : Optional[int]=3_6 , UpperCamelCase__ : str="gelu" , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Dict=0.0 , UpperCamelCase__ : Optional[int]=5_1_2 , UpperCamelCase__ : Dict=1_6 , UpperCamelCase__ : List[str]=2 , UpperCamelCase__ : Any=0.0_2 , UpperCamelCase__ : str=3 , UpperCamelCase__ : Tuple=4 , UpperCamelCase__ : Union[str, Any]=None , ): """simple docstring""" UpperCamelCase = parent UpperCamelCase = batch_size UpperCamelCase = seq_length UpperCamelCase = is_training UpperCamelCase = use_input_mask UpperCamelCase = use_token_type_ids UpperCamelCase = use_labels UpperCamelCase = vocab_size UpperCamelCase = hidden_size UpperCamelCase = num_hidden_layers UpperCamelCase = num_attention_heads UpperCamelCase = intermediate_size UpperCamelCase = hidden_act UpperCamelCase = hidden_dropout_prob UpperCamelCase = attention_probs_dropout_prob UpperCamelCase = max_position_embeddings UpperCamelCase = type_vocab_size UpperCamelCase = type_sequence_label_size UpperCamelCase = initializer_range UpperCamelCase = num_labels UpperCamelCase = num_choices UpperCamelCase = scope def A ( self : int ): """simple docstring""" UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase = None if self.use_input_mask: UpperCamelCase = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase = None if self.use_token_type_ids: UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCamelCase = 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] , self.num_choices ) UpperCamelCase = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def A ( self : Optional[int] ): """simple docstring""" return MraConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=UpperCamelCase__ , initializer_range=self.initializer_range , ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.get_config() UpperCamelCase = 3_0_0 return config def A ( self : Tuple ): """simple docstring""" ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = self.prepare_config_and_inputs() UpperCamelCase = True UpperCamelCase = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCamelCase = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def A ( self : Tuple , UpperCamelCase__ : Tuple , UpperCamelCase__ : int , UpperCamelCase__ : Any , UpperCamelCase__ : Dict , UpperCamelCase__ : int , UpperCamelCase__ : List[str] , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = MraModel(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) UpperCamelCase = model(UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : List[str] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any] , UpperCamelCase__ : str , UpperCamelCase__ : Dict , UpperCamelCase__ : Optional[Any] , ): """simple docstring""" UpperCamelCase = True UpperCamelCase = MraModel(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , encoder_attention_mask=UpperCamelCase__ , ) UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , encoder_hidden_states=UpperCamelCase__ , ) UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def A ( self : int , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[Any] , UpperCamelCase__ : List[str] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[str] ): """simple docstring""" UpperCamelCase = MraForMaskedLM(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : List[str] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = MraForQuestionAnswering(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , start_positions=UpperCamelCase__ , end_positions=UpperCamelCase__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def A ( self : Optional[int] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Tuple ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForSequenceClassification(UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A ( self : Any , UpperCamelCase__ : Any , UpperCamelCase__ : str , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : int , UpperCamelCase__ : int , UpperCamelCase__ : Optional[Any] ): """simple docstring""" UpperCamelCase = self.num_labels UpperCamelCase = MraForTokenClassification(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) model.eval() UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def A ( self : int , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : Any , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Dict , UpperCamelCase__ : str , UpperCamelCase__ : Dict ): """simple docstring""" UpperCamelCase = self.num_choices UpperCamelCase = MraForMultipleChoice(config=UpperCamelCase__ ) model.to(UpperCamelCase__ ) 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( UpperCamelCase__ , attention_mask=UpperCamelCase__ , token_type_ids=UpperCamelCase__ , labels=UpperCamelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def A ( self : int ): """simple docstring""" UpperCamelCase = self.prepare_config_and_inputs() ( ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ( UpperCamelCase ) , ) = config_and_inputs UpperCamelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE ( _a , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( MraModel, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, ) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = () def A ( self : str ): """simple docstring""" UpperCamelCase = MraModelTester(self ) UpperCamelCase = ConfigTester(self , config_class=UpperCamelCase__ , hidden_size=3_7 ) def A ( self : str ): """simple docstring""" self.config_tester.run_common_tests() def A ( self : Optional[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : str ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: UpperCamelCase = type self.model_tester.create_and_check_model(*UpperCamelCase__ ) def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase__ ) def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase__ ) def A ( self : Tuple ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__ ) def A ( self : Any ): """simple docstring""" UpperCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__ ) @slow def A ( self : List[Any] ): """simple docstring""" for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase = MraModel.from_pretrained(UpperCamelCase__ ) self.assertIsNotNone(UpperCamelCase__ ) @unittest.skip(reason='MRA does not output attentions' ) def A ( self : List[str] ): """simple docstring""" return @require_torch class SCREAMING_SNAKE_CASE ( unittest.TestCase ): """simple docstring""" @slow def A ( self : Optional[int] ): """simple docstring""" UpperCamelCase = MraModel.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = torch.Size((1, 2_5_6, 7_6_8) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4' ) UpperCamelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 2_5_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) ) @slow def A ( self : List[Any] ): """simple docstring""" UpperCamelCase = MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3' ) UpperCamelCase = torch.arange(4_0_9_6 ).unsqueeze(0 ) with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ )[0] UpperCamelCase = 5_0_2_6_5 UpperCamelCase = torch.Size((1, 4_0_9_6, vocab_size) ) self.assertEqual(output.shape , UpperCamelCase__ ) UpperCamelCase = torch.tensor( [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , UpperCamelCase__ , atol=1E-4 ) )
28
0
from __future__ import annotations import math import numpy as np from numpy.linalg import norm def A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' return math.sqrt(sum(pow(a - b , 2 ) for a, b in zip(A__ , A__ ) ) ) def A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' if dataset.ndim != value_array.ndim: _lowerCAmelCase : Union[str, Any] = ( "Wrong input data\'s dimensions... " F"dataset : {dataset.ndim}, value_array : {value_array.ndim}" ) raise ValueError(A__ ) try: if dataset.shape[1] != value_array.shape[1]: _lowerCAmelCase : int = ( "Wrong input data\'s shape... " F"dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}" ) raise ValueError(A__ ) except IndexError: if dataset.ndim != value_array.ndim: raise TypeError("Wrong shape" ) if dataset.dtype != value_array.dtype: _lowerCAmelCase : List[Any] = ( "Input data have different datatype... " F"dataset : {dataset.dtype}, value_array : {value_array.dtype}" ) raise TypeError(A__ ) _lowerCAmelCase : int = [] for value in value_array: _lowerCAmelCase : Optional[Any] = euclidean(A__ , dataset[0] ) _lowerCAmelCase : List[str] = dataset[0].tolist() for dataset_value in dataset[1:]: _lowerCAmelCase : Tuple = euclidean(A__ , A__ ) if dist > temp_dist: _lowerCAmelCase : Tuple = temp_dist _lowerCAmelCase : Dict = dataset_value.tolist() answer.append([vector, dist] ) return answer def A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' return np.dot(A__ , A__ ) / (norm(A__ ) * norm(A__ )) if __name__ == "__main__": import doctest doctest.testmod()
36
'''simple docstring''' import numpy as np import torch from torch.nn import CrossEntropyLoss from transformers import AutoModelForCausalLM, AutoTokenizer import datasets from datasets import logging _lowerCamelCase : Union[str, Any] = "\\n\n" _lowerCamelCase : List[str] = "\nPerplexity (PPL) is one of the most common metrics for evaluating language models.\nIt is defined as the exponentiated average negative log-likelihood of a sequence.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n" _lowerCamelCase : Dict = "\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n input_texts (list of str): input text, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to 'cuda' when available\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = [\"lorem ipsum\", \"Happy Birthday!\", \"Bienvenue\"]\n >>> results = perplexity.compute(model_id='gpt2',\n ... add_start_token=False,\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 78.22\n >>> print(round(results[\"perplexities\"][0], 2))\n 11.11\n\n Example 2:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = datasets.load_dataset(\"wikitext\",\n ... \"wikitext-2-raw-v1\",\n ... split=\"test\")[\"text\"][:50] # doctest:+ELLIPSIS\n [...]\n >>> input_texts = [s for s in input_texts if s!='']\n >>> results = perplexity.compute(model_id='gpt2',\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 60.35\n >>> print(round(results[\"perplexities\"][0], 2))\n 81.12\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE ( datasets.Metric ): """simple docstring""" def A ( self : Tuple ): """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'input_texts': datasets.Value('string' ), } ) , reference_urls=['https://huggingface.co/docs/transformers/perplexity'] , ) def A ( self : Optional[Any] , UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : Optional[Any] , UpperCamelCase__ : int = 1_6 , UpperCamelCase__ : bool = True , UpperCamelCase__ : List[Any]=None ): """simple docstring""" if device is not None: assert device in ["gpu", "cpu", "cuda"], "device should be either gpu or cpu." if device == "gpu": UpperCamelCase = 'cuda' else: UpperCamelCase = 'cuda' if torch.cuda.is_available() else 'cpu' UpperCamelCase = AutoModelForCausalLM.from_pretrained(UpperCamelCase__ ) UpperCamelCase = model.to(UpperCamelCase__ ) UpperCamelCase = AutoTokenizer.from_pretrained(UpperCamelCase__ ) # if batch_size > 1 (which generally leads to padding being required), and # if there is not an already assigned pad_token, assign an existing # special token to also be the padding token if tokenizer.pad_token is None and batch_size > 1: UpperCamelCase = list(tokenizer.special_tokens_map_extended.values() ) # check that the model already has at least one special token defined assert ( len(UpperCamelCase__ ) > 0 ), "If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1." # assign one of the special tokens to also be the pad token tokenizer.add_special_tokens({'pad_token': existing_special_tokens[0]} ) if add_start_token: # leave room for <BOS> token to be added: assert ( tokenizer.bos_token is not None ), "Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False" UpperCamelCase = model.config.max_length - 1 else: UpperCamelCase = model.config.max_length UpperCamelCase = tokenizer( UpperCamelCase__ , add_special_tokens=UpperCamelCase__ , padding=UpperCamelCase__ , truncation=UpperCamelCase__ , max_length=UpperCamelCase__ , return_tensors='pt' , return_attention_mask=UpperCamelCase__ , ).to(UpperCamelCase__ ) UpperCamelCase = encodings['input_ids'] UpperCamelCase = encodings['attention_mask'] # check that each input is long enough: if add_start_token: assert torch.all(torch.ge(attn_masks.sum(1 ) , 1 ) ), "Each input text must be at least one token long." else: assert torch.all( torch.ge(attn_masks.sum(1 ) , 2 ) ), "When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings." UpperCamelCase = [] UpperCamelCase = CrossEntropyLoss(reduction='none' ) for start_index in logging.tqdm(range(0 , len(UpperCamelCase__ ) , UpperCamelCase__ ) ): UpperCamelCase = min(start_index + batch_size , len(UpperCamelCase__ ) ) UpperCamelCase = encoded_texts[start_index:end_index] UpperCamelCase = attn_masks[start_index:end_index] if add_start_token: UpperCamelCase = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0 ) ).to(UpperCamelCase__ ) UpperCamelCase = torch.cat([bos_tokens_tensor, encoded_batch] , dim=1 ) UpperCamelCase = torch.cat( [torch.ones(bos_tokens_tensor.size() , dtype=torch.intaa ).to(UpperCamelCase__ ), attn_mask] , dim=1 ) UpperCamelCase = encoded_batch with torch.no_grad(): UpperCamelCase = model(UpperCamelCase__ , attention_mask=UpperCamelCase__ ).logits UpperCamelCase = out_logits[..., :-1, :].contiguous() UpperCamelCase = labels[..., 1:].contiguous() UpperCamelCase = attn_mask[..., 1:].contiguous() UpperCamelCase = torch.expa( (loss_fct(shift_logits.transpose(1 , 2 ) , UpperCamelCase__ ) * shift_attention_mask_batch).sum(1 ) / shift_attention_mask_batch.sum(1 ) ) ppls += perplexity_batch.tolist() return {"perplexities": ppls, "mean_perplexity": np.mean(UpperCamelCase__ )}
28
0
from collections import deque from math import floor from random import random from time import time class lowerCamelCase : '''simple docstring''' def __init__( self ) -> Optional[int]: UpperCAmelCase_ : Dict = {} def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=1 ) -> List[Any]: if self.graph.get(_UpperCamelCase ): if self.graph[u].count([w, v] ) == 0: self.graph[u].append([w, v] ) else: UpperCAmelCase_ : Optional[int] = [[w, v]] if not self.graph.get(_UpperCamelCase ): UpperCAmelCase_ : int = [] def __UpperCAmelCase ( self ) -> Dict: return list(self.graph ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> int: if self.graph.get(_UpperCamelCase ): for _ in self.graph[u]: if _[1] == v: self.graph[u].remove(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Union[str, Any]: if s == d: return [] UpperCAmelCase_ : Optional[Any] = [] UpperCAmelCase_ : Optional[int] = [] if s == -2: UpperCAmelCase_ : Any = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = s while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Union[str, Any] = s for node in self.graph[s]: if visited.count(node[1] ) < 1: if node[1] == d: visited.append(_UpperCamelCase ) return visited else: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Tuple = node[1] break # check if all the children are visited if s == ss: stack.pop() if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Union[str, Any] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : int = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return visited def __UpperCAmelCase ( self , _UpperCamelCase=-1 ) -> Union[str, Any]: if c == -1: UpperCAmelCase_ : Any = floor(random() * 1_0_0_0_0 ) + 1_0 for i in range(_UpperCamelCase ): # every vertex has max 100 edges for _ in range(floor(random() * 1_0_2 ) + 1 ): UpperCAmelCase_ : int = floor(random() * c ) + 1 if n != i: self.add_pair(_UpperCamelCase , _UpperCamelCase , 1 ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Tuple: UpperCAmelCase_ : Union[str, Any] = deque() UpperCAmelCase_ : Dict = [] if s == -2: UpperCAmelCase_ : Tuple = list(self.graph )[0] d.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) while d: UpperCAmelCase_ : Any = d.popleft() if len(self.graph[s] ) != 0: for node in self.graph[s]: if visited.count(node[1] ) < 1: d.append(node[1] ) visited.append(node[1] ) return visited def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: UpperCAmelCase_ : Dict = 0 for x in self.graph: for y in self.graph[x]: if y[1] == u: count += 1 return count def __UpperCAmelCase ( self , _UpperCamelCase ) -> Dict: return len(self.graph[u] ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Optional[int]: UpperCAmelCase_ : Tuple = [] UpperCAmelCase_ : List[Any] = [] if s == -2: UpperCAmelCase_ : Optional[Any] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : Union[str, Any] = [] while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Tuple = s for node in self.graph[s]: if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Union[str, Any] = node[1] break # check if all the children are visited if s == ss: sorted_nodes.append(stack.pop() ) if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : List[Any] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[int] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return sorted_nodes def __UpperCAmelCase ( self ) -> int: UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : str = [] UpperCAmelCase_ : Union[str, Any] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Any = -2 UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : Optional[int] = False UpperCAmelCase_ : Any = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Union[str, Any] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Dict = len(_UpperCamelCase ) - 1 while len_stack >= 0: if stack[len_stack] == node[1]: anticipating_nodes.add(node[1] ) break else: anticipating_nodes.add(stack[len_stack] ) len_stack -= 1 if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Dict = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : Any = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : List[str] = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : int = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Tuple = s UpperCAmelCase_ : List[Any] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return list(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[int]: UpperCAmelCase_ : Union[str, Any] = [] UpperCAmelCase_ : Optional[Any] = [] UpperCAmelCase_ : Any = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Tuple = -2 UpperCAmelCase_ : Dict = [] UpperCAmelCase_ : Tuple = s UpperCAmelCase_ : Any = False UpperCAmelCase_ : Dict = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Optional[Any] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : int = len(_UpperCamelCase ) - 1 while len_stack_minus_one >= 0: if stack[len_stack_minus_one] == node[1]: anticipating_nodes.add(node[1] ) break else: return True if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[Any] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : List[Any] = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : int = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : List[Any] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = s UpperCAmelCase_ : Dict = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return False def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Tuple: UpperCAmelCase_ : Optional[int] = time() self.dfs(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = time() return end - begin def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> int: UpperCAmelCase_ : int = time() self.bfs(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = time() return end - begin class lowerCamelCase : '''simple docstring''' def __init__( self ) -> str: UpperCAmelCase_ : Optional[Any] = {} def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=1 ) -> Any: # check if the u exists if self.graph.get(_UpperCamelCase ): # if there already is a edge if self.graph[u].count([w, v] ) == 0: self.graph[u].append([w, v] ) else: # if u does not exist UpperCAmelCase_ : List[str] = [[w, v]] # add the other way if self.graph.get(_UpperCamelCase ): # if there already is a edge if self.graph[v].count([w, u] ) == 0: self.graph[v].append([w, u] ) else: # if u does not exist UpperCAmelCase_ : List[str] = [[w, u]] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> Union[str, Any]: if self.graph.get(_UpperCamelCase ): for _ in self.graph[u]: if _[1] == v: self.graph[u].remove(_UpperCamelCase ) # the other way round if self.graph.get(_UpperCamelCase ): for _ in self.graph[v]: if _[1] == u: self.graph[v].remove(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> List[str]: if s == d: return [] UpperCAmelCase_ : Union[str, Any] = [] UpperCAmelCase_ : Union[str, Any] = [] if s == -2: UpperCAmelCase_ : Tuple = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Dict = s while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : Tuple = s for node in self.graph[s]: if visited.count(node[1] ) < 1: if node[1] == d: visited.append(_UpperCamelCase ) return visited else: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[int] = node[1] break # check if all the children are visited if s == ss: stack.pop() if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Dict = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Dict = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return visited def __UpperCAmelCase ( self , _UpperCamelCase=-1 ) -> Any: if c == -1: UpperCAmelCase_ : List[str] = floor(random() * 1_0_0_0_0 ) + 1_0 for i in range(_UpperCamelCase ): # every vertex has max 100 edges for _ in range(floor(random() * 1_0_2 ) + 1 ): UpperCAmelCase_ : List[Any] = floor(random() * c ) + 1 if n != i: self.add_pair(_UpperCamelCase , _UpperCamelCase , 1 ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Optional[Any]: UpperCAmelCase_ : Optional[Any] = deque() UpperCAmelCase_ : List[str] = [] if s == -2: UpperCAmelCase_ : List[str] = list(self.graph )[0] d.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) while d: UpperCAmelCase_ : str = d.popleft() if len(self.graph[s] ) != 0: for node in self.graph[s]: if visited.count(node[1] ) < 1: d.append(node[1] ) visited.append(node[1] ) return visited def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[Any]: return len(self.graph[u] ) def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : int = [] UpperCAmelCase_ : int = [] UpperCAmelCase_ : str = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = -2 UpperCAmelCase_ : Optional[int] = [] UpperCAmelCase_ : List[Any] = s UpperCAmelCase_ : Any = False UpperCAmelCase_ : int = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : List[str] = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Any = len(_UpperCamelCase ) - 1 while len_stack >= 0: if stack[len_stack] == node[1]: anticipating_nodes.add(node[1] ) break else: anticipating_nodes.add(stack[len_stack] ) len_stack -= 1 if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[int] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : Optional[int] = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Any = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[Any] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = s UpperCAmelCase_ : Any = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return list(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : List[Any] = [] UpperCAmelCase_ : int = [] UpperCAmelCase_ : List[str] = list(self.graph )[0] stack.append(_UpperCamelCase ) visited.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = -2 UpperCAmelCase_ : Tuple = [] UpperCAmelCase_ : List[str] = s UpperCAmelCase_ : int = False UpperCAmelCase_ : Union[str, Any] = set() while True: # check if there is any non isolated nodes if len(self.graph[s] ) != 0: UpperCAmelCase_ : str = s for node in self.graph[s]: if ( visited.count(node[1] ) > 0 and node[1] != parent and indirect_parents.count(node[1] ) > 0 and not on_the_way_back ): UpperCAmelCase_ : Any = len(_UpperCamelCase ) - 1 while len_stack_minus_one >= 0: if stack[len_stack_minus_one] == node[1]: anticipating_nodes.add(node[1] ) break else: return True if visited.count(node[1] ) < 1: stack.append(node[1] ) visited.append(node[1] ) UpperCAmelCase_ : Optional[Any] = node[1] break # check if all the children are visited if s == ss: stack.pop() UpperCAmelCase_ : int = True if len(_UpperCamelCase ) != 0: UpperCAmelCase_ : Dict = stack[len(_UpperCamelCase ) - 1] else: UpperCAmelCase_ : Optional[int] = False indirect_parents.append(_UpperCamelCase ) UpperCAmelCase_ : Dict = s UpperCAmelCase_ : Optional[Any] = ss # check if se have reached the starting point if len(_UpperCamelCase ) == 0: return False def __UpperCAmelCase ( self ) -> List[str]: return list(self.graph ) def __UpperCAmelCase ( self , _UpperCamelCase=-2 , _UpperCamelCase=-1 ) -> Any: UpperCAmelCase_ : Optional[int] = time() self.dfs(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = time() return end - begin def __UpperCAmelCase ( self , _UpperCamelCase=-2 ) -> Tuple: UpperCAmelCase_ : Optional[Any] = time() self.bfs(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = time() return end - begin
29
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = '\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to("cuda")\n\n >>> prompt = "A red cartoon frog, 4k"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16\n ... )\n >>> pipe.to("cuda")\n\n >>> init_image = load_image(\n ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"\n ... "/kandinsky/frog.png"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save("red_frog.png")\n ```\n' def lowercase__ ( __snake_case : List[str] , __snake_case : int , __snake_case : Tuple=8 ): '''simple docstring''' UpperCAmelCase_ : Dict = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 UpperCAmelCase_ : List[Any] = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def lowercase__ ( __snake_case : Any , __snake_case : int=512 , __snake_case : Dict=512 ): '''simple docstring''' UpperCAmelCase_ : Tuple = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) UpperCAmelCase_ : Dict = np.array(pil_image.convert('RGB' ) ) UpperCAmelCase_ : Any = arr.astype(np.floataa ) / 127.5 - 1 UpperCAmelCase_ : Dict = np.transpose(__snake_case , [2, 0, 1] ) UpperCAmelCase_ : List[str] = torch.from_numpy(__snake_case ).unsqueeze(0 ) return image class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Union[str, Any]: super().__init__() self.register_modules( unet=_UpperCamelCase , scheduler=_UpperCamelCase , movq=_UpperCamelCase , ) UpperCAmelCase_ : Tuple = 2 ** (len(self.movq.config.block_out_channels ) - 1) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: # get the original timestep using init_timestep UpperCAmelCase_ : Any = min(int(num_inference_steps * strength ) , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = max(num_inference_steps - init_timestep , 0 ) UpperCAmelCase_ : str = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=None ) -> Tuple: if not isinstance(_UpperCamelCase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( f"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : List[str] = image.to(device=_UpperCamelCase , dtype=_UpperCamelCase ) UpperCAmelCase_ : List[str] = batch_size * num_images_per_prompt if image.shape[1] == 4: UpperCAmelCase_ : List[str] = image else: if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != batch_size: raise ValueError( f"You have passed a list of generators of length {len(_UpperCamelCase )}, but requested an effective batch" f" size of {batch_size}. Make sure the batch size matches the length of the generators." ) elif isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Any = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(_UpperCamelCase ) ] UpperCAmelCase_ : Tuple = torch.cat(_UpperCamelCase , dim=0 ) else: UpperCAmelCase_ : Union[str, Any] = self.movq.encode(_UpperCamelCase ).latent_dist.sample(_UpperCamelCase ) UpperCAmelCase_ : int = self.movq.config.scaling_factor * init_latents UpperCAmelCase_ : Optional[int] = torch.cat([init_latents] , dim=0 ) UpperCAmelCase_ : Tuple = init_latents.shape UpperCAmelCase_ : List[Any] = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) # get latents UpperCAmelCase_ : str = self.scheduler.add_noise(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = init_latents return latents def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Any: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) UpperCAmelCase_ : Optional[Any] = torch.device(f"cuda:{gpu_id}" ) UpperCAmelCase_ : Optional[Any] = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Union[str, Any]: if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) UpperCAmelCase_ : str = torch.device(f"cuda:{gpu_id}" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=_UpperCamelCase ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) UpperCAmelCase_ : Dict = None for cpu_offloaded_model in [self.unet, self.movq]: UpperCAmelCase_ , UpperCAmelCase_ : Dict = cpu_offload_with_hook(_UpperCamelCase , _UpperCamelCase , prev_module_hook=_UpperCamelCase ) # We'll offload the last model manually. UpperCAmelCase_ : Any = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def __UpperCAmelCase ( self ) -> Dict: if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(_UpperCamelCase , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(_UpperCamelCase ) def __call__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 1_0_0 , _UpperCamelCase = 4.0 , _UpperCamelCase = 0.3 , _UpperCamelCase = 1 , _UpperCamelCase = None , _UpperCamelCase = "pil" , _UpperCamelCase = True , ) -> str: UpperCAmelCase_ : Any = self._execution_device UpperCAmelCase_ : Union[str, Any] = guidance_scale > 1.0 if isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : str = torch.cat(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : Optional[Any] = image_embeds.shape[0] if isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Union[str, Any] = torch.cat(_UpperCamelCase , dim=0 ) if do_classifier_free_guidance: UpperCAmelCase_ : int = image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : int = negative_image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : Optional[Any] = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=_UpperCamelCase ) if not isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Tuple = [image] if not all(isinstance(_UpperCamelCase , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( f"Input is in incorrect format: {[type(_UpperCamelCase ) for i in image]}. Currently, we only support PIL image and pytorch tensor" ) UpperCAmelCase_ : str = torch.cat([prepare_image(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) for i in image] , dim=0 ) UpperCAmelCase_ : Any = image.to(dtype=image_embeds.dtype , device=_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.movq.encode(_UpperCamelCase )['latents'] UpperCAmelCase_ : List[Any] = latents.repeat_interleave(_UpperCamelCase , dim=0 ) self.scheduler.set_timesteps(_UpperCamelCase , device=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ : Any = self.get_timesteps(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = timesteps[:1].repeat(batch_size * num_images_per_prompt ) UpperCAmelCase_ , UpperCAmelCase_ : str = downscale_height_and_width(_UpperCamelCase , _UpperCamelCase , self.movq_scale_factor ) UpperCAmelCase_ : Dict = self.prepare_latents( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , image_embeds.dtype , _UpperCamelCase , _UpperCamelCase ) for i, t in enumerate(self.progress_bar(_UpperCamelCase ) ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : Optional[Any] = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : str = {'image_embeds': image_embeds} UpperCAmelCase_ : Union[str, Any] = self.unet( sample=_UpperCamelCase , timestep=_UpperCamelCase , encoder_hidden_states=_UpperCamelCase , added_cond_kwargs=_UpperCamelCase , return_dict=_UpperCamelCase , )[0] if do_classifier_free_guidance: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = noise_pred.split(latents.shape[1] , dim=1 ) UpperCAmelCase_ , UpperCAmelCase_ : str = noise_pred.chunk(2 ) UpperCAmelCase_ , UpperCAmelCase_ : str = variance_pred.chunk(2 ) UpperCAmelCase_ : Dict = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) UpperCAmelCase_ : Tuple = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): UpperCAmelCase_ , UpperCAmelCase_ : int = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 UpperCAmelCase_ : List[str] = self.scheduler.step( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , generator=_UpperCamelCase , )[0] # post-processing UpperCAmelCase_ : Optional[Any] = self.movq.decode(_UpperCamelCase , force_not_quantize=_UpperCamelCase )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}" ) if output_type in ["np", "pil"]: UpperCAmelCase_ : List[str] = image * 0.5 + 0.5 UpperCAmelCase_ : List[Any] = image.clamp(0 , 1 ) UpperCAmelCase_ : Dict = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": UpperCAmelCase_ : List[Any] = self.numpy_to_pil(_UpperCamelCase ) if not return_dict: return (image,) return ImagePipelineOutput(images=_UpperCamelCase )
29
1
import argparse from pathlib import Path import fairseq import torch from fairseq.models.xmod import XMODModel as FairseqXmodModel from packaging import version from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification from transformers.utils import logging if version.parse(fairseq.__version__) < version.parse('0.12.2'): raise Exception('requires fairseq >= 0.12.2') if version.parse(fairseq.__version__) > version.parse('2'): raise Exception('requires fairseq < v2') logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = 'Hello, World!' __UpperCAmelCase = 'en_XX' def lowercase__ ( __snake_case : str , __snake_case : str , __snake_case : bool ): '''simple docstring''' UpperCAmelCase_ : Any = Path('data_bin' ) UpperCAmelCase_ : Any = FairseqXmodModel.from_pretrained( model_name_or_path=str(Path(__snake_case ).parent ) , checkpoint_file=Path(__snake_case ).name , _name='xmod_base' , arch='xmod_base' , task='multilingual_masked_lm' , data_name_or_path=str(__snake_case ) , bpe='sentencepiece' , sentencepiece_model=str(Path(__snake_case ).parent / 'sentencepiece.bpe.model' ) , src_dict=str(data_dir / 'dict.txt' ) , ) xmod.eval() # disable dropout print(__snake_case ) UpperCAmelCase_ : Dict = xmod.model.encoder.sentence_encoder UpperCAmelCase_ : Dict = XmodConfig( vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings , hidden_size=xmod.cfg.model.encoder_embed_dim , num_hidden_layers=xmod.cfg.model.encoder_layers , num_attention_heads=xmod.cfg.model.encoder_attention_heads , intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim , max_position_embeddings=514 , type_vocab_size=1 , layer_norm_eps=1E-5 , pre_norm=xmod.cfg.model.encoder_normalize_before , adapter_reduction_factor=getattr(xmod.cfg.model , 'bottleneck' , 2 ) , adapter_layer_norm=xmod.cfg.model.adapter_layer_norm , adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm , ln_before_adapter=xmod.cfg.model.ln_before_adapter , languages=xmod.cfg.model.languages , ) if classification_head: UpperCAmelCase_ : Optional[Any] = xmod.model.classification_heads['mnli'].out_proj.weight.shape[0] print('Our X-MOD config:' , __snake_case ) UpperCAmelCase_ : int = XmodForSequenceClassification(__snake_case ) if classification_head else XmodForMaskedLM(__snake_case ) model.eval() # Now let's copy all the weights. # Embeddings UpperCAmelCase_ : Optional[int] = xmod_sent_encoder.embed_tokens.weight UpperCAmelCase_ : Optional[int] = xmod_sent_encoder.embed_positions.weight UpperCAmelCase_ : Optional[Any] = torch.zeros_like( model.roberta.embeddings.token_type_embeddings.weight ) # just zero them out b/c xmod doesn't use them. UpperCAmelCase_ : List[str] = xmod_sent_encoder.layernorm_embedding.weight UpperCAmelCase_ : Dict = xmod_sent_encoder.layernorm_embedding.bias for i in range(config.num_hidden_layers ): # Encoder: start of layer UpperCAmelCase_ : Dict = model.roberta.encoder.layer[i] UpperCAmelCase_ : List[Any] = xmod_sent_encoder.layers[i] # self attention UpperCAmelCase_ : Dict = layer.attention.self if not ( xmod_layer.self_attn.k_proj.weight.data.shape == xmod_layer.self_attn.q_proj.weight.data.shape == xmod_layer.self_attn.v_proj.weight.data.shape == torch.Size((config.hidden_size, config.hidden_size) ) ): raise AssertionError('Dimensions of self-attention weights do not match.' ) UpperCAmelCase_ : Optional[int] = xmod_layer.self_attn.q_proj.weight UpperCAmelCase_ : Optional[int] = xmod_layer.self_attn.q_proj.bias UpperCAmelCase_ : Tuple = xmod_layer.self_attn.k_proj.weight UpperCAmelCase_ : Optional[Any] = xmod_layer.self_attn.k_proj.bias UpperCAmelCase_ : Union[str, Any] = xmod_layer.self_attn.v_proj.weight UpperCAmelCase_ : List[str] = xmod_layer.self_attn.v_proj.bias # self-attention output UpperCAmelCase_ : int = layer.attention.output if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape: raise AssertionError('Dimensions of self-attention output weights do not match.' ) UpperCAmelCase_ : List[str] = xmod_layer.self_attn.out_proj.weight UpperCAmelCase_ : List[str] = xmod_layer.self_attn.out_proj.bias UpperCAmelCase_ : Any = xmod_layer.self_attn_layer_norm.weight UpperCAmelCase_ : Dict = xmod_layer.self_attn_layer_norm.bias # intermediate UpperCAmelCase_ : Optional[Any] = layer.intermediate if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape: raise AssertionError('Dimensions of intermediate weights do not match.' ) UpperCAmelCase_ : str = xmod_layer.fca.weight UpperCAmelCase_ : str = xmod_layer.fca.bias # output UpperCAmelCase_ : Tuple = layer.output if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape: raise AssertionError('Dimensions of feed-forward weights do not match.' ) UpperCAmelCase_ : Dict = xmod_layer.fca.weight UpperCAmelCase_ : Union[str, Any] = xmod_layer.fca.bias UpperCAmelCase_ : List[Any] = xmod_layer.final_layer_norm.weight UpperCAmelCase_ : List[Any] = xmod_layer.final_layer_norm.bias if bert_output.adapter_layer_norm is not None: UpperCAmelCase_ : Tuple = xmod_layer.adapter_layer_norm.weight UpperCAmelCase_ : List[Any] = xmod_layer.adapter_layer_norm.bias if sorted(bert_output.adapter_modules.keys() ) != sorted(xmod_layer.adapter_modules.keys() ): raise AssertionError('Lists of language adapters do not match.' ) for lang_code, adapter in xmod_layer.adapter_modules.items(): UpperCAmelCase_ : Optional[int] = bert_output.adapter_modules[lang_code] UpperCAmelCase_ : Any = xmod_layer.adapter_modules[lang_code] UpperCAmelCase_ : Any = from_adapter.fca.weight UpperCAmelCase_ : str = from_adapter.fca.bias UpperCAmelCase_ : List[Any] = from_adapter.fca.weight UpperCAmelCase_ : List[str] = from_adapter.fca.bias # end of layer if xmod_sent_encoder.layer_norm is not None: UpperCAmelCase_ : str = xmod_sent_encoder.layer_norm.weight UpperCAmelCase_ : List[Any] = xmod_sent_encoder.layer_norm.bias if classification_head: UpperCAmelCase_ : List[Any] = xmod.model.classification_heads['mnli'].dense.weight UpperCAmelCase_ : str = xmod.model.classification_heads['mnli'].dense.bias UpperCAmelCase_ : int = xmod.model.classification_heads['mnli'].out_proj.weight UpperCAmelCase_ : str = xmod.model.classification_heads['mnli'].out_proj.bias else: # LM Head UpperCAmelCase_ : List[Any] = xmod.model.encoder.lm_head.dense.weight UpperCAmelCase_ : Optional[Any] = xmod.model.encoder.lm_head.dense.bias UpperCAmelCase_ : List[str] = xmod.model.encoder.lm_head.layer_norm.weight UpperCAmelCase_ : Any = xmod.model.encoder.lm_head.layer_norm.bias UpperCAmelCase_ : Optional[Any] = xmod.model.encoder.lm_head.weight UpperCAmelCase_ : str = xmod.model.encoder.lm_head.bias # Let's check that we get the same results. UpperCAmelCase_ : List[Any] = xmod.encode(__snake_case ).unsqueeze(0 ) # batch of size 1 model.roberta.set_default_language(__snake_case ) UpperCAmelCase_ : Any = model(__snake_case )[0] if classification_head: UpperCAmelCase_ : int = xmod.model.classification_heads['mnli'](xmod.extract_features(__snake_case ) ) else: UpperCAmelCase_ : Optional[Any] = xmod.model(__snake_case , lang_id=[SAMPLE_LANGUAGE] )[0] print(our_output.shape , their_output.shape ) UpperCAmelCase_ : int = torch.max(torch.abs(our_output - their_output ) ).item() print(F"max_absolute_diff = {max_absolute_diff}" ) # ~ 1e-7 UpperCAmelCase_ : Union[str, Any] = torch.allclose(__snake_case , __snake_case , atol=1E-3 ) print('Do both models output the same tensors?' , '🔥' if success else '💩' ) if not success: raise Exception('Something went wRoNg' ) Path(__snake_case ).mkdir(parents=__snake_case , exist_ok=__snake_case ) print(F"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(__snake_case ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--xmod_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.' ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.' ) parser.add_argument( '--classification_head', action='store_true', help='Whether to convert a final classification head.' ) __UpperCAmelCase = parser.parse_args() convert_xmod_checkpoint_to_pytorch( args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head )
29
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def lowercase__ ( __snake_case : List[Any] , __snake_case : List[str]=False ): '''simple docstring''' try: UpperCAmelCase_ : int = os.environ[key] except KeyError: # KEY isn't set, default to `default`. UpperCAmelCase_ : Optional[int] = default else: # KEY is set, convert it to True or False. try: UpperCAmelCase_ : List[Any] = strtobool(__snake_case ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value __UpperCAmelCase = parse_flag_from_env('RUN_SLOW', default=False) def lowercase__ ( __snake_case : int ): '''simple docstring''' return unittest.skip('Test was skipped' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(__snake_case ) def lowercase__ ( __snake_case : Optional[int] ): '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(__snake_case ) def lowercase__ ( __snake_case : int ): '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(__snake_case ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(__snake_case ) def lowercase__ ( __snake_case : Dict=None , __snake_case : Dict=None ): '''simple docstring''' if test_case is None: return partial(__snake_case , version=__snake_case ) return unittest.skipUnless(is_torch_version('>=' , __snake_case ) , F"test requires torch version >= {version}" )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(__snake_case ) __UpperCAmelCase = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(__snake_case ) class lowerCamelCase (unittest.TestCase ): '''simple docstring''' _snake_case : Union[str, Any] = True @classmethod def __UpperCAmelCase ( cls ) -> Union[str, Any]: UpperCAmelCase_ : List[Any] = tempfile.mkdtemp() @classmethod def __UpperCAmelCase ( cls ) -> List[str]: if os.path.exists(cls.tmpdir ): shutil.rmtree(cls.tmpdir ) def __UpperCAmelCase ( self ) -> str: if self.clear_on_setup: for path in Path(self.tmpdir ).glob('**/*' ): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(_UpperCamelCase ) class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Optional[int]: super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: UpperCAmelCase_ : List[Any] = mocks if isinstance(_UpperCamelCase , (tuple, list) ) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : int = AcceleratorState() UpperCAmelCase_ : str = tensor[None].clone().to(state.device ) UpperCAmelCase_ : List[str] = gather(__snake_case ).cpu() UpperCAmelCase_ : List[Any] = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , __snake_case ): return False return True class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : str = returncode UpperCAmelCase_ : Optional[Any] = stdout UpperCAmelCase_ : Optional[Any] = stderr async def lowercase__ ( __snake_case : Optional[Any] , __snake_case : Optional[int] ): '''simple docstring''' while True: UpperCAmelCase_ : Dict = await stream.readline() if line: callback(__snake_case ) else: break async def lowercase__ ( __snake_case : Optional[int] , __snake_case : Dict=None , __snake_case : str=None , __snake_case : Dict=None , __snake_case : List[str]=False , __snake_case : Optional[int]=False ): '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(__snake_case ) ) UpperCAmelCase_ : Optional[Any] = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=__snake_case , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=__snake_case , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) UpperCAmelCase_ : Any = [] UpperCAmelCase_ : str = [] def tee(__snake_case : Dict , __snake_case : Union[str, Any] , __snake_case : Tuple , __snake_case : Optional[int]="" ): UpperCAmelCase_ : List[str] = line.decode('utf-8' ).rstrip() sink.append(__snake_case ) if not quiet: print(__snake_case , __snake_case , file=__snake_case ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda __snake_case : tee(__snake_case , __snake_case , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda __snake_case : tee(__snake_case , __snake_case , sys.stderr , label='stderr:' ) ) ), ] , timeout=__snake_case , ) return _RunOutput(await p.wait() , __snake_case , __snake_case ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : List[Any]=None , __snake_case : str=None , __snake_case : Tuple=180 , __snake_case : Dict=False , __snake_case : Optional[Any]=True ): '''simple docstring''' UpperCAmelCase_ : str = asyncio.get_event_loop() UpperCAmelCase_ : int = loop.run_until_complete( _stream_subprocess(__snake_case , env=__snake_case , stdin=__snake_case , timeout=__snake_case , quiet=__snake_case , echo=__snake_case ) ) UpperCAmelCase_ : int = ' '.join(__snake_case ) if result.returncode > 0: UpperCAmelCase_ : int = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class lowerCamelCase (_snake_case ): '''simple docstring''' pass def lowercase__ ( __snake_case : List[str] , __snake_case : List[Any]=False ): '''simple docstring''' try: UpperCAmelCase_ : List[Any] = subprocess.check_output(__snake_case , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(__snake_case , 'decode' ): UpperCAmelCase_ : str = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(__snake_case )}` failed with the following error:\n\n{e.output.decode()}" ) from e
29
1
from dataclasses import dataclass from typing import Dict, Optional, Tuple, Union import torch import torch.nn as nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, apply_forward_hook from .attention_processor import AttentionProcessor, AttnProcessor from .modeling_utils import ModelMixin from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : "DiagonalGaussianDistribution" class lowerCamelCase (_snake_case , _snake_case ): '''simple docstring''' _snake_case : Optional[int] = True @register_to_config def __init__( self , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = ("DownEncoderBlock2D",) , _UpperCamelCase = ("UpDecoderBlock2D",) , _UpperCamelCase = (6_4,) , _UpperCamelCase = 1 , _UpperCamelCase = "silu" , _UpperCamelCase = 4 , _UpperCamelCase = 3_2 , _UpperCamelCase = 3_2 , _UpperCamelCase = 0.1_82_15 , ) -> List[Any]: super().__init__() # pass init params to Encoder UpperCAmelCase_ : List[str] = Encoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , down_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , act_fn=_UpperCamelCase , norm_num_groups=_UpperCamelCase , double_z=_UpperCamelCase , ) # pass init params to Decoder UpperCAmelCase_ : Dict = Decoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , up_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , norm_num_groups=_UpperCamelCase , act_fn=_UpperCamelCase , ) UpperCAmelCase_ : Any = nn.Convad(2 * latent_channels , 2 * latent_channels , 1 ) UpperCAmelCase_ : List[Any] = nn.Convad(_UpperCamelCase , _UpperCamelCase , 1 ) UpperCAmelCase_ : Any = False UpperCAmelCase_ : int = False # only relevant if vae tiling is enabled UpperCAmelCase_ : Optional[int] = self.config.sample_size UpperCAmelCase_ : int = ( self.config.sample_size[0] if isinstance(self.config.sample_size , (list, tuple) ) else self.config.sample_size ) UpperCAmelCase_ : Union[str, Any] = int(sample_size / (2 ** (len(self.config.block_out_channels ) - 1)) ) UpperCAmelCase_ : Optional[Any] = 0.25 def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=False ) -> List[str]: if isinstance(_UpperCamelCase , (Encoder, Decoder) ): UpperCAmelCase_ : Union[str, Any] = value def __UpperCAmelCase ( self , _UpperCamelCase = True ) -> int: UpperCAmelCase_ : Tuple = use_tiling def __UpperCAmelCase ( self ) -> Dict: self.enable_tiling(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: UpperCAmelCase_ : str = True def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Optional[int] = False @property # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors def __UpperCAmelCase ( self ) -> Dict[str, AttentionProcessor]: UpperCAmelCase_ : Optional[int] = {} def fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): UpperCAmelCase_ : Optional[int] = module.processor for sub_name, child in module.named_children(): fn_recursive_add_processors(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) return processors for name, module in self.named_children(): fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return processors def __UpperCAmelCase ( self , _UpperCamelCase ) -> List[Any]: UpperCAmelCase_ : Union[str, Any] = len(self.attn_processors.keys() ) if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != count: raise ValueError( f"A dict of processors was passed, but the number of processors {len(_UpperCamelCase )} does not match the" f" number of attention layers: {count}. Please make sure to pass {count} processor classes." ) def fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): if not isinstance(_UpperCamelCase , _UpperCamelCase ): module.set_processor(_UpperCamelCase ) else: module.set_processor(processor.pop(f"{name}.processor" ) ) for sub_name, child in module.named_children(): fn_recursive_attn_processor(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) for name, module in self.named_children(): fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Union[str, Any]: self.set_attn_processor(AttnProcessor() ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size): return self.tiled_encode(_UpperCamelCase , return_dict=_UpperCamelCase ) if self.use_slicing and x.shape[0] > 1: UpperCAmelCase_ : Union[str, Any] = [self.encoder(_UpperCamelCase ) for x_slice in x.split(1 )] UpperCAmelCase_ : Tuple = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : List[Any] = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size): return self.tiled_decode(_UpperCamelCase , return_dict=_UpperCamelCase ) UpperCAmelCase_ : str = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.decoder(_UpperCamelCase ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_slicing and z.shape[0] > 1: UpperCAmelCase_ : List[str] = [self._decode(_UpperCamelCase ).sample for z_slice in z.split(1 )] UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : Any = self._decode(_UpperCamelCase ).sample if not return_dict: return (decoded,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : Tuple = min(a.shape[2] , b.shape[2] , _UpperCamelCase ) for y in range(_UpperCamelCase ): UpperCAmelCase_ : str = a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: UpperCAmelCase_ : Tuple = min(a.shape[3] , b.shape[3] , _UpperCamelCase ) for x in range(_UpperCamelCase ): UpperCAmelCase_ : int = a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: UpperCAmelCase_ : Any = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Tuple = int(self.tile_latent_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Optional[int] = self.tile_latent_min_size - blend_extent # Split the image into 512x512 tiles and encode them separately. UpperCAmelCase_ : List[str] = [] for i in range(0 , x.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : Any = [] for j in range(0 , x.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : Any = x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size] UpperCAmelCase_ : Dict = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.quant_conv(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : str = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Dict = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : List[str] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Union[str, Any] = torch.cat(_UpperCamelCase , dim=2 ) UpperCAmelCase_ : List[Any] = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : str = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Dict = int(self.tile_sample_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Dict = self.tile_sample_min_size - blend_extent # Split z into overlapping 64x64 tiles and decode them separately. # The tiles have an overlap to avoid seams between tiles. UpperCAmelCase_ : Union[str, Any] = [] for i in range(0 , z.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = [] for j in range(0 , z.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size] UpperCAmelCase_ : Optional[Any] = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = self.decoder(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Union[str, Any] = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : Optional[Any] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase , dim=2 ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = False , _UpperCamelCase = True , _UpperCamelCase = None , ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : Optional[Any] = sample UpperCAmelCase_ : Union[str, Any] = self.encode(_UpperCamelCase ).latent_dist if sample_posterior: UpperCAmelCase_ : str = posterior.sample(generator=_UpperCamelCase ) else: UpperCAmelCase_ : int = posterior.mode() UpperCAmelCase_ : Dict = self.decode(_UpperCamelCase ).sample if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase )
29
import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed __UpperCAmelCase = logging.getLogger(__name__) def lowercase__ ( __snake_case : List[Any]=2 , __snake_case : Union[str, Any]=3 , __snake_case : Any=16 , __snake_case : int = 10 , __snake_case : int = 2 ): '''simple docstring''' def get_dataset(__snake_case : Optional[Any] ): UpperCAmelCase_ : Optional[Any] = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(__snake_case , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCAmelCase_ : Any = get_dataset(__snake_case ) UpperCAmelCase_ : str = get_dataset(__snake_case ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) return (train_dataloader, valid_dataloader) def lowercase__ ( __snake_case : Optional[int] , __snake_case : str , __snake_case : Optional[int] , __snake_case : List[str] , __snake_case : Any , __snake_case : Tuple=None ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = [] for epoch in range(__snake_case ): # Train quickly model.train() for batch in dataloader: UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = batch UpperCAmelCase_ : List[Any] = model(__snake_case ) UpperCAmelCase_ : int = torch.nn.functional.mse_loss(__snake_case , __snake_case ) accelerator.backward(__snake_case ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class lowerCamelCase (nn.Module ): '''simple docstring''' def __init__( self ) -> Optional[Any]: super().__init__() UpperCAmelCase_ : List[Any] = nn.Parameter(torch.randn(1 ) ) UpperCAmelCase_ : Optional[int] = nn.Parameter(torch.randn(1 ) ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[Any]: return x * self.a + self.b class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Optional[int] = ProjectConfiguration(total_limit=1 , project_dir=_UpperCamelCase , automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Dict = Accelerator(project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[Any] = DummyModel() UpperCAmelCase_ : str = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() # Train baseline UpperCAmelCase_ : Tuple = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial UpperCAmelCase_ : Any = os.path.join(_UpperCamelCase , 'initial' ) accelerator.save_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() UpperCAmelCase_ : Union[str, Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Union[str, Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Any = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : int = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : str = dummy_dataloaders() UpperCAmelCase_ : Optional[Any] = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Tuple = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[str] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Dict = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything UpperCAmelCase_ : Union[str, Any] = os.path.join(_UpperCamelCase , 'checkpoint' ) accelerator.save_state(_UpperCamelCase ) # Load everything back in and make sure all states work accelerator.load_state(_UpperCamelCase ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Union[str, Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : Optional[int] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = dummy_dataloaders() UpperCAmelCase_ : Any = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : str = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() UpperCAmelCase_ : Optional[Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Tuple = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : Any = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : str = model.a.item(), model.b.item() UpperCAmelCase_ : List[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Dict: UpperCAmelCase_ : Optional[Any] = torch.tensor([1, 2, 3] ) UpperCAmelCase_ : Any = torch.tensor([2, 3, 4] ) UpperCAmelCase_ : Union[str, Any] = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(net.parameters() ) UpperCAmelCase_ : Any = Accelerator() with self.assertRaises(_UpperCamelCase ) as ve: accelerator.register_for_checkpointing(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ : Dict = torch.optim.lr_scheduler.StepLR(_UpperCamelCase , step_size=1 , gamma=0.99 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Tuple = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() UpperCAmelCase_ : Dict = scheduler.state_dict() train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) self.assertNotEqual(_UpperCamelCase , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(_UpperCamelCase , scheduler.state_dict() ) def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[int] = DummyModel() UpperCAmelCase_ : Dict = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase , total_limit=2 ) # Train baseline UpperCAmelCase_ : Optional[int] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ : str = accelerator.prepare(_UpperCamelCase ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : List[str] = ['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )] execute_subprocess_async(_UpperCamelCase , env=os.environ.copy() ) if __name__ == "__main__": __UpperCAmelCase = '/tmp/accelerate/state_checkpointing' __UpperCAmelCase = DummyModel() __UpperCAmelCase = torch.optim.Adam(params=model.parameters(), lr=1E-3) __UpperCAmelCase = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9) __UpperCAmelCase , __UpperCAmelCase = dummy_dataloaders() __UpperCAmelCase = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline __UpperCAmelCase = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision='no') if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert param_device.type == accelerator.device.type __UpperCAmelCase = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='cpu') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == torch.device('cpu').type ), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='on_device') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == accelerator.device.type ), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match='Unsupported optimizer map location passed'): accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='invalid') accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
29
1
import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed __UpperCAmelCase = logging.getLogger(__name__) def lowercase__ ( __snake_case : List[Any]=2 , __snake_case : Union[str, Any]=3 , __snake_case : Any=16 , __snake_case : int = 10 , __snake_case : int = 2 ): '''simple docstring''' def get_dataset(__snake_case : Optional[Any] ): UpperCAmelCase_ : Optional[Any] = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(__snake_case , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCAmelCase_ : Any = get_dataset(__snake_case ) UpperCAmelCase_ : str = get_dataset(__snake_case ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) return (train_dataloader, valid_dataloader) def lowercase__ ( __snake_case : Optional[int] , __snake_case : str , __snake_case : Optional[int] , __snake_case : List[str] , __snake_case : Any , __snake_case : Tuple=None ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = [] for epoch in range(__snake_case ): # Train quickly model.train() for batch in dataloader: UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = batch UpperCAmelCase_ : List[Any] = model(__snake_case ) UpperCAmelCase_ : int = torch.nn.functional.mse_loss(__snake_case , __snake_case ) accelerator.backward(__snake_case ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class lowerCamelCase (nn.Module ): '''simple docstring''' def __init__( self ) -> Optional[Any]: super().__init__() UpperCAmelCase_ : List[Any] = nn.Parameter(torch.randn(1 ) ) UpperCAmelCase_ : Optional[int] = nn.Parameter(torch.randn(1 ) ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[Any]: return x * self.a + self.b class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Optional[int] = ProjectConfiguration(total_limit=1 , project_dir=_UpperCamelCase , automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Dict = Accelerator(project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[Any] = DummyModel() UpperCAmelCase_ : str = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() # Train baseline UpperCAmelCase_ : Tuple = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial UpperCAmelCase_ : Any = os.path.join(_UpperCamelCase , 'initial' ) accelerator.save_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() UpperCAmelCase_ : Union[str, Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Union[str, Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Any = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : int = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : str = dummy_dataloaders() UpperCAmelCase_ : Optional[Any] = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Tuple = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[str] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Dict = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything UpperCAmelCase_ : Union[str, Any] = os.path.join(_UpperCamelCase , 'checkpoint' ) accelerator.save_state(_UpperCamelCase ) # Load everything back in and make sure all states work accelerator.load_state(_UpperCamelCase ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Union[str, Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : Optional[int] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = dummy_dataloaders() UpperCAmelCase_ : Any = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : str = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() UpperCAmelCase_ : Optional[Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Tuple = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : Any = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : str = model.a.item(), model.b.item() UpperCAmelCase_ : List[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Dict: UpperCAmelCase_ : Optional[Any] = torch.tensor([1, 2, 3] ) UpperCAmelCase_ : Any = torch.tensor([2, 3, 4] ) UpperCAmelCase_ : Union[str, Any] = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(net.parameters() ) UpperCAmelCase_ : Any = Accelerator() with self.assertRaises(_UpperCamelCase ) as ve: accelerator.register_for_checkpointing(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ : Dict = torch.optim.lr_scheduler.StepLR(_UpperCamelCase , step_size=1 , gamma=0.99 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Tuple = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() UpperCAmelCase_ : Dict = scheduler.state_dict() train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) self.assertNotEqual(_UpperCamelCase , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(_UpperCamelCase , scheduler.state_dict() ) def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[int] = DummyModel() UpperCAmelCase_ : Dict = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase , total_limit=2 ) # Train baseline UpperCAmelCase_ : Optional[int] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ : str = accelerator.prepare(_UpperCamelCase ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : List[str] = ['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )] execute_subprocess_async(_UpperCamelCase , env=os.environ.copy() ) if __name__ == "__main__": __UpperCAmelCase = '/tmp/accelerate/state_checkpointing' __UpperCAmelCase = DummyModel() __UpperCAmelCase = torch.optim.Adam(params=model.parameters(), lr=1E-3) __UpperCAmelCase = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9) __UpperCAmelCase , __UpperCAmelCase = dummy_dataloaders() __UpperCAmelCase = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline __UpperCAmelCase = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision='no') if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert param_device.type == accelerator.device.type __UpperCAmelCase = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='cpu') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == torch.device('cpu').type ), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='on_device') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == accelerator.device.type ), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match='Unsupported optimizer map location passed'): accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='invalid') accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
29
import warnings from ...utils import logging from .image_processing_imagegpt import ImageGPTImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , *_UpperCamelCase , **_UpperCamelCase ) -> None: warnings.warn( 'The class ImageGPTFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use ImageGPTImageProcessor instead.' , _UpperCamelCase , ) super().__init__(*_UpperCamelCase , **_UpperCamelCase )
29
1
import numpy as np from nltk.translate import meteor_score import datasets from datasets.config import importlib_metadata, version __UpperCAmelCase = version.parse(importlib_metadata.version('nltk')) if NLTK_VERSION >= version.Version('3.6.4'): from nltk import word_tokenize __UpperCAmelCase = '\\n@inproceedings{banarjee2005,\n title = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n author = {Banerjee, Satanjeev and Lavie, Alon},\n booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n month = jun,\n year = {2005},\n address = {Ann Arbor, Michigan},\n publisher = {Association for Computational Linguistics},\n url = {https://www.aclweb.org/anthology/W05-0909},\n pages = {65--72},\n}\n' __UpperCAmelCase = '\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n' __UpperCAmelCase = '\nComputes METEOR score of translated segments against one or more references.\nArgs:\n predictions: list of predictions to score. Each prediction\n should be a string with tokens separated by spaces.\n references: list of reference for each prediction. Each\n reference should be a string with tokens separated by spaces.\n alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n \'meteor\': meteor score.\nExamples:\n\n >>> meteor = datasets.load_metric(\'meteor\')\n >>> predictions = ["It is a guide to action which ensures that the military always obeys the commands of the party"]\n >>> references = ["It is a guide to action that ensures that the military will forever heed Party commands"]\n >>> results = meteor.compute(predictions=predictions, references=references)\n >>> print(round(results["meteor"], 4))\n 0.6944\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class lowerCamelCase (datasets.Metric ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Union[str, Any]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': datasets.Value('string' , id='sequence' ), 'references': datasets.Value('string' , id='sequence' ), } ) , codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py'] , reference_urls=[ 'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score', 'https://en.wikipedia.org/wiki/METEOR', ] , ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> List[Any]: import nltk nltk.download('wordnet' ) if NLTK_VERSION >= version.Version('3.6.5' ): nltk.download('punkt' ) if NLTK_VERSION >= version.Version('3.6.6' ): nltk.download('omw-1.4' ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=0.9 , _UpperCamelCase=3 , _UpperCamelCase=0.5 ) -> List[str]: if NLTK_VERSION >= version.Version('3.6.5' ): UpperCAmelCase_ : Any = [ meteor_score.single_meteor_score( word_tokenize(_UpperCamelCase ) , word_tokenize(_UpperCamelCase ) , alpha=_UpperCamelCase , beta=_UpperCamelCase , gamma=_UpperCamelCase ) for ref, pred in zip(_UpperCamelCase , _UpperCamelCase ) ] else: UpperCAmelCase_ : Dict = [ meteor_score.single_meteor_score(_UpperCamelCase , _UpperCamelCase , alpha=_UpperCamelCase , beta=_UpperCamelCase , gamma=_UpperCamelCase ) for ref, pred in zip(_UpperCamelCase , _UpperCamelCase ) ] return {"meteor": np.mean(_UpperCamelCase )}
29
def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if not head: return True # split the list to two parts UpperCAmelCase_ , UpperCAmelCase_ : Any = head.next, head while fast and fast.next: UpperCAmelCase_ : str = fast.next.next UpperCAmelCase_ : Union[str, Any] = slow.next UpperCAmelCase_ : int = slow.next UpperCAmelCase_ : List[Any] = None # Don't forget here! But forget still works! # reverse the second part UpperCAmelCase_ : Tuple = None while second: UpperCAmelCase_ : int = second.next UpperCAmelCase_ : Any = node UpperCAmelCase_ : Optional[Any] = second UpperCAmelCase_ : Tuple = nxt # compare two parts # second part has the same or one less node while node: if node.val != head.val: return False UpperCAmelCase_ : Optional[Any] = node.next UpperCAmelCase_ : Dict = head.next return True def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' if not head or not head.next: return True # 1. Get the midpoint (slow) UpperCAmelCase_ : Any = head while fast and fast.next: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = fast.next.next, slow.next # 2. Push the second half into the stack UpperCAmelCase_ : List[str] = [slow.val] while slow.next: UpperCAmelCase_ : List[str] = slow.next stack.append(slow.val ) # 3. Comparison while stack: if stack.pop() != cur.val: return False UpperCAmelCase_ : int = cur.next return True def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if not head or not head.next: return True UpperCAmelCase_ : Tuple = {} UpperCAmelCase_ : int = 0 while head: if head.val in d: d[head.val].append(__snake_case ) else: UpperCAmelCase_ : List[Any] = [pos] UpperCAmelCase_ : Any = head.next pos += 1 UpperCAmelCase_ : Dict = pos - 1 UpperCAmelCase_ : Optional[int] = 0 for v in d.values(): if len(__snake_case ) % 2 != 0: middle += 1 else: UpperCAmelCase_ : int = 0 for i in range(0 , len(__snake_case ) ): if v[i] + v[len(__snake_case ) - 1 - step] != checksum: return False step += 1 if middle > 1: return False return True
29
1
__UpperCAmelCase = { "km/h": 1.0, "m/s": 3.6, "mph": 1.6_0_9_3_4_4, "knot": 1.8_5_2, } __UpperCAmelCase = { "km/h": 1.0, "m/s": 0.2_7_7_7_7_7_7_7_8, "mph": 0.6_2_1_3_7_1_1_9_2, "knot": 0.5_3_9_9_5_6_8_0_3, } def lowercase__ ( __snake_case : float , __snake_case : str , __snake_case : str ): '''simple docstring''' if unit_to not in speed_chart or unit_from not in speed_chart_inverse: UpperCAmelCase_ : Optional[int] = ( F"Incorrect 'from_type' or 'to_type' value: {unit_from!r}, {unit_to!r}\n" F"Valid values are: {', '.join(__snake_case )}" ) raise ValueError(__snake_case ) return round(speed * speed_chart[unit_from] * speed_chart_inverse[unit_to] , 3 ) if __name__ == "__main__": import doctest doctest.testmod()
29
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = {'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST', 'ViTMSNModel', 'ViTMSNForImageClassification', 'ViTMSNPreTrainedModel', ] if TYPE_CHECKING: from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_msn import ( VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMSNForImageClassification, ViTMSNModel, ViTMSNPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
1
from math import ceil, sqrt def lowercase__ ( __snake_case : int = 1_000_000 ): '''simple docstring''' UpperCAmelCase_ : List[Any] = 0 for outer_width in range(3 , (limit // 4) + 2 ): if outer_width**2 > limit: UpperCAmelCase_ : Union[str, Any] = max(ceil(sqrt(outer_width**2 - limit ) ) , 1 ) else: UpperCAmelCase_ : List[str] = 1 if (outer_width - hole_width_lower_bound) % 2: hole_width_lower_bound += 1 answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1 return answer if __name__ == "__main__": print(F'{solution() = }')
29
__UpperCAmelCase = { 'Pillow': 'Pillow<10.0.0', 'accelerate': 'accelerate>=0.20.3', 'av': 'av==9.2.0', 'beautifulsoup4': 'beautifulsoup4', 'black': 'black~=23.1', 'codecarbon': 'codecarbon==1.2.0', 'cookiecutter': 'cookiecutter==1.7.3', 'dataclasses': 'dataclasses', 'datasets': 'datasets!=2.5.0', 'decord': 'decord==0.6.0', 'deepspeed': 'deepspeed>=0.9.3', 'diffusers': 'diffusers', 'dill': 'dill<0.3.5', 'evaluate': 'evaluate>=0.2.0', 'fairscale': 'fairscale>0.3', 'faiss-cpu': 'faiss-cpu', 'fastapi': 'fastapi', 'filelock': 'filelock', 'flax': 'flax>=0.4.1,<=0.7.0', 'ftfy': 'ftfy', 'fugashi': 'fugashi>=1.0', 'GitPython': 'GitPython<3.1.19', 'hf-doc-builder': 'hf-doc-builder>=0.3.0', 'huggingface-hub': 'huggingface-hub>=0.14.1,<1.0', 'importlib_metadata': 'importlib_metadata', 'ipadic': 'ipadic>=1.0.0,<2.0', 'isort': 'isort>=5.5.4', 'jax': 'jax>=0.2.8,!=0.3.2,<=0.4.13', 'jaxlib': 'jaxlib>=0.1.65,<=0.4.13', 'jieba': 'jieba', 'kenlm': 'kenlm', 'keras-nlp': 'keras-nlp>=0.3.1', 'librosa': 'librosa', 'nltk': 'nltk', 'natten': 'natten>=0.14.6', 'numpy': 'numpy>=1.17', 'onnxconverter-common': 'onnxconverter-common', 'onnxruntime-tools': 'onnxruntime-tools>=1.4.2', 'onnxruntime': 'onnxruntime>=1.4.0', 'opencv-python': 'opencv-python', 'optuna': 'optuna', 'optax': 'optax>=0.0.8,<=0.1.4', 'packaging': 'packaging>=20.0', 'parameterized': 'parameterized', 'phonemizer': 'phonemizer', 'protobuf': 'protobuf', 'psutil': 'psutil', 'pyyaml': 'pyyaml>=5.1', 'pydantic': 'pydantic<2', 'pytest': 'pytest>=7.2.0', 'pytest-timeout': 'pytest-timeout', 'pytest-xdist': 'pytest-xdist', 'python': 'python>=3.8.0', 'ray[tune]': 'ray[tune]', 'regex': 'regex!=2019.12.17', 'requests': 'requests', 'rhoknp': 'rhoknp>=1.1.0,<1.3.1', 'rjieba': 'rjieba', 'rouge-score': 'rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1', 'ruff': 'ruff>=0.0.241,<=0.0.259', 'sacrebleu': 'sacrebleu>=1.4.12,<2.0.0', 'sacremoses': 'sacremoses', 'safetensors': 'safetensors>=0.3.1', 'sagemaker': 'sagemaker>=2.31.0', 'scikit-learn': 'scikit-learn', 'sentencepiece': 'sentencepiece>=0.1.91,!=0.1.92', 'sigopt': 'sigopt', 'starlette': 'starlette', 'sudachipy': 'sudachipy>=0.6.6', 'sudachidict_core': 'sudachidict_core>=20220729', 'tensorflow-cpu': 'tensorflow-cpu>=2.6,<2.14', 'tensorflow': 'tensorflow>=2.6,<2.14', 'tensorflow-text': 'tensorflow-text<2.14', 'tf2onnx': 'tf2onnx', 'timeout-decorator': 'timeout-decorator', 'timm': 'timm', 'tokenizers': 'tokenizers>=0.11.1,!=0.11.3,<0.14', 'torch': 'torch>=1.9,!=1.12.0', 'torchaudio': 'torchaudio', 'torchvision': 'torchvision', 'pyctcdecode': 'pyctcdecode>=0.4.0', 'tqdm': 'tqdm>=4.27', 'unidic': 'unidic>=1.0.2', 'unidic_lite': 'unidic_lite>=1.0.7', 'urllib3': 'urllib3<2.0.0', 'uvicorn': 'uvicorn', }
29
1
import logging import os from dataclasses import dataclass from typing import List, Optional, Union import tqdm from filelock import FileLock from transformers import ( BartTokenizer, BartTokenizerFast, DataProcessor, PreTrainedTokenizer, RobertaTokenizer, RobertaTokenizerFast, XLMRobertaTokenizer, is_tf_available, is_torch_available, ) __UpperCAmelCase = logging.getLogger(__name__) @dataclass(frozen=_snake_case ) class lowerCamelCase : '''simple docstring''' _snake_case : str _snake_case : str _snake_case : Optional[str] = None _snake_case : Optional[str] = None _snake_case : Optional[str] = None @dataclass(frozen=_snake_case ) class lowerCamelCase : '''simple docstring''' _snake_case : List[int] _snake_case : Optional[List[int]] = None _snake_case : Optional[List[int]] = None _snake_case : Optional[Union[int, float]] = None _snake_case : Optional[int] = None if is_torch_available(): import torch from torch.utils.data import Dataset class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : List[InputFeatures] def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = None , _UpperCamelCase=False , _UpperCamelCase = False , ) -> Tuple: UpperCAmelCase_ : List[Any] = hans_processors[task]() UpperCAmelCase_ : Tuple = os.path.join( _UpperCamelCase , 'cached_{}_{}_{}_{}'.format( 'dev' if evaluate else 'train' , tokenizer.__class__.__name__ , str(_UpperCamelCase ) , _UpperCamelCase , ) , ) UpperCAmelCase_ : Optional[Any] = processor.get_labels() if tokenizer.__class__ in ( RobertaTokenizer, RobertaTokenizerFast, XLMRobertaTokenizer, BartTokenizer, BartTokenizerFast, ): # HACK(label indices are swapped in RoBERTa pretrained model) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = label_list[2], label_list[1] UpperCAmelCase_ : str = label_list # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. UpperCAmelCase_ : Any = cached_features_file + '.lock' with FileLock(_UpperCamelCase ): if os.path.exists(_UpperCamelCase ) and not overwrite_cache: logger.info(f"Loading features from cached file {cached_features_file}" ) UpperCAmelCase_ : Union[str, Any] = torch.load(_UpperCamelCase ) else: logger.info(f"Creating features from dataset file at {data_dir}" ) UpperCAmelCase_ : List[Any] = ( processor.get_dev_examples(_UpperCamelCase ) if evaluate else processor.get_train_examples(_UpperCamelCase ) ) logger.info('Training examples: %s' , len(_UpperCamelCase ) ) UpperCAmelCase_ : Any = hans_convert_examples_to_features(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) logger.info('Saving features into cached file %s' , _UpperCamelCase ) torch.save(self.features , _UpperCamelCase ) def __len__( self ) -> int: return len(self.features ) def __getitem__( self , _UpperCamelCase ) -> InputFeatures: return self.features[i] def __UpperCAmelCase ( self ) -> Optional[Any]: return self.label_list if is_tf_available(): import tensorflow as tf class lowerCamelCase : '''simple docstring''' _snake_case : List[InputFeatures] def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = 1_2_8 , _UpperCamelCase=False , _UpperCamelCase = False , ) -> Optional[int]: UpperCAmelCase_ : Dict = hans_processors[task]() UpperCAmelCase_ : Dict = processor.get_labels() if tokenizer.__class__ in ( RobertaTokenizer, RobertaTokenizerFast, XLMRobertaTokenizer, BartTokenizer, BartTokenizerFast, ): # HACK(label indices are swapped in RoBERTa pretrained model) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = label_list[2], label_list[1] UpperCAmelCase_ : str = label_list UpperCAmelCase_ : List[str] = processor.get_dev_examples(_UpperCamelCase ) if evaluate else processor.get_train_examples(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = hans_convert_examples_to_features(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) def gen(): for ex_index, ex in tqdm.tqdm(enumerate(self.features ) , desc='convert examples to features' ): if ex_index % 1_0_0_0_0 == 0: logger.info('Writing example %d of %d' % (ex_index, len(_UpperCamelCase )) ) yield ( { "example_id": 0, "input_ids": ex.input_ids, "attention_mask": ex.attention_mask, "token_type_ids": ex.token_type_ids, }, ex.label, ) UpperCAmelCase_ : Tuple = tf.data.Dataset.from_generator( _UpperCamelCase , ( { 'example_id': tf.intaa, 'input_ids': tf.intaa, 'attention_mask': tf.intaa, 'token_type_ids': tf.intaa, }, tf.intaa, ) , ( { 'example_id': tf.TensorShape([] ), 'input_ids': tf.TensorShape([None, None] ), 'attention_mask': tf.TensorShape([None, None] ), 'token_type_ids': tf.TensorShape([None, None] ), }, tf.TensorShape([] ), ) , ) def __UpperCAmelCase ( self ) -> Optional[int]: return self.dataset def __len__( self ) -> int: return len(self.features ) def __getitem__( self , _UpperCamelCase ) -> InputFeatures: return self.features[i] def __UpperCAmelCase ( self ) -> List[str]: return self.label_list class lowerCamelCase (_snake_case ): '''simple docstring''' def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[int]: return self._create_examples(self._read_tsv(os.path.join(_UpperCamelCase , 'heuristics_train_set.txt' ) ) , 'train' ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: return self._create_examples(self._read_tsv(os.path.join(_UpperCamelCase , 'heuristics_evaluation_set.txt' ) ) , 'dev' ) def __UpperCAmelCase ( self ) -> Tuple: return ["contradiction", "entailment", "neutral"] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> Dict: UpperCAmelCase_ : List[str] = [] for i, line in enumerate(_UpperCamelCase ): if i == 0: continue UpperCAmelCase_ : Dict = '%s-%s' % (set_type, line[0]) UpperCAmelCase_ : Tuple = line[5] UpperCAmelCase_ : Tuple = line[6] UpperCAmelCase_ : Dict = line[7][2:] if line[7].startswith('ex' ) else line[7] UpperCAmelCase_ : Tuple = line[0] examples.append(InputExample(guid=_UpperCamelCase , text_a=_UpperCamelCase , text_b=_UpperCamelCase , label=_UpperCamelCase , pairID=_UpperCamelCase ) ) return examples def lowercase__ ( __snake_case : List[InputExample] , __snake_case : List[str] , __snake_case : int , __snake_case : PreTrainedTokenizer , ): '''simple docstring''' UpperCAmelCase_ : List[str] = {label: i for i, label in enumerate(__snake_case )} UpperCAmelCase_ : Optional[int] = [] for ex_index, example in tqdm.tqdm(enumerate(__snake_case ) , desc='convert examples to features' ): if ex_index % 10_000 == 0: logger.info('Writing example %d' % (ex_index) ) UpperCAmelCase_ : List[Any] = tokenizer( example.text_a , example.text_b , add_special_tokens=__snake_case , max_length=__snake_case , padding='max_length' , truncation=__snake_case , return_overflowing_tokens=__snake_case , ) UpperCAmelCase_ : str = label_map[example.label] if example.label in label_map else 0 UpperCAmelCase_ : List[str] = int(example.pairID ) features.append(InputFeatures(**__snake_case , label=__snake_case , pairID=__snake_case ) ) for i, example in enumerate(examples[:5] ): logger.info('*** Example ***' ) logger.info(F"guid: {example}" ) logger.info(F"features: {features[i]}" ) return features __UpperCAmelCase = { 'hans': 3, } __UpperCAmelCase = { 'hans': HansProcessor, }
29
from dataclasses import dataclass from typing import Dict, Optional, Tuple, Union import torch import torch.nn as nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, apply_forward_hook from .attention_processor import AttentionProcessor, AttnProcessor from .modeling_utils import ModelMixin from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : "DiagonalGaussianDistribution" class lowerCamelCase (_snake_case , _snake_case ): '''simple docstring''' _snake_case : Optional[int] = True @register_to_config def __init__( self , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = ("DownEncoderBlock2D",) , _UpperCamelCase = ("UpDecoderBlock2D",) , _UpperCamelCase = (6_4,) , _UpperCamelCase = 1 , _UpperCamelCase = "silu" , _UpperCamelCase = 4 , _UpperCamelCase = 3_2 , _UpperCamelCase = 3_2 , _UpperCamelCase = 0.1_82_15 , ) -> List[Any]: super().__init__() # pass init params to Encoder UpperCAmelCase_ : List[str] = Encoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , down_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , act_fn=_UpperCamelCase , norm_num_groups=_UpperCamelCase , double_z=_UpperCamelCase , ) # pass init params to Decoder UpperCAmelCase_ : Dict = Decoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , up_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , norm_num_groups=_UpperCamelCase , act_fn=_UpperCamelCase , ) UpperCAmelCase_ : Any = nn.Convad(2 * latent_channels , 2 * latent_channels , 1 ) UpperCAmelCase_ : List[Any] = nn.Convad(_UpperCamelCase , _UpperCamelCase , 1 ) UpperCAmelCase_ : Any = False UpperCAmelCase_ : int = False # only relevant if vae tiling is enabled UpperCAmelCase_ : Optional[int] = self.config.sample_size UpperCAmelCase_ : int = ( self.config.sample_size[0] if isinstance(self.config.sample_size , (list, tuple) ) else self.config.sample_size ) UpperCAmelCase_ : Union[str, Any] = int(sample_size / (2 ** (len(self.config.block_out_channels ) - 1)) ) UpperCAmelCase_ : Optional[Any] = 0.25 def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=False ) -> List[str]: if isinstance(_UpperCamelCase , (Encoder, Decoder) ): UpperCAmelCase_ : Union[str, Any] = value def __UpperCAmelCase ( self , _UpperCamelCase = True ) -> int: UpperCAmelCase_ : Tuple = use_tiling def __UpperCAmelCase ( self ) -> Dict: self.enable_tiling(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: UpperCAmelCase_ : str = True def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Optional[int] = False @property # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors def __UpperCAmelCase ( self ) -> Dict[str, AttentionProcessor]: UpperCAmelCase_ : Optional[int] = {} def fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): UpperCAmelCase_ : Optional[int] = module.processor for sub_name, child in module.named_children(): fn_recursive_add_processors(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) return processors for name, module in self.named_children(): fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return processors def __UpperCAmelCase ( self , _UpperCamelCase ) -> List[Any]: UpperCAmelCase_ : Union[str, Any] = len(self.attn_processors.keys() ) if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != count: raise ValueError( f"A dict of processors was passed, but the number of processors {len(_UpperCamelCase )} does not match the" f" number of attention layers: {count}. Please make sure to pass {count} processor classes." ) def fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): if not isinstance(_UpperCamelCase , _UpperCamelCase ): module.set_processor(_UpperCamelCase ) else: module.set_processor(processor.pop(f"{name}.processor" ) ) for sub_name, child in module.named_children(): fn_recursive_attn_processor(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) for name, module in self.named_children(): fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Union[str, Any]: self.set_attn_processor(AttnProcessor() ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size): return self.tiled_encode(_UpperCamelCase , return_dict=_UpperCamelCase ) if self.use_slicing and x.shape[0] > 1: UpperCAmelCase_ : Union[str, Any] = [self.encoder(_UpperCamelCase ) for x_slice in x.split(1 )] UpperCAmelCase_ : Tuple = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : List[Any] = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size): return self.tiled_decode(_UpperCamelCase , return_dict=_UpperCamelCase ) UpperCAmelCase_ : str = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.decoder(_UpperCamelCase ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_slicing and z.shape[0] > 1: UpperCAmelCase_ : List[str] = [self._decode(_UpperCamelCase ).sample for z_slice in z.split(1 )] UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : Any = self._decode(_UpperCamelCase ).sample if not return_dict: return (decoded,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : Tuple = min(a.shape[2] , b.shape[2] , _UpperCamelCase ) for y in range(_UpperCamelCase ): UpperCAmelCase_ : str = a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: UpperCAmelCase_ : Tuple = min(a.shape[3] , b.shape[3] , _UpperCamelCase ) for x in range(_UpperCamelCase ): UpperCAmelCase_ : int = a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: UpperCAmelCase_ : Any = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Tuple = int(self.tile_latent_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Optional[int] = self.tile_latent_min_size - blend_extent # Split the image into 512x512 tiles and encode them separately. UpperCAmelCase_ : List[str] = [] for i in range(0 , x.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : Any = [] for j in range(0 , x.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : Any = x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size] UpperCAmelCase_ : Dict = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.quant_conv(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : str = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Dict = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : List[str] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Union[str, Any] = torch.cat(_UpperCamelCase , dim=2 ) UpperCAmelCase_ : List[Any] = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : str = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Dict = int(self.tile_sample_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Dict = self.tile_sample_min_size - blend_extent # Split z into overlapping 64x64 tiles and decode them separately. # The tiles have an overlap to avoid seams between tiles. UpperCAmelCase_ : Union[str, Any] = [] for i in range(0 , z.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = [] for j in range(0 , z.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size] UpperCAmelCase_ : Optional[Any] = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = self.decoder(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Union[str, Any] = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : Optional[Any] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase , dim=2 ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = False , _UpperCamelCase = True , _UpperCamelCase = None , ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : Optional[Any] = sample UpperCAmelCase_ : Union[str, Any] = self.encode(_UpperCamelCase ).latent_dist if sample_posterior: UpperCAmelCase_ : str = posterior.sample(generator=_UpperCamelCase ) else: UpperCAmelCase_ : int = posterior.mode() UpperCAmelCase_ : Dict = self.decode(_UpperCamelCase ).sample if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase )
29
1
def lowercase__ ( __snake_case : List[str] , __snake_case : str , __snake_case : int , __snake_case : Union[str, Any] , __snake_case : Tuple , __snake_case : str ): '''simple docstring''' if index == r: for j in range(__snake_case ): print(data[j] , end=' ' ) print(' ' ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location UpperCAmelCase_ : Tuple = arr[i] combination_util(__snake_case , __snake_case , __snake_case , index + 1 , __snake_case , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(__snake_case , __snake_case , __snake_case , __snake_case , __snake_case , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def lowercase__ ( __snake_case : List[str] , __snake_case : List[str] , __snake_case : Dict ): '''simple docstring''' UpperCAmelCase_ : Tuple = [0] * r # Print all combination using temporary array 'data[]' combination_util(__snake_case , __snake_case , __snake_case , 0 , __snake_case , 0 ) if __name__ == "__main__": # Driver code to check the function above __UpperCAmelCase = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
29
def lowercase__ ( __snake_case : int , __snake_case : int ): '''simple docstring''' if a < 0 or b < 0: raise ValueError('the value of both inputs must be positive' ) UpperCAmelCase_ : Tuple = str(bin(__snake_case ) )[2:] # remove the leading "0b" UpperCAmelCase_ : Union[str, Any] = str(bin(__snake_case ) )[2:] # remove the leading "0b" UpperCAmelCase_ : List[Any] = max(len(__snake_case ) , len(__snake_case ) ) return "0b" + "".join( str(int(char_a == '1' and char_b == '1' ) ) for char_a, char_b in zip(a_binary.zfill(__snake_case ) , b_binary.zfill(__snake_case ) ) ) if __name__ == "__main__": import doctest doctest.testmod()
29
1
from collections.abc import Sequence def lowercase__ ( __snake_case : Sequence[int] | None = None ): '''simple docstring''' if nums is None or not nums: raise ValueError('Input sequence should not be empty' ) UpperCAmelCase_ : Optional[int] = nums[0] for i in range(1 , len(__snake_case ) ): UpperCAmelCase_ : Dict = nums[i] UpperCAmelCase_ : Optional[Any] = max(__snake_case , ans + num , __snake_case ) return ans if __name__ == "__main__": import doctest doctest.testmod() # Try on a sample input from the user __UpperCAmelCase = int(input('Enter number of elements : ').strip()) __UpperCAmelCase = list(map(int, input('\nEnter the numbers : ').strip().split()))[:n] print(max_subsequence_sum(array))
29
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_convbert import ConvBertTokenizer __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {'vocab_file': 'vocab.txt'} __UpperCAmelCase = { 'vocab_file': { 'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt', 'YituTech/conv-bert-medium-small': ( 'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt' ), 'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt', } } __UpperCAmelCase = { 'YituTech/conv-bert-base': 512, 'YituTech/conv-bert-medium-small': 512, 'YituTech/conv-bert-small': 512, } __UpperCAmelCase = { 'YituTech/conv-bert-base': {'do_lower_case': True}, 'YituTech/conv-bert-medium-small': {'do_lower_case': True}, 'YituTech/conv-bert-small': {'do_lower_case': True}, } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Optional[int] = VOCAB_FILES_NAMES _snake_case : int = PRETRAINED_VOCAB_FILES_MAP _snake_case : Dict = PRETRAINED_INIT_CONFIGURATION _snake_case : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _snake_case : Any = ConvBertTokenizer def __init__( self , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase=True , _UpperCamelCase="[UNK]" , _UpperCamelCase="[SEP]" , _UpperCamelCase="[PAD]" , _UpperCamelCase="[CLS]" , _UpperCamelCase="[MASK]" , _UpperCamelCase=True , _UpperCamelCase=None , **_UpperCamelCase , ) -> Dict: super().__init__( _UpperCamelCase , tokenizer_file=_UpperCamelCase , do_lower_case=_UpperCamelCase , unk_token=_UpperCamelCase , sep_token=_UpperCamelCase , pad_token=_UpperCamelCase , cls_token=_UpperCamelCase , mask_token=_UpperCamelCase , tokenize_chinese_chars=_UpperCamelCase , strip_accents=_UpperCamelCase , **_UpperCamelCase , ) UpperCAmelCase_ : Optional[int] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('lowercase' , _UpperCamelCase ) != do_lower_case or normalizer_state.get('strip_accents' , _UpperCamelCase ) != strip_accents or normalizer_state.get('handle_chinese_chars' , _UpperCamelCase ) != tokenize_chinese_chars ): UpperCAmelCase_ : Any = getattr(_UpperCamelCase , normalizer_state.pop('type' ) ) UpperCAmelCase_ : str = do_lower_case UpperCAmelCase_ : List[Any] = strip_accents UpperCAmelCase_ : str = tokenize_chinese_chars UpperCAmelCase_ : Tuple = normalizer_class(**_UpperCamelCase ) UpperCAmelCase_ : Any = do_lower_case def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=None ) -> List[str]: UpperCAmelCase_ : int = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> List[int]: UpperCAmelCase_ : Union[str, Any] = [self.sep_token_id] UpperCAmelCase_ : int = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> Tuple[str]: UpperCAmelCase_ : Any = self._tokenizer.model.save(_UpperCamelCase , name=_UpperCamelCase ) return tuple(_UpperCamelCase )
29
1
def lowercase__ ( __snake_case : int , __snake_case : int , __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : int = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def lowercase__ ( ): '''simple docstring''' print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
29
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'snap-research/efficientformer-l1-300': ( 'https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json' ), } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Optional[int] = '''efficientformer''' def __init__( self , _UpperCamelCase = [3, 2, 6, 4] , _UpperCamelCase = [4_8, 9_6, 2_2_4, 4_4_8] , _UpperCamelCase = [True, True, True, True] , _UpperCamelCase = 4_4_8 , _UpperCamelCase = 3_2 , _UpperCamelCase = 4 , _UpperCamelCase = 7 , _UpperCamelCase = 5 , _UpperCamelCase = 8 , _UpperCamelCase = 4 , _UpperCamelCase = 0.0 , _UpperCamelCase = 1_6 , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = 2 , _UpperCamelCase = 1 , _UpperCamelCase = 0.0 , _UpperCamelCase = 1 , _UpperCamelCase = True , _UpperCamelCase = True , _UpperCamelCase = 1E-5 , _UpperCamelCase = "gelu" , _UpperCamelCase = 0.02 , _UpperCamelCase = 1E-12 , _UpperCamelCase = 2_2_4 , _UpperCamelCase = 1E-05 , **_UpperCamelCase , ) -> None: super().__init__(**_UpperCamelCase ) UpperCAmelCase_ : int = hidden_act UpperCAmelCase_ : Union[str, Any] = hidden_dropout_prob UpperCAmelCase_ : Tuple = hidden_sizes UpperCAmelCase_ : Union[str, Any] = num_hidden_layers UpperCAmelCase_ : List[str] = num_attention_heads UpperCAmelCase_ : List[Any] = initializer_range UpperCAmelCase_ : int = layer_norm_eps UpperCAmelCase_ : List[str] = patch_size UpperCAmelCase_ : Union[str, Any] = num_channels UpperCAmelCase_ : Optional[Any] = depths UpperCAmelCase_ : List[Any] = mlp_expansion_ratio UpperCAmelCase_ : List[str] = downsamples UpperCAmelCase_ : List[Any] = dim UpperCAmelCase_ : Tuple = key_dim UpperCAmelCase_ : Optional[int] = attention_ratio UpperCAmelCase_ : str = resolution UpperCAmelCase_ : Dict = pool_size UpperCAmelCase_ : Union[str, Any] = downsample_patch_size UpperCAmelCase_ : List[str] = downsample_stride UpperCAmelCase_ : List[str] = downsample_pad UpperCAmelCase_ : Any = drop_path_rate UpperCAmelCase_ : Dict = num_metaad_blocks UpperCAmelCase_ : Dict = distillation UpperCAmelCase_ : int = use_layer_scale UpperCAmelCase_ : Any = layer_scale_init_value UpperCAmelCase_ : Any = image_size UpperCAmelCase_ : Dict = batch_norm_eps
29
1
import numpy as np from matplotlib import pyplot as plt from sklearn.datasets import load_iris from sklearn.metrics import ConfusionMatrixDisplay from sklearn.model_selection import train_test_split from xgboost import XGBClassifier def lowercase__ ( __snake_case : dict ): '''simple docstring''' return (data["data"], data["target"]) def lowercase__ ( __snake_case : np.ndarray , __snake_case : np.ndarray ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = XGBClassifier() classifier.fit(__snake_case , __snake_case ) return classifier def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = load_iris() UpperCAmelCase_ , UpperCAmelCase_ : int = data_handling(__snake_case ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = train_test_split( __snake_case , __snake_case , test_size=0.25 ) UpperCAmelCase_ : Optional[int] = iris['target_names'] # Create an XGBoost Classifier from the training data UpperCAmelCase_ : int = xgboost(__snake_case , __snake_case ) # Display the confusion matrix of the classifier with both training and test sets ConfusionMatrixDisplay.from_estimator( __snake_case , __snake_case , __snake_case , display_labels=__snake_case , cmap='Blues' , normalize='true' , ) plt.title('Normalized Confusion Matrix - IRIS Dataset' ) plt.show() if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
29
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = '\n Examples:\n ```py\n >>> from PIL import Image\n >>> import torch\n >>> from diffusers import DiffusionPipeline\n >>> from diffusers.utils import export_to_gif, load_image\n\n >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")\n\n >>> repo = "openai/shap-e-img2img"\n >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n >>> pipe = pipe.to(device)\n\n >>> guidance_scale = 3.0\n >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"\n >>> image = load_image(image_url).convert("RGB")\n\n >>> images = pipe(\n ... image,\n ... guidance_scale=guidance_scale,\n ... num_inference_steps=64,\n ... frame_size=256,\n ... ).images\n\n >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")\n ```\n' @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Union[PIL.Image.Image, np.ndarray] class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Any: super().__init__() self.register_modules( prior=_UpperCamelCase , image_encoder=_UpperCamelCase , image_processor=_UpperCamelCase , scheduler=_UpperCamelCase , renderer=_UpperCamelCase , ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> List[Any]: if latents is None: UpperCAmelCase_ : str = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) else: if latents.shape != shape: raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}" ) UpperCAmelCase_ : Tuple = latents.to(_UpperCamelCase ) UpperCAmelCase_ : Tuple = latents * scheduler.init_noise_sigma return latents def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Union[str, Any]: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) UpperCAmelCase_ : int = torch.device(f"cuda:{gpu_id}" ) UpperCAmelCase_ : int = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_UpperCamelCase , _UpperCamelCase ) @property def __UpperCAmelCase ( self ) -> int: if self.device != torch.device('meta' ) or not hasattr(self.image_encoder , '_hf_hook' ): return self.device for module in self.image_encoder.modules(): if ( hasattr(_UpperCamelCase , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> str: if isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , torch.Tensor ): UpperCAmelCase_ : int = torch.cat(_UpperCamelCase , axis=0 ) if image[0].ndim == 4 else torch.stack(_UpperCamelCase , axis=0 ) if not isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : Optional[int] = self.image_processor(_UpperCamelCase , return_tensors='pt' ).pixel_values[0].unsqueeze(0 ) UpperCAmelCase_ : Tuple = image.to(dtype=self.image_encoder.dtype , device=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.image_encoder(_UpperCamelCase )['last_hidden_state'] UpperCAmelCase_ : Union[str, Any] = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 UpperCAmelCase_ : List[str] = image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) if do_classifier_free_guidance: UpperCAmelCase_ : Dict = torch.zeros_like(_UpperCamelCase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes UpperCAmelCase_ : Optional[int] = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(_UpperCamelCase ) def __call__( self , _UpperCamelCase , _UpperCamelCase = 1 , _UpperCamelCase = 2_5 , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = 4.0 , _UpperCamelCase = 6_4 , _UpperCamelCase = "pil" , _UpperCamelCase = True , ) -> Union[str, Any]: if isinstance(_UpperCamelCase , PIL.Image.Image ): UpperCAmelCase_ : Tuple = 1 elif isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : str = image.shape[0] elif isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): UpperCAmelCase_ : Optional[int] = len(_UpperCamelCase ) else: raise ValueError( f"`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : Tuple = self._execution_device UpperCAmelCase_ : str = batch_size * num_images_per_prompt UpperCAmelCase_ : str = guidance_scale > 1.0 UpperCAmelCase_ : str = self._encode_image(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # prior self.scheduler.set_timesteps(_UpperCamelCase , device=_UpperCamelCase ) UpperCAmelCase_ : int = self.scheduler.timesteps UpperCAmelCase_ : int = self.prior.config.num_embeddings UpperCAmelCase_ : Any = self.prior.config.embedding_dim UpperCAmelCase_ : List[str] = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim UpperCAmelCase_ : List[Any] = latents.reshape(latents.shape[0] , _UpperCamelCase , _UpperCamelCase ) for i, t in enumerate(self.progress_bar(_UpperCamelCase ) ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : Tuple = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : Optional[Any] = self.scheduler.scale_model_input(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : int = self.prior( _UpperCamelCase , timestep=_UpperCamelCase , proj_embedding=_UpperCamelCase , ).predicted_image_embedding # remove the variance UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: UpperCAmelCase_ , UpperCAmelCase_ : str = noise_pred.chunk(2 ) UpperCAmelCase_ : List[Any] = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) UpperCAmelCase_ : List[str] = self.scheduler.step( _UpperCamelCase , timestep=_UpperCamelCase , sample=_UpperCamelCase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = [] for i, latent in enumerate(_UpperCamelCase ): print() UpperCAmelCase_ : List[str] = self.renderer.decode( latent[None, :] , _UpperCamelCase , size=_UpperCamelCase , ray_batch_size=4_0_9_6 , n_coarse_samples=6_4 , n_fine_samples=1_2_8 , ) images.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = torch.stack(_UpperCamelCase ) if output_type not in ["np", "pil"]: raise ValueError(f"Only the output types `pil` and `np` are supported not output_type={output_type}" ) UpperCAmelCase_ : Dict = images.cpu().numpy() if output_type == "pil": UpperCAmelCase_ : List[str] = [self.numpy_to_pil(_UpperCamelCase ) for image in images] # Offload last model to CPU if hasattr(self , 'final_offload_hook' ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=_UpperCamelCase )
29
1
def lowercase__ ( __snake_case : int ): '''simple docstring''' if length <= 0 or not isinstance(__snake_case , __snake_case ): raise ValueError('Length must be a positive integer.' ) return [n * (2 * n - 1) for n in range(__snake_case )] if __name__ == "__main__": print(hexagonal_numbers(length=5)) print(hexagonal_numbers(length=10))
29
import random import unittest import torch from diffusers import IFImgaImgSuperResolutionPipeline from diffusers.utils import floats_tensor from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import skip_mps, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin from . import IFPipelineTesterMixin @skip_mps class lowerCamelCase (_snake_case , _snake_case , unittest.TestCase ): '''simple docstring''' _snake_case : Union[str, Any] = IFImgaImgSuperResolutionPipeline _snake_case : Union[str, Any] = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''} _snake_case : List[Any] = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''} ) _snake_case : List[str] = PipelineTesterMixin.required_optional_params - {'''latents'''} def __UpperCAmelCase ( self ) -> Optional[Any]: return self._get_superresolution_dummy_components() def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=0 ) -> Any: if str(_UpperCamelCase ).startswith('mps' ): UpperCAmelCase_ : List[Any] = torch.manual_seed(_UpperCamelCase ) else: UpperCAmelCase_ : int = torch.Generator(device=_UpperCamelCase ).manual_seed(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Dict = floats_tensor((1, 3, 1_6, 1_6) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Tuple = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'original_image': original_image, 'generator': generator, 'num_inference_steps': 2, 'output_type': 'numpy', } return inputs @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def __UpperCAmelCase ( self ) -> Any: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 ) def __UpperCAmelCase ( self ) -> Dict: self._test_save_load_optional_components() @unittest.skipIf(torch_device != 'cuda' , reason='float16 requires CUDA' ) def __UpperCAmelCase ( self ) -> str: # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder super().test_save_load_floataa(expected_max_diff=1E-1 ) def __UpperCAmelCase ( self ) -> List[Any]: self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 ) def __UpperCAmelCase ( self ) -> Union[str, Any]: self._test_save_load_local() def __UpperCAmelCase ( self ) -> Dict: self._test_inference_batch_single_identical( expected_max_diff=1E-2 , )
29
1
def lowercase__ ( __snake_case : List[str] , __snake_case : Any ): '''simple docstring''' return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2 def lowercase__ ( __snake_case : List[Any] , __snake_case : List[Any]=0 ): '''simple docstring''' return sorted(__snake_case , key=lambda __snake_case : x[column] ) def lowercase__ ( __snake_case : Union[str, Any] , __snake_case : Union[str, Any] , __snake_case : Optional[int]=float('inf' ) ): '''simple docstring''' for i in range(points_counts - 1 ): for j in range(i + 1 , __snake_case ): UpperCAmelCase_ : int = euclidean_distance_sqr(points[i] , points[j] ) if current_dis < min_dis: UpperCAmelCase_ : Union[str, Any] = current_dis return min_dis def lowercase__ ( __snake_case : List[Any] , __snake_case : Optional[Any] , __snake_case : Union[str, Any]=float('inf' ) ): '''simple docstring''' for i in range(min(6 , points_counts - 1 ) , __snake_case ): for j in range(max(0 , i - 6 ) , __snake_case ): UpperCAmelCase_ : Union[str, Any] = euclidean_distance_sqr(points[i] , points[j] ) if current_dis < min_dis: UpperCAmelCase_ : List[str] = current_dis return min_dis def lowercase__ ( __snake_case : Any , __snake_case : str , __snake_case : List[Any] ): '''simple docstring''' if points_counts <= 3: return dis_between_closest_pair(__snake_case , __snake_case ) # recursion UpperCAmelCase_ : int = points_counts // 2 UpperCAmelCase_ : Union[str, Any] = closest_pair_of_points_sqr( __snake_case , points_sorted_on_y[:mid] , __snake_case ) UpperCAmelCase_ : Dict = closest_pair_of_points_sqr( __snake_case , points_sorted_on_y[mid:] , points_counts - mid ) UpperCAmelCase_ : List[Any] = min(__snake_case , __snake_case ) UpperCAmelCase_ : Optional[int] = [] for point in points_sorted_on_x: if abs(point[0] - points_sorted_on_x[mid][0] ) < closest_pair_dis: cross_strip.append(__snake_case ) UpperCAmelCase_ : int = dis_between_closest_in_strip( __snake_case , len(__snake_case ) , __snake_case ) return min(__snake_case , __snake_case ) def lowercase__ ( __snake_case : List[Any] , __snake_case : Dict ): '''simple docstring''' UpperCAmelCase_ : Dict = column_based_sort(__snake_case , column=0 ) UpperCAmelCase_ : Optional[int] = column_based_sort(__snake_case , column=1 ) return ( closest_pair_of_points_sqr( __snake_case , __snake_case , __snake_case ) ) ** 0.5 if __name__ == "__main__": __UpperCAmelCase = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)] print('Distance:', closest_pair_of_points(points, len(points)))
29
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = { 'configuration_time_series_transformer': [ 'TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TimeSeriesTransformerConfig', ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST', 'TimeSeriesTransformerForPrediction', 'TimeSeriesTransformerModel', 'TimeSeriesTransformerPreTrainedModel', ] if TYPE_CHECKING: from .configuration_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimeSeriesTransformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimeSeriesTransformerForPrediction, TimeSeriesTransformerModel, TimeSeriesTransformerPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
1
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 lowercase__ ( __snake_case : str , __snake_case : List[Any] , __snake_case : Dict ): '''simple docstring''' if isinstance(__snake_case , torch.Tensor ): return image elif isinstance(__snake_case , PIL.Image.Image ): UpperCAmelCase_ : Optional[int] = [image] if isinstance(image[0] , PIL.Image.Image ): UpperCAmelCase_ : Union[str, Any] = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] UpperCAmelCase_ : Optional[int] = np.concatenate(__snake_case , axis=0 ) UpperCAmelCase_ : Tuple = np.array(__snake_case ).astype(np.floataa ) / 255.0 UpperCAmelCase_ : List[str] = image.transpose(0 , 3 , 1 , 2 ) UpperCAmelCase_ : List[Any] = 2.0 * image - 1.0 UpperCAmelCase_ : Optional[int] = torch.from_numpy(__snake_case ) elif isinstance(image[0] , torch.Tensor ): UpperCAmelCase_ : List[Any] = torch.cat(__snake_case , dim=0 ) return image def lowercase__ ( __snake_case : List[Any] , __snake_case : int , __snake_case : Union[str, Any] , __snake_case : Optional[Any]=0.9995 ): '''simple docstring''' if not isinstance(__snake_case , np.ndarray ): UpperCAmelCase_ : Optional[Any] = True UpperCAmelCase_ : Dict = va.device UpperCAmelCase_ : Any = va.cpu().numpy() UpperCAmelCase_ : Dict = va.cpu().numpy() UpperCAmelCase_ : Optional[int] = np.sum(va * va / (np.linalg.norm(__snake_case ) * np.linalg.norm(__snake_case )) ) if np.abs(__snake_case ) > DOT_THRESHOLD: UpperCAmelCase_ : Tuple = (1 - t) * va + t * va else: UpperCAmelCase_ : List[str] = np.arccos(__snake_case ) UpperCAmelCase_ : Any = np.sin(__snake_case ) UpperCAmelCase_ : Tuple = theta_a * t UpperCAmelCase_ : str = np.sin(__snake_case ) UpperCAmelCase_ : List[Any] = np.sin(theta_a - theta_t ) / sin_theta_a UpperCAmelCase_ : Union[str, Any] = sin_theta_t / sin_theta_a UpperCAmelCase_ : Any = sa * va + sa * va if inputs_are_torch: UpperCAmelCase_ : Union[str, Any] = torch.from_numpy(__snake_case ).to(__snake_case ) return va def lowercase__ ( __snake_case : int , __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = F.normalize(__snake_case , dim=-1 ) UpperCAmelCase_ : str = F.normalize(__snake_case , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def lowercase__ ( __snake_case : Dict , __snake_case : Tuple ): '''simple docstring''' for param in model.parameters(): UpperCAmelCase_ : Optional[Any] = value class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase=None , ) -> Any: super().__init__() self.register_modules( vae=_UpperCamelCase , text_encoder=_UpperCamelCase , clip_model=_UpperCamelCase , tokenizer=_UpperCamelCase , unet=_UpperCamelCase , scheduler=_UpperCamelCase , feature_extractor=_UpperCamelCase , coca_model=_UpperCamelCase , coca_tokenizer=_UpperCamelCase , coca_transform=_UpperCamelCase , ) UpperCAmelCase_ : Optional[int] = ( feature_extractor.size if isinstance(feature_extractor.size , _UpperCamelCase ) else feature_extractor.size['shortest_edge'] ) UpperCAmelCase_ : Optional[Any] = transforms.Normalize(mean=feature_extractor.image_mean , std=feature_extractor.image_std ) set_requires_grad(self.text_encoder , _UpperCamelCase ) set_requires_grad(self.clip_model , _UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase = "auto" ) -> Dict: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory UpperCAmelCase_ : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> List[Any]: self.enable_attention_slicing(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> int: set_requires_grad(self.vae , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: set_requires_grad(self.vae , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Dict: set_requires_grad(self.unet , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> List[Any]: set_requires_grad(self.unet , _UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Tuple: # get the original timestep using init_timestep UpperCAmelCase_ : Union[str, Any] = min(int(num_inference_steps * strength ) , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = max(num_inference_steps - init_timestep , 0 ) UpperCAmelCase_ : Union[str, Any] = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=None ) -> Optional[int]: if not isinstance(_UpperCamelCase , torch.Tensor ): raise ValueError(f"`image` has to be of type `torch.Tensor` but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : Union[str, Any] = image.to(device=_UpperCamelCase , dtype=_UpperCamelCase ) if isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : int = [ self.vae.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(_UpperCamelCase ) ] UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase , dim=0 ) else: UpperCAmelCase_ : List[Any] = self.vae.encode(_UpperCamelCase ).latent_dist.sample(_UpperCamelCase ) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor UpperCAmelCase_ : List[Any] = 0.1_82_15 * init_latents UpperCAmelCase_ : str = init_latents.repeat_interleave(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : Dict = randn_tensor(init_latents.shape , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) # get latents UpperCAmelCase_ : List[str] = self.scheduler.add_noise(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = init_latents return latents def __UpperCAmelCase ( self , _UpperCamelCase ) -> Union[str, Any]: UpperCAmelCase_ : str = self.coca_transform(_UpperCamelCase ).unsqueeze(0 ) with torch.no_grad(), torch.cuda.amp.autocast(): UpperCAmelCase_ : int = self.coca_model.generate(transformed_image.to(device=self.device , dtype=self.coca_model.dtype ) ) UpperCAmelCase_ : int = self.coca_tokenizer.decode(generated[0].cpu().numpy() ) return generated.split('<end_of_text>' )[0].replace('<start_of_text>' , '' ).rstrip(' .,' ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> int: UpperCAmelCase_ : str = self.feature_extractor.preprocess(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = torch.from_numpy(clip_image_input['pixel_values'][0] ).unsqueeze(0 ).to(self.device ).half() UpperCAmelCase_ : Tuple = self.clip_model.get_image_features(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = image_embeddings_clip.repeat_interleave(_UpperCamelCase , dim=0 ) return image_embeddings_clip @torch.enable_grad() def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Tuple: UpperCAmelCase_ : List[str] = latents.detach().requires_grad_() UpperCAmelCase_ : str = self.scheduler.scale_model_input(_UpperCamelCase , _UpperCamelCase ) # predict the noise residual UpperCAmelCase_ : Any = self.unet(_UpperCamelCase , _UpperCamelCase , encoder_hidden_states=_UpperCamelCase ).sample if isinstance(self.scheduler , (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler) ): UpperCAmelCase_ : int = self.scheduler.alphas_cumprod[timestep] UpperCAmelCase_ : int = 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 UpperCAmelCase_ : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 UpperCAmelCase_ : Optional[Any] = torch.sqrt(_UpperCamelCase ) UpperCAmelCase_ : Any = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler , _UpperCamelCase ): UpperCAmelCase_ : List[Any] = self.scheduler.sigmas[index] UpperCAmelCase_ : Tuple = 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 UpperCAmelCase_ : str = 1 / 0.1_82_15 * sample UpperCAmelCase_ : List[Any] = self.vae.decode(_UpperCamelCase ).sample UpperCAmelCase_ : Union[str, Any] = (image / 2 + 0.5).clamp(0 , 1 ) UpperCAmelCase_ : Dict = transforms.Resize(self.feature_extractor_size )(_UpperCamelCase ) UpperCAmelCase_ : Any = self.normalize(_UpperCamelCase ).to(latents.dtype ) UpperCAmelCase_ : Tuple = self.clip_model.get_image_features(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=_UpperCamelCase ) UpperCAmelCase_ : int = spherical_dist_loss(_UpperCamelCase , _UpperCamelCase ).mean() * clip_guidance_scale UpperCAmelCase_ : List[Any] = -torch.autograd.grad(_UpperCamelCase , _UpperCamelCase )[0] if isinstance(self.scheduler , _UpperCamelCase ): UpperCAmelCase_ : Any = latents.detach() + grads * (sigma**2) UpperCAmelCase_ : Optional[Any] = noise_pred_original else: UpperCAmelCase_ : str = noise_pred_original - torch.sqrt(_UpperCamelCase ) * grads return noise_pred, latents @torch.no_grad() def __call__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 0.6 , _UpperCamelCase = 5_0 , _UpperCamelCase = 7.5 , _UpperCamelCase = 1 , _UpperCamelCase = 0.0 , _UpperCamelCase = 1_0_0 , _UpperCamelCase = None , _UpperCamelCase = "pil" , _UpperCamelCase = True , _UpperCamelCase = 0.8 , _UpperCamelCase = 0.1 , _UpperCamelCase = 0.1 , ) -> Optional[int]: if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != batch_size: raise ValueError(f"You have passed {batch_size} batch_size, but only {len(_UpperCamelCase )} 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(_UpperCamelCase , torch.Generator ) and batch_size > 1: UpperCAmelCase_ : str = [generator] + [None] * (batch_size - 1) UpperCAmelCase_ : str = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] UpperCAmelCase_ : Any = [x[0] for x in coca_is_none if x[1]] UpperCAmelCase_ : Any = ', '.join(_UpperCamelCase ) # generate prompts with coca model if prompt is None if content_prompt is None: if len(_UpperCamelCase ): 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." ) UpperCAmelCase_ : Tuple = self.get_image_description(_UpperCamelCase ) if style_prompt is None: if len(_UpperCamelCase ): 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." ) UpperCAmelCase_ : List[str] = self.get_image_description(_UpperCamelCase ) # get prompt text embeddings for content and style UpperCAmelCase_ : Optional[Any] = self.tokenizer( _UpperCamelCase , padding='max_length' , max_length=self.tokenizer.model_max_length , truncation=_UpperCamelCase , return_tensors='pt' , ) UpperCAmelCase_ : Union[str, Any] = self.text_encoder(content_text_input.input_ids.to(self.device ) )[0] UpperCAmelCase_ : Any = self.tokenizer( _UpperCamelCase , padding='max_length' , max_length=self.tokenizer.model_max_length , truncation=_UpperCamelCase , return_tensors='pt' , ) UpperCAmelCase_ : Union[str, Any] = self.text_encoder(style_text_input.input_ids.to(self.device ) )[0] UpperCAmelCase_ : str = slerp(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # duplicate text embeddings for each generation per prompt UpperCAmelCase_ : List[str] = text_embeddings.repeat_interleave(_UpperCamelCase , dim=0 ) # set timesteps UpperCAmelCase_ : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps ).parameters.keys() ) UpperCAmelCase_ : Any = {} if accepts_offset: UpperCAmelCase_ : Union[str, Any] = 1 self.scheduler.set_timesteps(_UpperCamelCase , **_UpperCamelCase ) # 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 ) UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = self.get_timesteps(_UpperCamelCase , _UpperCamelCase , self.device ) UpperCAmelCase_ : List[str] = timesteps[:1].repeat(_UpperCamelCase ) # Preprocess image UpperCAmelCase_ : Optional[int] = preprocess(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Any = self.prepare_latents( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , text_embeddings.dtype , self.device , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = preprocess(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : List[str] = self.prepare_latents( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , text_embeddings.dtype , self.device , _UpperCamelCase ) UpperCAmelCase_ : List[str] = slerp(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) if clip_guidance_scale > 0: UpperCAmelCase_ : List[Any] = self.get_clip_image_embeddings(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = self.get_clip_image_embeddings(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : str = slerp( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # 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. UpperCAmelCase_ : int = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: UpperCAmelCase_ : str = content_text_input.input_ids.shape[-1] UpperCAmelCase_ : Tuple = self.tokenizer([''] , padding='max_length' , max_length=_UpperCamelCase , return_tensors='pt' ) UpperCAmelCase_ : Dict = self.text_encoder(uncond_input.input_ids.to(self.device ) )[0] # duplicate unconditional embeddings for each generation per prompt UpperCAmelCase_ : Tuple = uncond_embeddings.repeat_interleave(_UpperCamelCase , 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 UpperCAmelCase_ : Tuple = 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`. UpperCAmelCase_ : List[Any] = (batch_size, self.unet.config.in_channels, height // 8, width // 8) UpperCAmelCase_ : Tuple = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps UpperCAmelCase_ : List[Any] = torch.randn(_UpperCamelCase , generator=_UpperCamelCase , device='cpu' , dtype=_UpperCamelCase ).to( self.device ) else: UpperCAmelCase_ : str = torch.randn(_UpperCamelCase , generator=_UpperCamelCase , device=self.device , dtype=_UpperCamelCase ) else: if latents.shape != latents_shape: raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}" ) UpperCAmelCase_ : Any = latents.to(self.device ) # scale the initial noise by the standard deviation required by the scheduler UpperCAmelCase_ : Dict = 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_ : List[Any] = 'eta' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) UpperCAmelCase_ : Tuple = {} if accepts_eta: UpperCAmelCase_ : Optional[int] = eta # check if the scheduler accepts generator UpperCAmelCase_ : Optional[Any] = 'generator' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) if accepts_generator: UpperCAmelCase_ : Union[str, Any] = generator with self.progress_bar(total=_UpperCamelCase ): for i, t in enumerate(_UpperCamelCase ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : int = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : Optional[Any] = self.scheduler.scale_model_input(_UpperCamelCase , _UpperCamelCase ) # predict the noise residual UpperCAmelCase_ : Optional[Any] = self.unet(_UpperCamelCase , _UpperCamelCase , encoder_hidden_states=_UpperCamelCase ).sample # perform classifier free guidance if do_classifier_free_guidance: UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = noise_pred.chunk(2 ) UpperCAmelCase_ : str = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: UpperCAmelCase_ : Optional[Any] = ( text_embeddings.chunk(2 )[1] if do_classifier_free_guidance else text_embeddings ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = self.cond_fn( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) # compute the previous noisy sample x_t -> x_t-1 UpperCAmelCase_ : Optional[Any] = self.scheduler.step(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , **_UpperCamelCase ).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor UpperCAmelCase_ : Optional[int] = 1 / 0.1_82_15 * latents UpperCAmelCase_ : List[Any] = self.vae.decode(_UpperCamelCase ).sample UpperCAmelCase_ : str = (image / 2 + 0.5).clamp(0 , 1 ) UpperCAmelCase_ : Any = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": UpperCAmelCase_ : List[str] = self.numpy_to_pil(_UpperCamelCase ) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=_UpperCamelCase , nsfw_content_detected=_UpperCamelCase )
29
import os import shutil from pathlib import Path from typing import Optional, Union import numpy as np from huggingface_hub import hf_hub_download from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging if is_onnx_available(): import onnxruntime as ort __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'tensor(bool)': np.bool_, 'tensor(int8)': np.inta, 'tensor(uint8)': np.uinta, 'tensor(int16)': np.intaa, 'tensor(uint16)': np.uintaa, 'tensor(int32)': np.intaa, 'tensor(uint32)': np.uintaa, 'tensor(int64)': np.intaa, 'tensor(uint64)': np.uintaa, 'tensor(float16)': np.floataa, 'tensor(float)': np.floataa, 'tensor(double)': np.floataa, } class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase=None , **_UpperCamelCase ) -> Dict: logger.info('`diffusers.OnnxRuntimeModel` is experimental and might change in the future.' ) UpperCAmelCase_ : Any = model UpperCAmelCase_ : int = kwargs.get('model_save_dir' , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = kwargs.get('latest_model_name' , _UpperCamelCase ) def __call__( self , **_UpperCamelCase ) -> str: UpperCAmelCase_ : Optional[int] = {k: np.array(_UpperCamelCase ) for k, v in kwargs.items()} return self.model.run(_UpperCamelCase , _UpperCamelCase ) @staticmethod def __UpperCAmelCase ( _UpperCamelCase , _UpperCamelCase=None , _UpperCamelCase=None ) -> List[Any]: if provider is None: logger.info('No onnxruntime provider specified, using CPUExecutionProvider' ) UpperCAmelCase_ : List[str] = 'CPUExecutionProvider' return ort.InferenceSession(_UpperCamelCase , providers=[provider] , sess_options=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None , **_UpperCamelCase ) -> Dict: UpperCAmelCase_ : Any = file_name if file_name is not None else ONNX_WEIGHTS_NAME UpperCAmelCase_ : Optional[Any] = self.model_save_dir.joinpath(self.latest_model_name ) UpperCAmelCase_ : str = Path(_UpperCamelCase ).joinpath(_UpperCamelCase ) try: shutil.copyfile(_UpperCamelCase , _UpperCamelCase ) except shutil.SameFileError: pass # copy external weights (for models >2GB) UpperCAmelCase_ : Optional[Any] = self.model_save_dir.joinpath(_UpperCamelCase ) if src_path.exists(): UpperCAmelCase_ : List[Any] = Path(_UpperCamelCase ).joinpath(_UpperCamelCase ) try: shutil.copyfile(_UpperCamelCase , _UpperCamelCase ) except shutil.SameFileError: pass def __UpperCAmelCase ( self , _UpperCamelCase , **_UpperCamelCase , ) -> List[str]: if os.path.isfile(_UpperCamelCase ): logger.error(f"Provided path ({save_directory}) should be a directory, not a file" ) return os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) # saving model weights/files self._save_pretrained(_UpperCamelCase , **_UpperCamelCase ) @classmethod def __UpperCAmelCase ( cls , _UpperCamelCase , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = False , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = None , **_UpperCamelCase , ) -> List[str]: UpperCAmelCase_ : List[str] = file_name if file_name is not None else ONNX_WEIGHTS_NAME # load model from local directory if os.path.isdir(_UpperCamelCase ): UpperCAmelCase_ : Union[str, Any] = OnnxRuntimeModel.load_model( os.path.join(_UpperCamelCase , _UpperCamelCase ) , provider=_UpperCamelCase , sess_options=_UpperCamelCase ) UpperCAmelCase_ : Tuple = Path(_UpperCamelCase ) # load model from hub else: # download model UpperCAmelCase_ : List[str] = hf_hub_download( repo_id=_UpperCamelCase , filename=_UpperCamelCase , use_auth_token=_UpperCamelCase , revision=_UpperCamelCase , cache_dir=_UpperCamelCase , force_download=_UpperCamelCase , ) UpperCAmelCase_ : Union[str, Any] = Path(_UpperCamelCase ).parent UpperCAmelCase_ : List[str] = Path(_UpperCamelCase ).name UpperCAmelCase_ : Union[str, Any] = OnnxRuntimeModel.load_model(_UpperCamelCase , provider=_UpperCamelCase , sess_options=_UpperCamelCase ) return cls(model=_UpperCamelCase , **_UpperCamelCase ) @classmethod def __UpperCAmelCase ( cls , _UpperCamelCase , _UpperCamelCase = True , _UpperCamelCase = None , _UpperCamelCase = None , **_UpperCamelCase , ) -> Optional[int]: UpperCAmelCase_ : List[str] = None if len(str(_UpperCamelCase ).split('@' ) ) == 2: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = model_id.split('@' ) return cls._from_pretrained( model_id=_UpperCamelCase , revision=_UpperCamelCase , cache_dir=_UpperCamelCase , force_download=_UpperCamelCase , use_auth_token=_UpperCamelCase , **_UpperCamelCase , )
29
1
import inspect import os import unittest from dataclasses import dataclass import torch from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs from accelerate.state import AcceleratorState from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu from accelerate.utils import KwargsHandler @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : int = 0 _snake_case : bool = False _snake_case : float = 3.0 class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Dict: # If no defaults are changed, `to_kwargs` returns an empty dict. self.assertDictEqual(MockClass().to_kwargs() , {} ) self.assertDictEqual(MockClass(a=2 ).to_kwargs() , {'a': 2} ) self.assertDictEqual(MockClass(a=2 , b=_UpperCamelCase ).to_kwargs() , {'a': 2, 'b': True} ) self.assertDictEqual(MockClass(a=2 , c=2.25 ).to_kwargs() , {'a': 2, 'c': 2.25} ) @require_cuda def __UpperCAmelCase ( self ) -> Optional[Any]: # If no defaults are changed, `to_kwargs` returns an empty dict. UpperCAmelCase_ : Optional[Any] = GradScalerKwargs(init_scale=1_0_2_4 , growth_factor=2 ) AcceleratorState._reset_state() UpperCAmelCase_ : Union[str, Any] = Accelerator(mixed_precision='fp16' , kwargs_handlers=[scaler_handler] ) print(accelerator.use_fpaa ) UpperCAmelCase_ : Any = accelerator.scaler # Check the kwargs have been applied self.assertEqual(scaler._init_scale , 10_24.0 ) self.assertEqual(scaler._growth_factor , 2.0 ) # Check the other values are at the default self.assertEqual(scaler._backoff_factor , 0.5 ) self.assertEqual(scaler._growth_interval , 2_0_0_0 ) self.assertEqual(scaler._enabled , _UpperCamelCase ) @require_multi_gpu def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : int = ['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )] execute_subprocess_async(_UpperCamelCase , env=os.environ.copy() ) if __name__ == "__main__": __UpperCAmelCase = DistributedDataParallelKwargs(bucket_cap_mb=15, find_unused_parameters=True) __UpperCAmelCase = Accelerator(kwargs_handlers=[ddp_scaler]) __UpperCAmelCase = torch.nn.Linear(100, 200) __UpperCAmelCase = accelerator.prepare(model) # Check the values changed in kwargs __UpperCAmelCase = '' __UpperCAmelCase = model.bucket_bytes_cap // (1024 * 1024) if observed_bucket_cap_map != 15: error_msg += F"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n" if model.find_unused_parameters is not True: error_msg += F"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n" # Check the values of the defaults if model.dim != 0: error_msg += F"Default value not respected, should have `0` but found {model.dim}.\n" if model.broadcast_buffers is not True: error_msg += F"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n" if model.gradient_as_bucket_view is not False: error_msg += F"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n" # Raise error at the end to make sure we don't stop at the first failure. if len(error_msg) > 0: raise ValueError(error_msg)
29
import contextlib import csv import json import os import sqlitea import tarfile import textwrap import zipfile import pyarrow as pa import pyarrow.parquet as pq import pytest import datasets import datasets.config @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Tuple = 10 UpperCAmelCase_ : Tuple = datasets.Features( { 'tokens': datasets.Sequence(datasets.Value('string' ) ), 'labels': datasets.Sequence(datasets.ClassLabel(names=['negative', 'positive'] ) ), 'answers': datasets.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), 'id': datasets.Value('int64' ), } ) UpperCAmelCase_ : Tuple = datasets.Dataset.from_dict( { 'tokens': [['foo'] * 5] * n, 'labels': [[1] * 5] * n, 'answers': [{'answer_start': [97], 'text': ['1976']}] * 10, 'id': list(range(__snake_case ) ), } , features=__snake_case , ) return dataset @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : List[str] ): '''simple docstring''' UpperCAmelCase_ : str = str(tmp_path_factory.mktemp('data' ) / 'file.arrow' ) dataset.map(cache_file_name=__snake_case ) return filename # FILE_CONTENT + files __UpperCAmelCase = '\\n Text data.\n Second line of data.' @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'file.txt' UpperCAmelCase_ : Tuple = FILE_CONTENT with open(__snake_case , 'w' ) as f: f.write(__snake_case ) return filename @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' import bza UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'file.txt.bz2' UpperCAmelCase_ : str = bytes(__snake_case , 'utf-8' ) with bza.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' import gzip UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'file.txt.gz' ) UpperCAmelCase_ : Dict = bytes(__snake_case , 'utf-8' ) with gzip.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if datasets.config.LZ4_AVAILABLE: import lza.frame UpperCAmelCase_ : Any = tmp_path_factory.mktemp('data' ) / 'file.txt.lz4' UpperCAmelCase_ : Any = bytes(__snake_case , 'utf-8' ) with lza.frame.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : List[Any] ): '''simple docstring''' if datasets.config.PY7ZR_AVAILABLE: import pyazr UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'file.txt.7z' with pyazr.SevenZipFile(__snake_case , 'w' ) as archive: archive.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] , __snake_case : List[Any] ): '''simple docstring''' import tarfile UpperCAmelCase_ : Any = tmp_path_factory.mktemp('data' ) / 'file.txt.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' import lzma UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'file.txt.xz' UpperCAmelCase_ : Any = bytes(__snake_case , 'utf-8' ) with lzma.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[int] , __snake_case : Optional[Any] ): '''simple docstring''' import zipfile UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'file.txt.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' if datasets.config.ZSTANDARD_AVAILABLE: import zstandard as zstd UpperCAmelCase_ : Tuple = tmp_path_factory.mktemp('data' ) / 'file.txt.zst' UpperCAmelCase_ : List[str] = bytes(__snake_case , 'utf-8' ) with zstd.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'file.xml' UpperCAmelCase_ : List[Any] = textwrap.dedent( '\\n <?xml version="1.0" encoding="UTF-8" ?>\n <tmx version="1.4">\n <header segtype="sentence" srclang="ca" />\n <body>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 1</seg></tuv>\n <tuv xml:lang="en"><seg>Content 1</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 2</seg></tuv>\n <tuv xml:lang="en"><seg>Content 2</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 3</seg></tuv>\n <tuv xml:lang="en"><seg>Content 3</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 4</seg></tuv>\n <tuv xml:lang="en"><seg>Content 4</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 5</seg></tuv>\n <tuv xml:lang="en"><seg>Content 5</seg></tuv>\n </tu>\n </body>\n </tmx>' ) with open(__snake_case , 'w' ) as f: f.write(__snake_case ) return filename __UpperCAmelCase = [ {'col_1': '0', 'col_2': 0, 'col_3': 0.0}, {'col_1': '1', 'col_2': 1, 'col_3': 1.0}, {'col_1': '2', 'col_2': 2, 'col_3': 2.0}, {'col_1': '3', 'col_2': 3, 'col_3': 3.0}, ] __UpperCAmelCase = [ {'col_1': '4', 'col_2': 4, 'col_3': 4.0}, {'col_1': '5', 'col_2': 5, 'col_3': 5.0}, ] __UpperCAmelCase = { 'col_1': ['0', '1', '2', '3'], 'col_2': [0, 1, 2, 3], 'col_3': [0.0, 1.0, 2.0, 3.0], } __UpperCAmelCase = [ {'col_3': 0.0, 'col_1': '0', 'col_2': 0}, {'col_3': 1.0, 'col_1': '1', 'col_2': 1}, ] __UpperCAmelCase = [ {'col_1': 's0', 'col_2': 0, 'col_3': 0.0}, {'col_1': 's1', 'col_2': 1, 'col_3': 1.0}, {'col_1': 's2', 'col_2': 2, 'col_3': 2.0}, {'col_1': 's3', 'col_2': 3, 'col_3': 3.0}, ] @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return DATA_DICT_OF_LISTS @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : List[Any] = datasets.Dataset.from_dict(__snake_case ) UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.arrow' ) dataset.map(cache_file_name=__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset.sqlite' ) with contextlib.closing(sqlitea.connect(__snake_case ) ) as con: UpperCAmelCase_ : List[Any] = con.cursor() cur.execute('CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)' ) for item in DATA: cur.execute('INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)' , tuple(item.values() ) ) con.commit() return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.csv' ) with open(__snake_case , 'w' , newline='' ) as f: UpperCAmelCase_ : Tuple = csv.DictWriter(__snake_case , fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset2.csv' ) with open(__snake_case , 'w' , newline='' ) as f: UpperCAmelCase_ : Optional[Any] = csv.DictWriter(__snake_case , fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Any ): '''simple docstring''' import bza UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'dataset.csv.bz2' with open(__snake_case , 'rb' ) as f: UpperCAmelCase_ : int = f.read() # data = bytes(FILE_CONTENT, "utf-8") with bza.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] , __snake_case : Tuple , __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Optional[int] , __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(csv_path.replace('.csv' , '.CSV' ) ) ) f.write(__snake_case , arcname=os.path.basename(csva_path.replace('.csv' , '.CSV' ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : int , __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : int = str(tmp_path_factory.mktemp('data' ) / 'dataset.parquet' ) UpperCAmelCase_ : Dict = pa.schema( { 'col_1': pa.string(), 'col_2': pa.intaa(), 'col_3': pa.floataa(), } ) with open(__snake_case , 'wb' ) as f: UpperCAmelCase_ : List[Any] = pq.ParquetWriter(__snake_case , schema=__snake_case ) UpperCAmelCase_ : Any = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__snake_case ) )] for k in DATA[0]} , schema=__snake_case ) writer.write_table(__snake_case ) writer.close() return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) UpperCAmelCase_ : Optional[int] = {'data': DATA} with open(__snake_case , 'w' ) as f: json.dump(__snake_case , __snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) UpperCAmelCase_ : Tuple = {'data': DATA_DICT_OF_LISTS} with open(__snake_case , 'w' ) as f: json.dump(__snake_case , __snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : int = str(tmp_path_factory.mktemp('data' ) / 'dataset_312.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA_312: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset-str.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA_STR: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : Dict ): '''simple docstring''' import gzip UpperCAmelCase_ : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt.gz' ) with open(__snake_case , 'rb' ) as orig_file: with gzip.open(__snake_case , 'wb' ) as zipped_file: zipped_file.writelines(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int , __snake_case : Any ): '''simple docstring''' import gzip UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.gz' ) with open(__snake_case , 'rb' ) as orig_file: with gzip.open(__snake_case , 'wb' ) as zipped_file: zipped_file.writelines(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : Dict , __snake_case : Optional[int] ): '''simple docstring''' UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : str , __snake_case : Dict , __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : str = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('nested' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : Union[str, Any] , __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : str , __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Any , __snake_case : Any , __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.join('nested' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Any = ['0', '1', '2', '3'] UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt' ) with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = ['0', '1', '2', '3'] UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.txt' ) with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : Dict = ['0', '1', '2', '3'] UpperCAmelCase_ : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset.abc' with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any , __snake_case : Union[str, Any] , __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.text.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : str , __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.text.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] , __snake_case : str , __snake_case : Optional[int] ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'dataset.ext.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename('unsupported.ext' ) ) f.write(__snake_case , arcname=os.path.basename('unsupported_2.ext' ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' UpperCAmelCase_ : Tuple = '\n'.join(['First', 'Second\u2029with Unicode new line', 'Third'] ) UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset_with_unicode_new_lines.txt' ) with open(__snake_case , 'w' , encoding='utf-8' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return os.path.join('tests' , 'features' , 'data' , 'test_image_rgb.jpg' ) @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return os.path.join('tests' , 'features' , 'data' , 'test_audio_44100.wav' ) @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : List[str] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.img.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ).replace('.jpg' , '2.jpg' ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data_dir' ) (data_dir / "subdir").mkdir() with open(data_dir / 'subdir' / 'train.txt' , 'w' ) as f: f.write('foo\n' * 10 ) with open(data_dir / 'subdir' / 'test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) # hidden file with open(data_dir / 'subdir' / '.test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) # hidden directory (data_dir / ".subdir").mkdir() with open(data_dir / '.subdir' / 'train.txt' , 'w' ) as f: f.write('foo\n' * 10 ) with open(data_dir / '.subdir' / 'test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) return data_dir
29
1
from typing import List, Optional, Tuple, Union import torch from ...models import UNetaDModel from ...schedulers import ScoreSdeVeScheduler from ...utils import randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : UNetaDModel _snake_case : ScoreSdeVeScheduler def __init__( self , _UpperCamelCase , _UpperCamelCase ) -> int: super().__init__() self.register_modules(unet=_UpperCamelCase , scheduler=_UpperCamelCase ) @torch.no_grad() def __call__( self , _UpperCamelCase = 1 , _UpperCamelCase = 2_0_0_0 , _UpperCamelCase = None , _UpperCamelCase = "pil" , _UpperCamelCase = True , **_UpperCamelCase , ) -> Union[ImagePipelineOutput, Tuple]: UpperCAmelCase_ : List[Any] = self.unet.config.sample_size UpperCAmelCase_ : Optional[Any] = (batch_size, 3, img_size, img_size) UpperCAmelCase_ : Dict = self.unet UpperCAmelCase_ : Optional[Any] = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase ) * self.scheduler.init_noise_sigma UpperCAmelCase_ : List[Any] = sample.to(self.device ) self.scheduler.set_timesteps(_UpperCamelCase ) self.scheduler.set_sigmas(_UpperCamelCase ) for i, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): UpperCAmelCase_ : str = self.scheduler.sigmas[i] * torch.ones(shape[0] , device=self.device ) # correction step for _ in range(self.scheduler.config.correct_steps ): UpperCAmelCase_ : str = self.unet(_UpperCamelCase , _UpperCamelCase ).sample UpperCAmelCase_ : Tuple = self.scheduler.step_correct(_UpperCamelCase , _UpperCamelCase , generator=_UpperCamelCase ).prev_sample # prediction step UpperCAmelCase_ : str = model(_UpperCamelCase , _UpperCamelCase ).sample UpperCAmelCase_ : List[Any] = self.scheduler.step_pred(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , generator=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ : Any = output.prev_sample, output.prev_sample_mean UpperCAmelCase_ : Any = sample_mean.clamp(0 , 1 ) UpperCAmelCase_ : Optional[Any] = sample.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": UpperCAmelCase_ : Tuple = self.numpy_to_pil(_UpperCamelCase ) if not return_dict: return (sample,) return ImagePipelineOutput(images=_UpperCamelCase )
29
from __future__ import annotations def lowercase__ ( __snake_case : tuple[int, int] , __snake_case : int ): '''simple docstring''' UpperCAmelCase_ , UpperCAmelCase_ : Tuple = position UpperCAmelCase_ : str = [ (y + 1, x + 2), (y - 1, x + 2), (y + 1, x - 2), (y - 1, x - 2), (y + 2, x + 1), (y + 2, x - 1), (y - 2, x + 1), (y - 2, x - 1), ] UpperCAmelCase_ : Optional[Any] = [] for position in positions: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = position if 0 <= y_test < n and 0 <= x_test < n: permissible_positions.append(__snake_case ) return permissible_positions def lowercase__ ( __snake_case : list[list[int]] ): '''simple docstring''' return not any(elem == 0 for row in board for elem in row ) def lowercase__ ( __snake_case : list[list[int]] , __snake_case : tuple[int, int] , __snake_case : int ): '''simple docstring''' if is_complete(__snake_case ): return True for position in get_valid_pos(__snake_case , len(__snake_case ) ): UpperCAmelCase_ , UpperCAmelCase_ : Any = position if board[y][x] == 0: UpperCAmelCase_ : Optional[Any] = curr + 1 if open_knight_tour_helper(__snake_case , __snake_case , curr + 1 ): return True UpperCAmelCase_ : List[Any] = 0 return False def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : str = [[0 for i in range(__snake_case )] for j in range(__snake_case )] for i in range(__snake_case ): for j in range(__snake_case ): UpperCAmelCase_ : Optional[Any] = 1 if open_knight_tour_helper(__snake_case , (i, j) , 1 ): return board UpperCAmelCase_ : List[Any] = 0 UpperCAmelCase_ : List[str] = F"Open Kight Tour cannot be performed on a board of size {n}" raise ValueError(__snake_case ) if __name__ == "__main__": import doctest doctest.testmod()
29
1
import math from typing import Any, Callable, List, Optional, Tuple, Union import numpy as np import torch from ...models import TaFilmDecoder from ...schedulers import DDPMScheduler from ...utils import is_onnx_available, logging, randn_tensor if is_onnx_available(): from ..onnx_utils import OnnxRuntimeModel from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline from .continous_encoder import SpectrogramContEncoder from .notes_encoder import SpectrogramNotesEncoder __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = 256 class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Union[str, Any] = ['''melgan'''] def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> None: super().__init__() # From MELGAN UpperCAmelCase_ : Optional[Any] = math.log(1E-5 ) # Matches MelGAN training. UpperCAmelCase_ : Any = 4.0 # Largest value for most examples UpperCAmelCase_ : Optional[int] = 1_2_8 self.register_modules( notes_encoder=_UpperCamelCase , continuous_encoder=_UpperCamelCase , decoder=_UpperCamelCase , scheduler=_UpperCamelCase , melgan=_UpperCamelCase , ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=(-1.0, 1.0) , _UpperCamelCase=False ) -> Optional[Any]: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = output_range if clip: UpperCAmelCase_ : int = torch.clip(_UpperCamelCase , self.min_value , self.max_value ) # Scale to [0, 1]. UpperCAmelCase_ : List[str] = (features - self.min_value) / (self.max_value - self.min_value) # Scale to [min_out, max_out]. return zero_one * (max_out - min_out) + min_out def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=(-1.0, 1.0) , _UpperCamelCase=False ) -> Dict: UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = input_range UpperCAmelCase_ : int = torch.clip(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) if clip else outputs # Scale to [0, 1]. UpperCAmelCase_ : Union[str, Any] = (outputs - min_out) / (max_out - min_out) # Scale to [self.min_value, self.max_value]. return zero_one * (self.max_value - self.min_value) + self.min_value def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> int: UpperCAmelCase_ : List[Any] = input_tokens > 0 UpperCAmelCase_ , UpperCAmelCase_ : List[str] = self.notes_encoder( encoder_input_tokens=_UpperCamelCase , encoder_inputs_mask=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ : List[str] = self.continuous_encoder( encoder_inputs=_UpperCamelCase , encoder_inputs_mask=_UpperCamelCase ) return [(tokens_encoded, tokens_mask), (continuous_encoded, continuous_mask)] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> List[Any]: UpperCAmelCase_ : Tuple = noise_time if not torch.is_tensor(_UpperCamelCase ): UpperCAmelCase_ : int = torch.tensor([timesteps] , dtype=torch.long , device=input_tokens.device ) elif torch.is_tensor(_UpperCamelCase ) and len(timesteps.shape ) == 0: UpperCAmelCase_ : List[str] = timesteps[None].to(input_tokens.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML UpperCAmelCase_ : Optional[int] = timesteps * torch.ones(input_tokens.shape[0] , dtype=timesteps.dtype , device=timesteps.device ) UpperCAmelCase_ : List[str] = self.decoder( encodings_and_masks=_UpperCamelCase , decoder_input_tokens=_UpperCamelCase , decoder_noise_time=_UpperCamelCase ) return logits @torch.no_grad() def __call__( self , _UpperCamelCase , _UpperCamelCase = None , _UpperCamelCase = 1_0_0 , _UpperCamelCase = True , _UpperCamelCase = "numpy" , _UpperCamelCase = None , _UpperCamelCase = 1 , ) -> Union[AudioPipelineOutput, Tuple]: if (callback_steps is None) or ( callback_steps is not None and (not isinstance(_UpperCamelCase , _UpperCamelCase ) or callback_steps <= 0) ): raise ValueError( f"`callback_steps` has to be a positive integer but is {callback_steps} of type" f" {type(_UpperCamelCase )}." ) UpperCAmelCase_ : List[Any] = np.zeros([1, TARGET_FEATURE_LENGTH, self.n_dims] , dtype=np.floataa ) UpperCAmelCase_ : Union[str, Any] = np.zeros([1, 0, self.n_dims] , np.floataa ) UpperCAmelCase_ : str = torch.ones((1, TARGET_FEATURE_LENGTH) , dtype=_UpperCamelCase , device=self.device ) for i, encoder_input_tokens in enumerate(_UpperCamelCase ): if i == 0: UpperCAmelCase_ : Any = torch.from_numpy(pred_mel[:1].copy() ).to( device=self.device , dtype=self.decoder.dtype ) # The first chunk has no previous context. UpperCAmelCase_ : int = torch.zeros((1, TARGET_FEATURE_LENGTH) , dtype=_UpperCamelCase , device=self.device ) else: # The full song pipeline does not feed in a context feature, so the mask # will be all 0s after the feature converter. Because we know we're # feeding in a full context chunk from the previous prediction, set it # to all 1s. UpperCAmelCase_ : Optional[Any] = ones UpperCAmelCase_ : Union[str, Any] = self.scale_features( _UpperCamelCase , output_range=[-1.0, 1.0] , clip=_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = self.encode( input_tokens=torch.IntTensor([encoder_input_tokens] ).to(device=self.device ) , continuous_inputs=_UpperCamelCase , continuous_mask=_UpperCamelCase , ) # Sample encoder_continuous_inputs shaped gaussian noise to begin loop UpperCAmelCase_ : List[Any] = randn_tensor( shape=encoder_continuous_inputs.shape , generator=_UpperCamelCase , device=self.device , dtype=self.decoder.dtype , ) # set step values self.scheduler.set_timesteps(_UpperCamelCase ) # Denoising diffusion loop for j, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): UpperCAmelCase_ : str = self.decode( encodings_and_masks=_UpperCamelCase , input_tokens=_UpperCamelCase , noise_time=t / self.scheduler.config.num_train_timesteps , ) # Compute previous output: x_t -> x_t-1 UpperCAmelCase_ : List[str] = self.scheduler.step(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , generator=_UpperCamelCase ).prev_sample UpperCAmelCase_ : Tuple = self.scale_to_features(_UpperCamelCase , input_range=[-1.0, 1.0] ) UpperCAmelCase_ : List[str] = mel[:1] UpperCAmelCase_ : str = mel.cpu().float().numpy() UpperCAmelCase_ : Dict = np.concatenate([full_pred_mel, pred_mel[:1]] , axis=1 ) # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(_UpperCamelCase , _UpperCamelCase ) logger.info('Generated segment' , _UpperCamelCase ) if output_type == "numpy" and not is_onnx_available(): raise ValueError( 'Cannot return output in \'np\' format if ONNX is not available. Make sure to have ONNX installed or set \'output_type\' to \'mel\'.' ) elif output_type == "numpy" and self.melgan is None: raise ValueError( 'Cannot return output in \'np\' format if melgan component is not defined. Make sure to define `self.melgan` or set \'output_type\' to \'mel\'.' ) if output_type == "numpy": UpperCAmelCase_ : List[Any] = self.melgan(input_features=full_pred_mel.astype(np.floataa ) ) else: UpperCAmelCase_ : str = full_pred_mel if not return_dict: return (output,) return AudioPipelineOutput(audios=_UpperCamelCase )
29
def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : list[list[int]] = [[0 for _ in range(__snake_case )] for _ in range(m + 1 )] for i in range(m + 1 ): UpperCAmelCase_ : Optional[Any] = 1 for n in range(m + 1 ): for k in range(1 , __snake_case ): memo[n][k] += memo[n][k - 1] if n - k > 0: memo[n][k] += memo[n - k - 1][k] return memo[m][m - 1] if __name__ == "__main__": import sys if len(sys.argv) == 1: try: __UpperCAmelCase = int(input('Enter a number: ').strip()) print(partition(n)) except ValueError: print('Please enter a number.') else: try: __UpperCAmelCase = int(sys.argv[1]) print(partition(n)) except ValueError: print('Please pass a number.')
29
1
from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'studio-ousia/luke-base': 'https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json', 'studio-ousia/luke-large': 'https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json', } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : int = '''luke''' def __init__( self , _UpperCamelCase=5_0_2_6_7 , _UpperCamelCase=5_0_0_0_0_0 , _UpperCamelCase=7_6_8 , _UpperCamelCase=2_5_6 , _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=True , _UpperCamelCase=None , _UpperCamelCase=1 , _UpperCamelCase=0 , _UpperCamelCase=2 , **_UpperCamelCase , ) -> str: super().__init__(pad_token_id=_UpperCamelCase , bos_token_id=_UpperCamelCase , eos_token_id=_UpperCamelCase , **_UpperCamelCase ) UpperCAmelCase_ : Any = vocab_size UpperCAmelCase_ : Optional[int] = entity_vocab_size UpperCAmelCase_ : Optional[int] = hidden_size UpperCAmelCase_ : Optional[int] = entity_emb_size UpperCAmelCase_ : Optional[int] = num_hidden_layers UpperCAmelCase_ : int = num_attention_heads UpperCAmelCase_ : str = hidden_act UpperCAmelCase_ : Any = intermediate_size UpperCAmelCase_ : Any = hidden_dropout_prob UpperCAmelCase_ : Optional[Any] = attention_probs_dropout_prob UpperCAmelCase_ : List[str] = max_position_embeddings UpperCAmelCase_ : str = type_vocab_size UpperCAmelCase_ : Dict = initializer_range UpperCAmelCase_ : Optional[Any] = layer_norm_eps UpperCAmelCase_ : Optional[int] = use_entity_aware_attention UpperCAmelCase_ : Optional[int] = classifier_dropout
29
from typing import Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING __UpperCAmelCase = logging.get_logger(__name__) @add_end_docstrings(_snake_case ) class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , *_UpperCamelCase , **_UpperCamelCase ) -> int: super().__init__(*_UpperCamelCase , **_UpperCamelCase ) self.check_model_type(_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase=None , **_UpperCamelCase ) -> List[Any]: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = {}, {} if padding is not None: UpperCAmelCase_ : List[str] = padding if truncation is not None: UpperCAmelCase_ : Tuple = truncation if top_k is not None: UpperCAmelCase_ : Dict = top_k return preprocess_params, {}, postprocess_params def __call__( self , _UpperCamelCase , _UpperCamelCase = None , **_UpperCamelCase ) -> int: if isinstance(_UpperCamelCase , (Image.Image, str) ) and isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Optional[Any] = {'image': image, 'question': question} else: UpperCAmelCase_ : List[str] = image UpperCAmelCase_ : Optional[Any] = super().__call__(_UpperCamelCase , **_UpperCamelCase ) return results def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=False , _UpperCamelCase=False ) -> Optional[Any]: UpperCAmelCase_ : List[Any] = load_image(inputs['image'] ) UpperCAmelCase_ : Dict = self.tokenizer( inputs['question'] , return_tensors=self.framework , padding=_UpperCamelCase , truncation=_UpperCamelCase ) UpperCAmelCase_ : int = self.image_processor(images=_UpperCamelCase , return_tensors=self.framework ) model_inputs.update(_UpperCamelCase ) return model_inputs def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[int]: UpperCAmelCase_ : Any = self.model(**_UpperCamelCase ) return model_outputs def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=5 ) -> str: if top_k > self.model.config.num_labels: UpperCAmelCase_ : Union[str, Any] = self.model.config.num_labels if self.framework == "pt": UpperCAmelCase_ : List[str] = model_outputs.logits.sigmoid()[0] UpperCAmelCase_ , UpperCAmelCase_ : str = probs.topk(_UpperCamelCase ) else: raise ValueError(f"Unsupported framework: {self.framework}" ) UpperCAmelCase_ : Optional[Any] = scores.tolist() UpperCAmelCase_ : Tuple = ids.tolist() return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(_UpperCamelCase , _UpperCamelCase )]
29
1
def lowercase__ ( __snake_case : int , __snake_case : list[int] , __snake_case : int ): '''simple docstring''' def count_of_possible_combinations(__snake_case : int ) -> int: if target < 0: return 0 if target == 0: return 1 return sum(count_of_possible_combinations(target - item ) for item in array ) return count_of_possible_combinations(__snake_case ) def lowercase__ ( __snake_case : int , __snake_case : list[int] , __snake_case : int ): '''simple docstring''' def count_of_possible_combinations_with_dp_array( __snake_case : int , __snake_case : list[int] ) -> int: if target < 0: return 0 if target == 0: return 1 if dp_array[target] != -1: return dp_array[target] UpperCAmelCase_ : Optional[Any] = sum( count_of_possible_combinations_with_dp_array(target - item , __snake_case ) for item in array ) UpperCAmelCase_ : Any = answer return answer UpperCAmelCase_ : Tuple = [-1] * (target + 1) return count_of_possible_combinations_with_dp_array(__snake_case , __snake_case ) def lowercase__ ( __snake_case : int , __snake_case : list[int] , __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : List[str] = [0] * (target + 1) UpperCAmelCase_ : List[str] = 1 for i in range(1 , target + 1 ): for j in range(__snake_case ): if i - array[j] >= 0: dp_array[i] += dp_array[i - array[j]] return dp_array[target] if __name__ == "__main__": import doctest doctest.testmod() __UpperCAmelCase = 3 __UpperCAmelCase = 5 __UpperCAmelCase = [1, 2, 5] print(combination_sum_iv(n, array, target))
29
import os # Precomputes a list of the 100 first triangular numbers __UpperCAmelCase = [int(0.5 * n * (n + 1)) for n in range(1, 101)] def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Any = os.path.dirname(os.path.realpath(__snake_case ) ) UpperCAmelCase_ : Optional[Any] = os.path.join(__snake_case , 'words.txt' ) UpperCAmelCase_ : Union[str, Any] = '' with open(__snake_case ) as f: UpperCAmelCase_ : List[Any] = f.readline() UpperCAmelCase_ : Optional[int] = [word.strip('"' ) for word in words.strip('\r\n' ).split(',' )] UpperCAmelCase_ : Optional[int] = [ word for word in [sum(ord(__snake_case ) - 64 for x in word ) for word in words] if word in TRIANGULAR_NUMBERS ] return len(__snake_case ) if __name__ == "__main__": print(solution())
29
1
from typing import TYPE_CHECKING from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available __UpperCAmelCase = {'configuration_van': ['VAN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VanConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'VAN_PRETRAINED_MODEL_ARCHIVE_LIST', 'VanForImageClassification', 'VanModel', 'VanPreTrainedModel', ] if TYPE_CHECKING: from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_van import ( VAN_PRETRAINED_MODEL_ARCHIVE_LIST, VanForImageClassification, VanModel, VanPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure)
29
import importlib import shutil import threading import warnings from typing import List import fsspec import fsspec.asyn from . import compression from .hffilesystem import HfFileSystem __UpperCAmelCase = importlib.util.find_spec('s3fs') is not None if _has_safs: from .safilesystem import SaFileSystem # noqa: F401 __UpperCAmelCase = [ compression.BzaFileSystem, compression.GzipFileSystem, compression.LzaFileSystem, compression.XzFileSystem, compression.ZstdFileSystem, ] # Register custom filesystems for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]: if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class: warnings.warn(F'A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.') fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True) def lowercase__ ( __snake_case : str ): '''simple docstring''' if "://" in dataset_path: UpperCAmelCase_ : int = dataset_path.split('://' )[1] return dataset_path def lowercase__ ( __snake_case : fsspec.AbstractFileSystem ): '''simple docstring''' if fs is not None and fs.protocol != "file": return True else: return False def lowercase__ ( __snake_case : fsspec.AbstractFileSystem , __snake_case : str , __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : List[str] = not is_remote_filesystem(__snake_case ) if is_local: # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory shutil.move(fs._strip_protocol(__snake_case ) , fs._strip_protocol(__snake_case ) ) else: fs.mv(__snake_case , __snake_case , recursive=__snake_case ) def lowercase__ ( ): '''simple docstring''' if hasattr(fsspec.asyn , 'reset_lock' ): # for future fsspec>2022.05.0 fsspec.asyn.reset_lock() else: UpperCAmelCase_ : Optional[Any] = None UpperCAmelCase_ : Union[str, Any] = None UpperCAmelCase_ : int = threading.Lock()
29
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = {'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST', 'ViTMSNModel', 'ViTMSNForImageClassification', 'ViTMSNPreTrainedModel', ] if TYPE_CHECKING: from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_msn import ( VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMSNForImageClassification, ViTMSNModel, ViTMSNPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
def lowercase__ ( __snake_case : list ): '''simple docstring''' for i in range(len(__snake_case ) - 1 , 0 , -1 ): UpperCAmelCase_ : Dict = False for j in range(__snake_case , 0 , -1 ): if unsorted[j] < unsorted[j - 1]: UpperCAmelCase_ , UpperCAmelCase_ : Any = unsorted[j - 1], unsorted[j] UpperCAmelCase_ : int = True for j in range(__snake_case ): if unsorted[j] > unsorted[j + 1]: UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = unsorted[j + 1], unsorted[j] UpperCAmelCase_ : Any = True if not swapped: break return unsorted if __name__ == "__main__": import doctest doctest.testmod() __UpperCAmelCase = input('Enter numbers separated by a comma:\n').strip() __UpperCAmelCase = [int(item) for item in user_input.split(',')] print(F'{cocktail_shaker_sort(unsorted) = }')
29
1
import os import re import warnings from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_ta import TaTokenizer else: __UpperCAmelCase = None __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'} __UpperCAmelCase = { 'vocab_file': { 't5-small': 'https://huggingface.co/t5-small/resolve/main/spiece.model', 't5-base': 'https://huggingface.co/t5-base/resolve/main/spiece.model', 't5-large': 'https://huggingface.co/t5-large/resolve/main/spiece.model', 't5-3b': 'https://huggingface.co/t5-3b/resolve/main/spiece.model', 't5-11b': 'https://huggingface.co/t5-11b/resolve/main/spiece.model', }, 'tokenizer_file': { 't5-small': 'https://huggingface.co/t5-small/resolve/main/tokenizer.json', 't5-base': 'https://huggingface.co/t5-base/resolve/main/tokenizer.json', 't5-large': 'https://huggingface.co/t5-large/resolve/main/tokenizer.json', 't5-3b': 'https://huggingface.co/t5-3b/resolve/main/tokenizer.json', 't5-11b': 'https://huggingface.co/t5-11b/resolve/main/tokenizer.json', }, } # TODO(PVP) - this should be removed in Transformers v5 __UpperCAmelCase = { 't5-small': 512, 't5-base': 512, 't5-large': 512, 't5-3b': 512, 't5-11b': 512, } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : int = VOCAB_FILES_NAMES _snake_case : Optional[Any] = PRETRAINED_VOCAB_FILES_MAP _snake_case : str = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _snake_case : str = ['''input_ids''', '''attention_mask'''] _snake_case : List[Any] = TaTokenizer _snake_case : List[int] = [] def __init__( self , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase="</s>" , _UpperCamelCase="<unk>" , _UpperCamelCase="<pad>" , _UpperCamelCase=1_0_0 , _UpperCamelCase=None , **_UpperCamelCase , ) -> str: # Add extra_ids to the special token list if extra_ids > 0 and additional_special_tokens is None: UpperCAmelCase_ : List[str] = [f"<extra_id_{i}>" for i in range(_UpperCamelCase )] elif extra_ids > 0 and additional_special_tokens is not None: # Check that we have the right number of extra special tokens UpperCAmelCase_ : Tuple = len(set(filter(lambda _UpperCamelCase : bool('extra_id_' in str(_UpperCamelCase ) ) , _UpperCamelCase ) ) ) if extra_tokens != extra_ids: raise ValueError( f"Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are" ' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids' ' tokens' ) super().__init__( _UpperCamelCase , tokenizer_file=_UpperCamelCase , eos_token=_UpperCamelCase , unk_token=_UpperCamelCase , pad_token=_UpperCamelCase , extra_ids=_UpperCamelCase , additional_special_tokens=_UpperCamelCase , **_UpperCamelCase , ) UpperCAmelCase_ : Any = vocab_file UpperCAmelCase_ : Tuple = False if not self.vocab_file else True UpperCAmelCase_ : str = extra_ids @staticmethod def __UpperCAmelCase ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> int: if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes: UpperCAmelCase_ : Any = TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path] if init_max_model_length is not None and init_max_model_length != max_model_length: return init_max_model_length elif init_max_model_length is None: warnings.warn( 'This tokenizer was incorrectly instantiated with a model max length of' f" {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this" ' behavior is kept to avoid breaking backwards compatibility when padding/encoding with' ' `truncation is True`.\n- Be aware that you SHOULD NOT rely on' f" {pretrained_model_name_or_path} automatically truncating your input to" f" {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences" f" longer than {deprecated_max_model_length} you can either instantiate this tokenizer with" ' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please' ' instantiate this tokenizer with `model_max_length` set to your preferred value.' , _UpperCamelCase , ) return max_model_length def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> Tuple[str]: 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(_UpperCamelCase ): logger.error(f"Vocabulary path ({save_directory}) should be a directory" ) return UpperCAmelCase_ : int = os.path.join( _UpperCamelCase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_UpperCamelCase ): copyfile(self.vocab_file , _UpperCamelCase ) logger.info(f"Copy vocab file to {out_vocab_file}" ) return (out_vocab_file,) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> List[int]: UpperCAmelCase_ : List[str] = token_ids_a + [self.eos_token_id] if token_ids_a is None: return self.prefix_tokens + token_ids_a else: UpperCAmelCase_ : int = token_ids_a + [self.eos_token_id] return self.prefix_tokens + token_ids_a + token_ids_a def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> List[int]: UpperCAmelCase_ : Any = [self.eos_token_id] if token_ids_a is None: return len(token_ids_a + eos ) * [0] return len(token_ids_a + eos + token_ids_a + eos ) * [0] def __UpperCAmelCase ( self ) -> Tuple: return list( set(filter(lambda _UpperCamelCase : bool(re.search(r'<extra_id_\d+>' , _UpperCamelCase ) ) is not None , self.additional_special_tokens ) ) ) def __UpperCAmelCase ( self ) -> str: return [self.convert_tokens_to_ids(_UpperCamelCase ) for token in self.get_sentinel_tokens()]
29
from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = '\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n >>> from diffusers.utils import load_image\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n ... "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16\n ... )\n >>> pipe_prior.to("cuda")\n\n >>> prompt = "A red cartoon frog, 4k"\n >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n ... "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16\n ... )\n >>> pipe.to("cuda")\n\n >>> init_image = load_image(\n ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"\n ... "/kandinsky/frog.png"\n ... )\n\n >>> image = pipe(\n ... image=init_image,\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... strength=0.2,\n ... ).images\n\n >>> image[0].save("red_frog.png")\n ```\n' def lowercase__ ( __snake_case : List[str] , __snake_case : int , __snake_case : Tuple=8 ): '''simple docstring''' UpperCAmelCase_ : Dict = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 UpperCAmelCase_ : List[Any] = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def lowercase__ ( __snake_case : Any , __snake_case : int=512 , __snake_case : Dict=512 ): '''simple docstring''' UpperCAmelCase_ : Tuple = pil_image.resize((w, h) , resample=Image.BICUBIC , reducing_gap=1 ) UpperCAmelCase_ : Dict = np.array(pil_image.convert('RGB' ) ) UpperCAmelCase_ : Any = arr.astype(np.floataa ) / 127.5 - 1 UpperCAmelCase_ : Dict = np.transpose(__snake_case , [2, 0, 1] ) UpperCAmelCase_ : List[str] = torch.from_numpy(__snake_case ).unsqueeze(0 ) return image class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Union[str, Any]: super().__init__() self.register_modules( unet=_UpperCamelCase , scheduler=_UpperCamelCase , movq=_UpperCamelCase , ) UpperCAmelCase_ : Tuple = 2 ** (len(self.movq.config.block_out_channels ) - 1) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: # get the original timestep using init_timestep UpperCAmelCase_ : Any = min(int(num_inference_steps * strength ) , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = max(num_inference_steps - init_timestep , 0 ) UpperCAmelCase_ : str = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=None ) -> Tuple: if not isinstance(_UpperCamelCase , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( f"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : List[str] = image.to(device=_UpperCamelCase , dtype=_UpperCamelCase ) UpperCAmelCase_ : List[str] = batch_size * num_images_per_prompt if image.shape[1] == 4: UpperCAmelCase_ : List[str] = image else: if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != batch_size: raise ValueError( f"You have passed a list of generators of length {len(_UpperCamelCase )}, but requested an effective batch" f" size of {batch_size}. Make sure the batch size matches the length of the generators." ) elif isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Any = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(_UpperCamelCase ) ] UpperCAmelCase_ : Tuple = torch.cat(_UpperCamelCase , dim=0 ) else: UpperCAmelCase_ : Union[str, Any] = self.movq.encode(_UpperCamelCase ).latent_dist.sample(_UpperCamelCase ) UpperCAmelCase_ : int = self.movq.config.scaling_factor * init_latents UpperCAmelCase_ : Optional[int] = torch.cat([init_latents] , dim=0 ) UpperCAmelCase_ : Tuple = init_latents.shape UpperCAmelCase_ : List[Any] = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) # get latents UpperCAmelCase_ : str = self.scheduler.add_noise(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = init_latents return latents def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Any: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) UpperCAmelCase_ : Optional[Any] = torch.device(f"cuda:{gpu_id}" ) UpperCAmelCase_ : Optional[Any] = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Union[str, Any]: if is_accelerate_available() and is_accelerate_version('>=' , '0.17.0.dev0' ): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.' ) UpperCAmelCase_ : str = torch.device(f"cuda:{gpu_id}" ) if self.device.type != "cpu": self.to('cpu' , silence_dtype_warnings=_UpperCamelCase ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) UpperCAmelCase_ : Dict = None for cpu_offloaded_model in [self.unet, self.movq]: UpperCAmelCase_ , UpperCAmelCase_ : Dict = cpu_offload_with_hook(_UpperCamelCase , _UpperCamelCase , prev_module_hook=_UpperCamelCase ) # We'll offload the last model manually. UpperCAmelCase_ : Any = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def __UpperCAmelCase ( self ) -> Dict: if not hasattr(self.unet , '_hf_hook' ): return self.device for module in self.unet.modules(): if ( hasattr(_UpperCamelCase , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() @replace_example_docstring(_UpperCamelCase ) def __call__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 5_1_2 , _UpperCamelCase = 1_0_0 , _UpperCamelCase = 4.0 , _UpperCamelCase = 0.3 , _UpperCamelCase = 1 , _UpperCamelCase = None , _UpperCamelCase = "pil" , _UpperCamelCase = True , ) -> str: UpperCAmelCase_ : Any = self._execution_device UpperCAmelCase_ : Union[str, Any] = guidance_scale > 1.0 if isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : str = torch.cat(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : Optional[Any] = image_embeds.shape[0] if isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Union[str, Any] = torch.cat(_UpperCamelCase , dim=0 ) if do_classifier_free_guidance: UpperCAmelCase_ : int = image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : int = negative_image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) UpperCAmelCase_ : Optional[Any] = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=_UpperCamelCase ) if not isinstance(_UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Tuple = [image] if not all(isinstance(_UpperCamelCase , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( f"Input is in incorrect format: {[type(_UpperCamelCase ) for i in image]}. Currently, we only support PIL image and pytorch tensor" ) UpperCAmelCase_ : str = torch.cat([prepare_image(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) for i in image] , dim=0 ) UpperCAmelCase_ : Any = image.to(dtype=image_embeds.dtype , device=_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.movq.encode(_UpperCamelCase )['latents'] UpperCAmelCase_ : List[Any] = latents.repeat_interleave(_UpperCamelCase , dim=0 ) self.scheduler.set_timesteps(_UpperCamelCase , device=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ : Any = self.get_timesteps(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = timesteps[:1].repeat(batch_size * num_images_per_prompt ) UpperCAmelCase_ , UpperCAmelCase_ : str = downscale_height_and_width(_UpperCamelCase , _UpperCamelCase , self.movq_scale_factor ) UpperCAmelCase_ : Dict = self.prepare_latents( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , image_embeds.dtype , _UpperCamelCase , _UpperCamelCase ) for i, t in enumerate(self.progress_bar(_UpperCamelCase ) ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : Optional[Any] = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : str = {'image_embeds': image_embeds} UpperCAmelCase_ : Union[str, Any] = self.unet( sample=_UpperCamelCase , timestep=_UpperCamelCase , encoder_hidden_states=_UpperCamelCase , added_cond_kwargs=_UpperCamelCase , return_dict=_UpperCamelCase , )[0] if do_classifier_free_guidance: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = noise_pred.split(latents.shape[1] , dim=1 ) UpperCAmelCase_ , UpperCAmelCase_ : str = noise_pred.chunk(2 ) UpperCAmelCase_ , UpperCAmelCase_ : str = variance_pred.chunk(2 ) UpperCAmelCase_ : Dict = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) UpperCAmelCase_ : Tuple = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , 'variance_type' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): UpperCAmelCase_ , UpperCAmelCase_ : int = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 UpperCAmelCase_ : List[str] = self.scheduler.step( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , generator=_UpperCamelCase , )[0] # post-processing UpperCAmelCase_ : Optional[Any] = self.movq.decode(_UpperCamelCase , force_not_quantize=_UpperCamelCase )['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}" ) if output_type in ["np", "pil"]: UpperCAmelCase_ : List[str] = image * 0.5 + 0.5 UpperCAmelCase_ : List[Any] = image.clamp(0 , 1 ) UpperCAmelCase_ : Dict = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": UpperCAmelCase_ : List[Any] = self.numpy_to_pil(_UpperCamelCase ) if not return_dict: return (image,) return ImagePipelineOutput(images=_UpperCamelCase )
29
1
import argparse import json from collections import OrderedDict from functools import partial from pathlib import Path import timm import torch from huggingface_hub import hf_hub_download from transformers import LevitConfig, LevitForImageClassificationWithTeacher, LevitImageProcessor from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger() def lowercase__ ( __snake_case : int , __snake_case : str , __snake_case : LevitConfig , __snake_case : Path , __snake_case : bool = True ): '''simple docstring''' print(F"Converting {name}..." ) with torch.no_grad(): if hidden_sizes == 128: if name[-1] == "S": UpperCAmelCase_ : Union[str, Any] = timm.create_model('levit_128s' , pretrained=__snake_case ) else: UpperCAmelCase_ : List[Any] = timm.create_model('levit_128' , pretrained=__snake_case ) if hidden_sizes == 192: UpperCAmelCase_ : Tuple = timm.create_model('levit_192' , pretrained=__snake_case ) if hidden_sizes == 256: UpperCAmelCase_ : Optional[int] = timm.create_model('levit_256' , pretrained=__snake_case ) if hidden_sizes == 384: UpperCAmelCase_ : Any = timm.create_model('levit_384' , pretrained=__snake_case ) from_model.eval() UpperCAmelCase_ : Dict = LevitForImageClassificationWithTeacher(__snake_case ).eval() UpperCAmelCase_ : Tuple = OrderedDict() UpperCAmelCase_ : List[Any] = from_model.state_dict() UpperCAmelCase_ : int = list(from_model.state_dict().keys() ) UpperCAmelCase_ : Union[str, Any] = list(our_model.state_dict().keys() ) print(len(__snake_case ) , len(__snake_case ) ) for i in range(len(__snake_case ) ): UpperCAmelCase_ : int = weights[og_keys[i]] our_model.load_state_dict(__snake_case ) UpperCAmelCase_ : str = torch.randn((2, 3, 224, 224) ) UpperCAmelCase_ : List[Any] = from_model(__snake_case ) UpperCAmelCase_ : Any = our_model(__snake_case ).logits assert torch.allclose(__snake_case , __snake_case ), "The model logits don't match the original one." UpperCAmelCase_ : str = name print(__snake_case ) if push_to_hub: our_model.save_pretrained(save_directory / checkpoint_name ) UpperCAmelCase_ : Dict = LevitImageProcessor() image_processor.save_pretrained(save_directory / checkpoint_name ) print(F"Pushed {checkpoint_name}" ) def lowercase__ ( __snake_case : Path , __snake_case : str = None , __snake_case : bool = True ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = 'imagenet-1k-id2label.json' UpperCAmelCase_ : Union[str, Any] = 1_000 UpperCAmelCase_ : Tuple = (1, num_labels) UpperCAmelCase_ : Tuple = 'huggingface/label-files' UpperCAmelCase_ : Union[str, Any] = num_labels UpperCAmelCase_ : Any = json.load(open(hf_hub_download(__snake_case , __snake_case , repo_type='dataset' ) , 'r' ) ) UpperCAmelCase_ : Optional[int] = {int(__snake_case ): v for k, v in idalabel.items()} UpperCAmelCase_ : int = idalabel UpperCAmelCase_ : int = {v: k for k, v in idalabel.items()} UpperCAmelCase_ : Optional[int] = partial(__snake_case , num_labels=__snake_case , idalabel=__snake_case , labelaid=__snake_case ) UpperCAmelCase_ : Tuple = { 'levit-128S': 128, 'levit-128': 128, 'levit-192': 192, 'levit-256': 256, 'levit-384': 384, } UpperCAmelCase_ : int = { 'levit-128S': ImageNetPreTrainedConfig( hidden_sizes=[128, 256, 384] , num_attention_heads=[4, 6, 8] , depths=[2, 3, 4] , key_dim=[16, 16, 16] , drop_path_rate=0 , ), 'levit-128': ImageNetPreTrainedConfig( hidden_sizes=[128, 256, 384] , num_attention_heads=[4, 8, 12] , depths=[4, 4, 4] , key_dim=[16, 16, 16] , drop_path_rate=0 , ), 'levit-192': ImageNetPreTrainedConfig( hidden_sizes=[192, 288, 384] , num_attention_heads=[3, 5, 6] , depths=[4, 4, 4] , key_dim=[32, 32, 32] , drop_path_rate=0 , ), 'levit-256': ImageNetPreTrainedConfig( hidden_sizes=[256, 384, 512] , num_attention_heads=[4, 6, 8] , depths=[4, 4, 4] , key_dim=[32, 32, 32] , drop_path_rate=0 , ), 'levit-384': ImageNetPreTrainedConfig( hidden_sizes=[384, 512, 768] , num_attention_heads=[6, 9, 12] , depths=[4, 4, 4] , key_dim=[32, 32, 32] , drop_path_rate=0.1 , ), } if model_name: convert_weight_and_push( names_to_hidden_sizes[model_name] , __snake_case , names_to_config[model_name] , __snake_case , __snake_case ) else: for model_name, config in names_to_config.items(): convert_weight_and_push(names_to_hidden_sizes[model_name] , __snake_case , __snake_case , __snake_case , __snake_case ) return config, expected_shape if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default=None, type=str, help='The name of the model you wish to convert, it must be one of the supported Levit* architecture,', ) parser.add_argument( '--pytorch_dump_folder_path', default='levit-dump-folder/', type=Path, required=False, help='Path to the output PyTorch model directory.', ) parser.add_argument('--push_to_hub', action='store_true', help='Push model and image processor to the hub') parser.add_argument( '--no-push_to_hub', dest='push_to_hub', action='store_false', help='Do not push model and image processor to the hub', ) __UpperCAmelCase = parser.parse_args() __UpperCAmelCase = args.pytorch_dump_folder_path pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True) convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
29
import asyncio import os import shutil import subprocess import sys import tempfile import unittest from distutils.util import strtobool from functools import partial from pathlib import Path from typing import List, Union from unittest import mock import torch from ..state import AcceleratorState, PartialState from ..utils import ( gather, is_bnb_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_mps_available, is_safetensors_available, is_tensorboard_available, is_torch_version, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) def lowercase__ ( __snake_case : List[Any] , __snake_case : List[str]=False ): '''simple docstring''' try: UpperCAmelCase_ : int = os.environ[key] except KeyError: # KEY isn't set, default to `default`. UpperCAmelCase_ : Optional[int] = default else: # KEY is set, convert it to True or False. try: UpperCAmelCase_ : List[Any] = strtobool(__snake_case ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"If set, {key} must be yes or no." ) return _value __UpperCAmelCase = parse_flag_from_env('RUN_SLOW', default=False) def lowercase__ ( __snake_case : int ): '''simple docstring''' return unittest.skip('Test was skipped' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(_run_slow_tests , 'test is slow' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(not torch.cuda.is_available() , 'test requires only a CPU' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(torch.cuda.is_available() , 'test requires a GPU' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(is_xpu_available() , 'test requires a XPU' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_mps_available() , 'test requires a `mps` backend support in `torch`' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless( is_transformers_available() and is_datasets_available() , 'test requires the Hugging Face suite' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_bnb_available() , 'test requires the bitsandbytes library' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(is_tpu_available() , 'test requires TPU' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() == 1 , 'test requires a GPU' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() == 1 , 'test requires a XPU' )(__snake_case ) def lowercase__ ( __snake_case : Optional[int] ): '''simple docstring''' return unittest.skipUnless(torch.cuda.device_count() > 1 , 'test requires multiple GPUs' )(__snake_case ) def lowercase__ ( __snake_case : int ): '''simple docstring''' return unittest.skipUnless(torch.xpu.device_count() > 1 , 'test requires multiple XPUs' )(__snake_case ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' return unittest.skipUnless(is_safetensors_available() , 'test requires safetensors' )(__snake_case ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' return unittest.skipUnless(is_deepspeed_available() , 'test requires DeepSpeed' )(__snake_case ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' return unittest.skipUnless(is_torch_version('>=' , '1.12.0' ) , 'test requires torch version >= 1.12.0' )(__snake_case ) def lowercase__ ( __snake_case : Dict=None , __snake_case : Dict=None ): '''simple docstring''' if test_case is None: return partial(__snake_case , version=__snake_case ) return unittest.skipUnless(is_torch_version('>=' , __snake_case ) , F"test requires torch version >= {version}" )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_tensorboard_available() , 'test requires Tensorboard' )(__snake_case ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' return unittest.skipUnless(is_wandb_available() , 'test requires wandb' )(__snake_case ) def lowercase__ ( __snake_case : str ): '''simple docstring''' return unittest.skipUnless(is_comet_ml_available() , 'test requires comet_ml' )(__snake_case ) __UpperCAmelCase = ( any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available() ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' return unittest.skipUnless( _atleast_one_tracker_available , 'test requires at least one tracker to be available and for `comet_ml` to not be installed' , )(__snake_case ) class lowerCamelCase (unittest.TestCase ): '''simple docstring''' _snake_case : Union[str, Any] = True @classmethod def __UpperCAmelCase ( cls ) -> Union[str, Any]: UpperCAmelCase_ : List[Any] = tempfile.mkdtemp() @classmethod def __UpperCAmelCase ( cls ) -> List[str]: if os.path.exists(cls.tmpdir ): shutil.rmtree(cls.tmpdir ) def __UpperCAmelCase ( self ) -> str: if self.clear_on_setup: for path in Path(self.tmpdir ).glob('**/*' ): if path.is_file(): path.unlink() elif path.is_dir(): shutil.rmtree(_UpperCamelCase ) class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Optional[int]: super().tearDown() # Reset the state of the AcceleratorState singleton. AcceleratorState._reset_state() PartialState._reset_state() class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self , _UpperCamelCase ) -> Any: UpperCAmelCase_ : List[Any] = mocks if isinstance(_UpperCamelCase , (tuple, list) ) else [mocks] for m in self.mocks: m.start() self.addCleanup(m.stop ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : int = AcceleratorState() UpperCAmelCase_ : str = tensor[None].clone().to(state.device ) UpperCAmelCase_ : List[str] = gather(__snake_case ).cpu() UpperCAmelCase_ : List[Any] = tensor[0].cpu() for i in range(tensors.shape[0] ): if not torch.equal(tensors[i] , __snake_case ): return False return True class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : str = returncode UpperCAmelCase_ : Optional[Any] = stdout UpperCAmelCase_ : Optional[Any] = stderr async def lowercase__ ( __snake_case : Optional[Any] , __snake_case : Optional[int] ): '''simple docstring''' while True: UpperCAmelCase_ : Dict = await stream.readline() if line: callback(__snake_case ) else: break async def lowercase__ ( __snake_case : Optional[int] , __snake_case : Dict=None , __snake_case : str=None , __snake_case : Dict=None , __snake_case : List[str]=False , __snake_case : Optional[int]=False ): '''simple docstring''' if echo: print('\nRunning: ' , ' '.join(__snake_case ) ) UpperCAmelCase_ : Optional[Any] = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=__snake_case , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=__snake_case , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) UpperCAmelCase_ : Any = [] UpperCAmelCase_ : str = [] def tee(__snake_case : Dict , __snake_case : Union[str, Any] , __snake_case : Tuple , __snake_case : Optional[int]="" ): UpperCAmelCase_ : List[str] = line.decode('utf-8' ).rstrip() sink.append(__snake_case ) if not quiet: print(__snake_case , __snake_case , file=__snake_case ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ asyncio.create_task(_read_stream(p.stdout , lambda __snake_case : tee(__snake_case , __snake_case , sys.stdout , label='stdout:' ) ) ), asyncio.create_task(_read_stream(p.stderr , lambda __snake_case : tee(__snake_case , __snake_case , sys.stderr , label='stderr:' ) ) ), ] , timeout=__snake_case , ) return _RunOutput(await p.wait() , __snake_case , __snake_case ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : List[Any]=None , __snake_case : str=None , __snake_case : Tuple=180 , __snake_case : Dict=False , __snake_case : Optional[Any]=True ): '''simple docstring''' UpperCAmelCase_ : str = asyncio.get_event_loop() UpperCAmelCase_ : int = loop.run_until_complete( _stream_subprocess(__snake_case , env=__snake_case , stdin=__snake_case , timeout=__snake_case , quiet=__snake_case , echo=__snake_case ) ) UpperCAmelCase_ : int = ' '.join(__snake_case ) if result.returncode > 0: UpperCAmelCase_ : int = '\n'.join(result.stderr ) raise RuntimeError( F"'{cmd_str}' failed with returncode {result.returncode}\n\n" F"The combined stderr from workers follows:\n{stderr}" ) return result class lowerCamelCase (_snake_case ): '''simple docstring''' pass def lowercase__ ( __snake_case : List[str] , __snake_case : List[Any]=False ): '''simple docstring''' try: UpperCAmelCase_ : List[Any] = subprocess.check_output(__snake_case , stderr=subprocess.STDOUT ) if return_stdout: if hasattr(__snake_case , 'decode' ): UpperCAmelCase_ : str = output.decode('utf-8' ) return output except subprocess.CalledProcessError as e: raise SubprocessCallException( F"Command `{' '.join(__snake_case )}` failed with the following error:\n\n{e.output.decode()}" ) from e
29
1
import argparse import json import os from pathlib import Path import requests import torch from transformers import JukeboxConfig, JukeboxModel from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = 'https://openaipublic.azureedge.net/jukebox/models/' __UpperCAmelCase = { 'jukebox-1b-lyrics': [ '5b/vqvae.pth.tar', '5b/prior_level_0.pth.tar', '5b/prior_level_1.pth.tar', '1b_lyrics/prior_level_2.pth.tar', ], 'jukebox-5b-lyrics': [ '5b/vqvae.pth.tar', '5b/prior_level_0.pth.tar', '5b/prior_level_1.pth.tar', '5b_lyrics/prior_level_2.pth.tar', ], } def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' if key.endswith('.model.1.bias' ) and len(key.split('.' ) ) > 10: UpperCAmelCase_ : Dict = key.replace('.model.1.bias' , '.conv1d_1.bias' ) elif key.endswith('.model.1.weight' ) and len(key.split('.' ) ) > 10: UpperCAmelCase_ : Dict = key.replace('.model.1.weight' , '.conv1d_1.weight' ) elif key.endswith('.model.3.bias' ) and len(key.split('.' ) ) > 10: UpperCAmelCase_ : Union[str, Any] = key.replace('.model.3.bias' , '.conv1d_2.bias' ) elif key.endswith('.model.3.weight' ) and len(key.split('.' ) ) > 10: UpperCAmelCase_ : Dict = key.replace('.model.3.weight' , '.conv1d_2.weight' ) if "conditioner_blocks.0." in key: UpperCAmelCase_ : List[str] = key.replace('conditioner_blocks.0' , 'conditioner_blocks' ) if "prime_prior" in key: UpperCAmelCase_ : List[str] = key.replace('prime_prior' , 'encoder' ) if ".emb." in key and "total" not in key and "absolute" not in key and "relative" not in key: UpperCAmelCase_ : Optional[int] = key.replace('.emb.' , '.' ) if key.endswith('k' ): # replace vqvae.X.k with vqvae.X.codebook return key.replace('.k' , '.codebook' ) if "y_emb." in key: return key.replace('y_emb.' , 'metadata_embedding.' ) if "x_emb.emb." in key: UpperCAmelCase_ : List[Any] = key.replace('0.x_emb.emb' , 'embed_tokens' ) if "prime_state_ln" in key: return key.replace('prime_state_ln' , 'encoder.final_layer_norm' ) if ".ln" in key: return key.replace('.ln' , '.layer_norm' ) if "_ln" in key: return key.replace('_ln' , '_layer_norm' ) if "prime_state_proj" in key: return key.replace('prime_state_proj' , 'encoder.proj_in' ) if "prime_x_out" in key: return key.replace('prime_x_out' , 'encoder.lm_head' ) if "prior.x_out" in key: return key.replace('x_out' , 'fc_proj_out' ) if "x_emb" in key: return key.replace('x_emb' , 'embed_tokens' ) return key def lowercase__ ( __snake_case : Optional[int] , __snake_case : Any , __snake_case : Dict , __snake_case : Optional[int] ): '''simple docstring''' UpperCAmelCase_ : Tuple = {} import re UpperCAmelCase_ : List[str] = re.compile(R'encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)' ) UpperCAmelCase_ : List[str] = re.compile( R'encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)' ) UpperCAmelCase_ : int = re.compile(R'encoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)' ) UpperCAmelCase_ : Optional[Any] = re.compile(R'decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)' ) UpperCAmelCase_ : Optional[Any] = re.compile( R'decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)' ) UpperCAmelCase_ : Dict = re.compile(R'decoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)' ) UpperCAmelCase_ : Optional[Any] = re.compile(R'conditioner_blocks.(\d*).cond.model.(\d*).(\d).(bias|weight)' ) UpperCAmelCase_ : Tuple = re.compile( R'conditioner_blocks.(\d*).cond.model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)' ) UpperCAmelCase_ : List[Any] = re.compile(R'conditioner_blocks.(\d*).cond.model.(\d*).(bias|weight)' ) for original_key, value in state_dict.items(): # rename vqvae.encoder keys if re_encoder_block_conv_in.fullmatch(__snake_case ): UpperCAmelCase_ : List[str] = re_encoder_block_conv_in.match(__snake_case ) UpperCAmelCase_ : Optional[int] = regex_match.groups() UpperCAmelCase_ : Any = int(groups[2] ) * 2 + int(groups[3] ) UpperCAmelCase_ : Any = F"encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.{groups[-1]}" UpperCAmelCase_ : List[Any] = re_encoder_block_conv_in.sub(__snake_case , __snake_case ) elif re_encoder_block_resnet.fullmatch(__snake_case ): UpperCAmelCase_ : str = re_encoder_block_resnet.match(__snake_case ) UpperCAmelCase_ : Tuple = regex_match.groups() UpperCAmelCase_ : List[str] = int(groups[2] ) * 2 + int(groups[3] ) UpperCAmelCase_ : int = {'1': 1, '3': 2}[groups[-2]] UpperCAmelCase_ : Optional[Any] = F"encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}." UpperCAmelCase_ : Optional[Any] = F"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}" UpperCAmelCase_ : Union[str, Any] = prefix + resnet_block UpperCAmelCase_ : Union[str, Any] = re_encoder_block_resnet.sub(__snake_case , __snake_case ) elif re_encoder_block_proj_out.fullmatch(__snake_case ): UpperCAmelCase_ : str = re_encoder_block_proj_out.match(__snake_case ) UpperCAmelCase_ : str = regex_match.groups() UpperCAmelCase_ : int = F"encoders.{groups[0]}.level_blocks.{groups[1]}.proj_out.{groups[-1]}" UpperCAmelCase_ : List[str] = re_encoder_block_proj_out.sub(__snake_case , __snake_case ) # rename vqvae.decoder keys elif re_decoder_block_conv_out.fullmatch(__snake_case ): UpperCAmelCase_ : List[str] = re_decoder_block_conv_out.match(__snake_case ) UpperCAmelCase_ : Union[str, Any] = regex_match.groups() UpperCAmelCase_ : Union[str, Any] = int(groups[2] ) * 2 + int(groups[3] ) - 2 UpperCAmelCase_ : Tuple = F"decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.{groups[-1]}" UpperCAmelCase_ : int = re_decoder_block_conv_out.sub(__snake_case , __snake_case ) elif re_decoder_block_resnet.fullmatch(__snake_case ): UpperCAmelCase_ : List[Any] = re_decoder_block_resnet.match(__snake_case ) UpperCAmelCase_ : List[Any] = regex_match.groups() UpperCAmelCase_ : List[str] = int(groups[2] ) * 2 + int(groups[3] ) - 2 UpperCAmelCase_ : List[Any] = {'1': 1, '3': 2}[groups[-2]] UpperCAmelCase_ : Dict = F"decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}." UpperCAmelCase_ : Any = F"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}" UpperCAmelCase_ : Any = prefix + resnet_block UpperCAmelCase_ : Tuple = re_decoder_block_resnet.sub(__snake_case , __snake_case ) elif re_decoder_block_proj_in.fullmatch(__snake_case ): UpperCAmelCase_ : Dict = re_decoder_block_proj_in.match(__snake_case ) UpperCAmelCase_ : Tuple = regex_match.groups() UpperCAmelCase_ : Optional[int] = F"decoders.{groups[0]}.level_blocks.{groups[1]}.proj_in.{groups[-1]}" UpperCAmelCase_ : Any = re_decoder_block_proj_in.sub(__snake_case , __snake_case ) # rename prior cond.model to upsampler.upsample_block and resnet elif re_prior_cond_conv_out.fullmatch(__snake_case ): UpperCAmelCase_ : List[str] = re_prior_cond_conv_out.match(__snake_case ) UpperCAmelCase_ : int = regex_match.groups() UpperCAmelCase_ : str = int(groups[1] ) * 2 + int(groups[2] ) - 2 UpperCAmelCase_ : Union[str, Any] = F"conditioner_blocks.upsampler.upsample_block.{block_index}.{groups[-1]}" UpperCAmelCase_ : Dict = re_prior_cond_conv_out.sub(__snake_case , __snake_case ) elif re_prior_cond_resnet.fullmatch(__snake_case ): UpperCAmelCase_ : List[Any] = re_prior_cond_resnet.match(__snake_case ) UpperCAmelCase_ : Dict = regex_match.groups() UpperCAmelCase_ : str = int(groups[1] ) * 2 + int(groups[2] ) - 2 UpperCAmelCase_ : str = {'1': 1, '3': 2}[groups[-2]] UpperCAmelCase_ : Union[str, Any] = F"conditioner_blocks.upsampler.upsample_block.{block_index}." UpperCAmelCase_ : Union[str, Any] = F"resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}" UpperCAmelCase_ : Optional[Any] = prefix + resnet_block UpperCAmelCase_ : Optional[Any] = re_prior_cond_resnet.sub(__snake_case , __snake_case ) elif re_prior_cond_proj_in.fullmatch(__snake_case ): UpperCAmelCase_ : Optional[int] = re_prior_cond_proj_in.match(__snake_case ) UpperCAmelCase_ : Tuple = regex_match.groups() UpperCAmelCase_ : List[str] = F"conditioner_blocks.upsampler.proj_in.{groups[-1]}" UpperCAmelCase_ : Union[str, Any] = re_prior_cond_proj_in.sub(__snake_case , __snake_case ) # keep original key else: UpperCAmelCase_ : Optional[Any] = original_key UpperCAmelCase_ : List[str] = replace_key(__snake_case ) if F"{key_prefix}.{key}" not in model_state_dict or key is None: print(F"failed converting {original_key} to {key}, does not match" ) # handle missmatched shape elif value.shape != model_state_dict[F"{key_prefix}.{key}"].shape: UpperCAmelCase_ : Tuple = model_state_dict[F"{key_prefix}.{key}"] print(F"{original_key}-> {key} : \nshape {val.shape} and { value.shape}, do not match" ) UpperCAmelCase_ : str = original_key UpperCAmelCase_ : str = original_key UpperCAmelCase_ : Tuple = value return new_dict @torch.no_grad() def lowercase__ ( __snake_case : str=None , __snake_case : Optional[int]=None ): '''simple docstring''' for file in MODEL_MAPPING[model_name]: if not os.path.isfile(F"{pytorch_dump_folder_path}/{file.split('/' )[-1]}" ): UpperCAmelCase_ : Optional[Any] = requests.get(F"{PREFIX}{file}" , allow_redirects=__snake_case ) os.makedirs(F"{pytorch_dump_folder_path}/" , exist_ok=__snake_case ) open(F"{pytorch_dump_folder_path}/{file.split('/' )[-1]}" , 'wb' ).write(r.content ) UpperCAmelCase_ : str = MODEL_MAPPING[model_name.split('/' )[-1]] UpperCAmelCase_ : List[str] = JukeboxConfig.from_pretrained(__snake_case ) UpperCAmelCase_ : Optional[int] = JukeboxModel(__snake_case ) UpperCAmelCase_ : Any = [] UpperCAmelCase_ : Any = {} for i, dict_name in enumerate(__snake_case ): UpperCAmelCase_ : Union[str, Any] = torch.load(F"{pytorch_dump_folder_path}/{dict_name.split('/' )[-1]}" )['model'] UpperCAmelCase_ : List[str] = {} for k in old_dic.keys(): if k.endswith('.b' ): UpperCAmelCase_ : Any = old_dic[k] elif k.endswith('.w' ): UpperCAmelCase_ : int = old_dic[k] elif "level_2" not in dict_name and "cond.model." in k: UpperCAmelCase_ : List[Any] = old_dic[k] else: UpperCAmelCase_ : int = old_dic[k] UpperCAmelCase_ : List[Any] = 'vqvae' if i == 0 else F"priors.{3 - i}" UpperCAmelCase_ : str = fix_jukebox_keys(__snake_case , model.state_dict() , __snake_case , __snake_case ) weight_dict.append(__snake_case ) UpperCAmelCase_ : Optional[Any] = weight_dict.pop(0 ) model.vqvae.load_state_dict(__snake_case ) for i in range(len(__snake_case ) ): model.priors[i].load_state_dict(weight_dict[2 - i] ) Path(__snake_case ).mkdir(exist_ok=__snake_case ) with open(F"{pytorch_dump_folder_path}/mapping.json" , 'w' ) as txtfile: json.dump(__snake_case , __snake_case ) print(F"Saving model {model_name} to {pytorch_dump_folder_path}" ) model.save_pretrained(__snake_case ) return weight_dict if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='jukebox-5b-lyrics', type=str, help='Name of the model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default='jukebox-5b-lyrics-converted', type=str, help='Path to the output PyTorch model directory.', ) __UpperCAmelCase = parser.parse_args() convert_openai_checkpoint(args.model_name, args.pytorch_dump_folder_path)
29
import inspect import logging import os import random import shutil import tempfile import unittest import pytest import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset from accelerate import Accelerator from accelerate.test_utils import execute_subprocess_async, require_cuda from accelerate.utils import ProjectConfiguration, set_seed __UpperCAmelCase = logging.getLogger(__name__) def lowercase__ ( __snake_case : List[Any]=2 , __snake_case : Union[str, Any]=3 , __snake_case : Any=16 , __snake_case : int = 10 , __snake_case : int = 2 ): '''simple docstring''' def get_dataset(__snake_case : Optional[Any] ): UpperCAmelCase_ : Optional[Any] = torch.randn(batch_size * n_batches , 1 ) return TensorDataset(__snake_case , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) ) UpperCAmelCase_ : Any = get_dataset(__snake_case ) UpperCAmelCase_ : str = get_dataset(__snake_case ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) UpperCAmelCase_ : int = DataLoader(__snake_case , shuffle=__snake_case , batch_size=__snake_case , num_workers=4 ) return (train_dataloader, valid_dataloader) def lowercase__ ( __snake_case : Optional[int] , __snake_case : str , __snake_case : Optional[int] , __snake_case : List[str] , __snake_case : Any , __snake_case : Tuple=None ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = [] for epoch in range(__snake_case ): # Train quickly model.train() for batch in dataloader: UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = batch UpperCAmelCase_ : List[Any] = model(__snake_case ) UpperCAmelCase_ : int = torch.nn.functional.mse_loss(__snake_case , __snake_case ) accelerator.backward(__snake_case ) optimizer.step() optimizer.zero_grad() rands.append(random.random() ) # Introduce some randomness if scheduler is not None: scheduler.step() return rands class lowerCamelCase (nn.Module ): '''simple docstring''' def __init__( self ) -> Optional[Any]: super().__init__() UpperCAmelCase_ : List[Any] = nn.Parameter(torch.randn(1 ) ) UpperCAmelCase_ : Optional[int] = nn.Parameter(torch.randn(1 ) ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> Optional[Any]: return x * self.a + self.b class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Optional[int] = ProjectConfiguration(total_limit=1 , project_dir=_UpperCamelCase , automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Dict = Accelerator(project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() # Save second state accelerator.save_state() self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[Any] = DummyModel() UpperCAmelCase_ : str = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() # Train baseline UpperCAmelCase_ : Tuple = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial UpperCAmelCase_ : Any = os.path.join(_UpperCamelCase , 'initial' ) accelerator.save_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() UpperCAmelCase_ : Union[str, Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Union[str, Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Any = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : int = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : str = dummy_dataloaders() UpperCAmelCase_ : Optional[Any] = Accelerator() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Tuple = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(_UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[str] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Dict = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything UpperCAmelCase_ : Union[str, Any] = os.path.join(_UpperCamelCase , 'checkpoint' ) accelerator.save_state(_UpperCamelCase ) # Load everything back in and make sure all states work accelerator.load_state(_UpperCamelCase ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Union[str, Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Tuple = DummyModel() UpperCAmelCase_ : Optional[int] = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = dummy_dataloaders() UpperCAmelCase_ : Any = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : str = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() ((UpperCAmelCase_) , (UpperCAmelCase_)) : Optional[int] = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() UpperCAmelCase_ : Optional[Any] = train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : Tuple = model.a.item(), model.b.item() UpperCAmelCase_ : Optional[int] = optimizer.state_dict() # Train partially set_seed(4_2 ) UpperCAmelCase_ : Any = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : str = model.a.item(), model.b.item() UpperCAmelCase_ : List[Any] = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = train(2 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save everything accelerator.save_state() # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_1' ) ) test_rands += train(1 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) ((UpperCAmelCase_) , (UpperCAmelCase_)) : List[Any] = model.a.item(), model.b.item() UpperCAmelCase_ : Dict = optimizer.state_dict() self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) self.assertEqual(_UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Dict: UpperCAmelCase_ : Optional[Any] = torch.tensor([1, 2, 3] ) UpperCAmelCase_ : Any = torch.tensor([2, 3, 4] ) UpperCAmelCase_ : Union[str, Any] = DummyModel() UpperCAmelCase_ : List[str] = torch.optim.Adam(net.parameters() ) UpperCAmelCase_ : Any = Accelerator() with self.assertRaises(_UpperCamelCase ) as ve: accelerator.register_for_checkpointing(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Optional[int] = str(ve.exception ) self.assertTrue('Item at index 0' in message ) self.assertTrue('Item at index 1' in message ) self.assertFalse('Item at index 2' in message ) self.assertFalse('Item at index 3' in message ) def __UpperCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : int = DummyModel() UpperCAmelCase_ : Any = torch.optim.Adam(params=model.parameters() , lr=1E-3 ) UpperCAmelCase_ : Dict = torch.optim.lr_scheduler.StepLR(_UpperCamelCase , step_size=1 , gamma=0.99 ) UpperCAmelCase_ , UpperCAmelCase_ : Tuple = dummy_dataloaders() UpperCAmelCase_ : Tuple = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase ) # Train baseline UpperCAmelCase_ : Tuple = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = accelerator.prepare( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save initial accelerator.save_state() UpperCAmelCase_ : Dict = scheduler.state_dict() train(3 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) self.assertNotEqual(_UpperCamelCase , scheduler.state_dict() ) # Load everything back in and make sure all states work accelerator.load_state(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) self.assertEqual(_UpperCamelCase , scheduler.state_dict() ) def __UpperCAmelCase ( self ) -> Dict: with tempfile.TemporaryDirectory() as tmpdir: set_seed(4_2 ) UpperCAmelCase_ : Optional[int] = DummyModel() UpperCAmelCase_ : Dict = ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase , total_limit=2 ) # Train baseline UpperCAmelCase_ : Optional[int] = Accelerator(project_dir=_UpperCamelCase , project_config=_UpperCamelCase ) UpperCAmelCase_ : str = accelerator.prepare(_UpperCamelCase ) # Save 3 states: for _ in range(1_1 ): accelerator.save_state() self.assertTrue(not os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_9' ) ) ) self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase , 'checkpoints' , 'checkpoint_10' ) ) ) @require_cuda def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : List[str] = ['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )] execute_subprocess_async(_UpperCamelCase , env=os.environ.copy() ) if __name__ == "__main__": __UpperCAmelCase = '/tmp/accelerate/state_checkpointing' __UpperCAmelCase = DummyModel() __UpperCAmelCase = torch.optim.Adam(params=model.parameters(), lr=1E-3) __UpperCAmelCase = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9) __UpperCAmelCase , __UpperCAmelCase = dummy_dataloaders() __UpperCAmelCase = ProjectConfiguration(automatic_checkpoint_naming=True) # Train baseline __UpperCAmelCase = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision='no') if accelerator.process_index == 0: if os.path.exists(savedir): shutil.rmtree(savedir) os.makedirs(savedir) __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare( model, optimizer, train_dataloader, valid_dataloader, scheduler ) __UpperCAmelCase , __UpperCAmelCase = accelerator.prepare(model, optimizer) train(3, model, train_dataloader, optimizer, accelerator, scheduler) # Check that the intial optimizer is loaded on the GPU for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert param_device.type == accelerator.device.type __UpperCAmelCase = model.cpu() accelerator.wait_for_everyone() accelerator.save_state() accelerator.wait_for_everyone() # Check CPU state accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='cpu') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == torch.device('cpu').type ), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}" # Check device state model.to(accelerator.device) accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='on_device') for group in optimizer.param_groups: __UpperCAmelCase = group['params'][0].device break assert ( param_device.type == accelerator.device.type ), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}" # Check error with pytest.raises(TypeError, match='Unsupported optimizer map location passed'): accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='invalid') accelerator.wait_for_everyone() if accelerator.process_index == 0: shutil.rmtree(savedir) accelerator.wait_for_everyone()
29
1
import argparse import torch from transformers import ( EncodecConfig, EncodecFeatureExtractor, EncodecModel, logging, ) # checkpoints downloaded from: # https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th # https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin # https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger('transformers.models.encodec') __UpperCAmelCase = { 'quantizer.vq.layers.*._codebook.inited': 'quantizer.layers.*.codebook.inited', 'quantizer.vq.layers.*._codebook.cluster_size': 'quantizer.layers.*.codebook.cluster_size', 'quantizer.vq.layers.*._codebook.embed': 'quantizer.layers.*.codebook.embed', 'quantizer.vq.layers.*._codebook.embed_avg': 'quantizer.layers.*.codebook.embed_avg', } __UpperCAmelCase = { 'encoder.model.0.conv.conv': 'encoder.layers.0.conv', 'encoder.model.1.block.1.conv.conv': 'encoder.layers.1.block.1.conv', 'encoder.model.1.block.3.conv.conv': 'encoder.layers.1.block.3.conv', 'encoder.model.1.shortcut.conv.conv': 'encoder.layers.1.shortcut.conv', 'encoder.model.3.conv.conv': 'encoder.layers.3.conv', 'encoder.model.4.block.1.conv.conv': 'encoder.layers.4.block.1.conv', 'encoder.model.4.block.3.conv.conv': 'encoder.layers.4.block.3.conv', 'encoder.model.4.shortcut.conv.conv': 'encoder.layers.4.shortcut.conv', 'encoder.model.6.conv.conv': 'encoder.layers.6.conv', 'encoder.model.7.block.1.conv.conv': 'encoder.layers.7.block.1.conv', 'encoder.model.7.block.3.conv.conv': 'encoder.layers.7.block.3.conv', 'encoder.model.7.shortcut.conv.conv': 'encoder.layers.7.shortcut.conv', 'encoder.model.9.conv.conv': 'encoder.layers.9.conv', 'encoder.model.10.block.1.conv.conv': 'encoder.layers.10.block.1.conv', 'encoder.model.10.block.3.conv.conv': 'encoder.layers.10.block.3.conv', 'encoder.model.10.shortcut.conv.conv': 'encoder.layers.10.shortcut.conv', 'encoder.model.12.conv.conv': 'encoder.layers.12.conv', 'encoder.model.13.lstm': 'encoder.layers.13.lstm', 'encoder.model.15.conv.conv': 'encoder.layers.15.conv', } __UpperCAmelCase = { 'encoder.model.0.conv.norm': 'encoder.layers.0.norm', 'encoder.model.1.block.1.conv.norm': 'encoder.layers.1.block.1.norm', 'encoder.model.1.block.3.conv.norm': 'encoder.layers.1.block.3.norm', 'encoder.model.1.shortcut.conv.norm': 'encoder.layers.1.shortcut.norm', 'encoder.model.3.conv.norm': 'encoder.layers.3.norm', 'encoder.model.4.block.1.conv.norm': 'encoder.layers.4.block.1.norm', 'encoder.model.4.block.3.conv.norm': 'encoder.layers.4.block.3.norm', 'encoder.model.4.shortcut.conv.norm': 'encoder.layers.4.shortcut.norm', 'encoder.model.6.conv.norm': 'encoder.layers.6.norm', 'encoder.model.7.block.1.conv.norm': 'encoder.layers.7.block.1.norm', 'encoder.model.7.block.3.conv.norm': 'encoder.layers.7.block.3.norm', 'encoder.model.7.shortcut.conv.norm': 'encoder.layers.7.shortcut.norm', 'encoder.model.9.conv.norm': 'encoder.layers.9.norm', 'encoder.model.10.block.1.conv.norm': 'encoder.layers.10.block.1.norm', 'encoder.model.10.block.3.conv.norm': 'encoder.layers.10.block.3.norm', 'encoder.model.10.shortcut.conv.norm': 'encoder.layers.10.shortcut.norm', 'encoder.model.12.conv.norm': 'encoder.layers.12.norm', 'encoder.model.15.conv.norm': 'encoder.layers.15.norm', } __UpperCAmelCase = { 'decoder.model.0.conv.conv': 'decoder.layers.0.conv', 'decoder.model.1.lstm': 'decoder.layers.1.lstm', 'decoder.model.3.convtr.convtr': 'decoder.layers.3.conv', 'decoder.model.4.block.1.conv.conv': 'decoder.layers.4.block.1.conv', 'decoder.model.4.block.3.conv.conv': 'decoder.layers.4.block.3.conv', 'decoder.model.4.shortcut.conv.conv': 'decoder.layers.4.shortcut.conv', 'decoder.model.6.convtr.convtr': 'decoder.layers.6.conv', 'decoder.model.7.block.1.conv.conv': 'decoder.layers.7.block.1.conv', 'decoder.model.7.block.3.conv.conv': 'decoder.layers.7.block.3.conv', 'decoder.model.7.shortcut.conv.conv': 'decoder.layers.7.shortcut.conv', 'decoder.model.9.convtr.convtr': 'decoder.layers.9.conv', 'decoder.model.10.block.1.conv.conv': 'decoder.layers.10.block.1.conv', 'decoder.model.10.block.3.conv.conv': 'decoder.layers.10.block.3.conv', 'decoder.model.10.shortcut.conv.conv': 'decoder.layers.10.shortcut.conv', 'decoder.model.12.convtr.convtr': 'decoder.layers.12.conv', 'decoder.model.13.block.1.conv.conv': 'decoder.layers.13.block.1.conv', 'decoder.model.13.block.3.conv.conv': 'decoder.layers.13.block.3.conv', 'decoder.model.13.shortcut.conv.conv': 'decoder.layers.13.shortcut.conv', 'decoder.model.15.conv.conv': 'decoder.layers.15.conv', } __UpperCAmelCase = { 'decoder.model.0.conv.norm': 'decoder.layers.0.norm', 'decoder.model.3.convtr.norm': 'decoder.layers.3.norm', 'decoder.model.4.block.1.conv.norm': 'decoder.layers.4.block.1.norm', 'decoder.model.4.block.3.conv.norm': 'decoder.layers.4.block.3.norm', 'decoder.model.4.shortcut.conv.norm': 'decoder.layers.4.shortcut.norm', 'decoder.model.6.convtr.norm': 'decoder.layers.6.norm', 'decoder.model.7.block.1.conv.norm': 'decoder.layers.7.block.1.norm', 'decoder.model.7.block.3.conv.norm': 'decoder.layers.7.block.3.norm', 'decoder.model.7.shortcut.conv.norm': 'decoder.layers.7.shortcut.norm', 'decoder.model.9.convtr.norm': 'decoder.layers.9.norm', 'decoder.model.10.block.1.conv.norm': 'decoder.layers.10.block.1.norm', 'decoder.model.10.block.3.conv.norm': 'decoder.layers.10.block.3.norm', 'decoder.model.10.shortcut.conv.norm': 'decoder.layers.10.shortcut.norm', 'decoder.model.12.convtr.norm': 'decoder.layers.12.norm', 'decoder.model.13.block.1.conv.norm': 'decoder.layers.13.block.1.norm', 'decoder.model.13.block.3.conv.norm': 'decoder.layers.13.block.3.norm', 'decoder.model.13.shortcut.conv.norm': 'decoder.layers.13.shortcut.norm', 'decoder.model.15.conv.norm': 'decoder.layers.15.norm', } __UpperCAmelCase = { **MAPPING_QUANTIZER, **MAPPING_ENCODER, **MAPPING_DECODER, } __UpperCAmelCase = { **MAPPING_QUANTIZER, **MAPPING_ENCODER, **MAPPING_ENCODER_48K, **MAPPING_DECODER, **MAPPING_DECODER_48K, } __UpperCAmelCase = [] __UpperCAmelCase = [] def lowercase__ ( __snake_case : Optional[Any] , __snake_case : Optional[int] , __snake_case : Tuple , __snake_case : Optional[int] , __snake_case : List[Any] ): '''simple docstring''' for attribute in key.split('.' ): UpperCAmelCase_ : Union[str, Any] = getattr(__snake_case , __snake_case ) if weight_type is not None: UpperCAmelCase_ : Optional[Any] = getattr(__snake_case , __snake_case ).shape else: UpperCAmelCase_ : Optional[int] = hf_pointer.shape if hf_shape != value.shape: raise ValueError( F"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be" F" {value.shape} for {full_name}" ) if weight_type == "weight": UpperCAmelCase_ : Dict = value elif weight_type == "weight_g": UpperCAmelCase_ : List[str] = value elif weight_type == "weight_v": UpperCAmelCase_ : List[str] = value elif weight_type == "bias": UpperCAmelCase_ : Optional[Any] = value elif weight_type == "running_mean": UpperCAmelCase_ : str = value elif weight_type == "running_var": UpperCAmelCase_ : Optional[int] = value elif weight_type == "num_batches_tracked": UpperCAmelCase_ : Union[str, Any] = value elif weight_type == "weight_ih_l0": UpperCAmelCase_ : Tuple = value elif weight_type == "weight_hh_l0": UpperCAmelCase_ : Any = value elif weight_type == "bias_ih_l0": UpperCAmelCase_ : List[str] = value elif weight_type == "bias_hh_l0": UpperCAmelCase_ : List[Any] = value elif weight_type == "weight_ih_l1": UpperCAmelCase_ : Union[str, Any] = value elif weight_type == "weight_hh_l1": UpperCAmelCase_ : List[str] = value elif weight_type == "bias_ih_l1": UpperCAmelCase_ : Union[str, Any] = value elif weight_type == "bias_hh_l1": UpperCAmelCase_ : Any = value else: UpperCAmelCase_ : int = value logger.info(F"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}." ) def lowercase__ ( __snake_case : str , __snake_case : str ): '''simple docstring''' for key in ignore_keys: if key.endswith('.*' ): if name.startswith(key[:-1] ): return True elif ".*." in key: UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = key.split('.*.' ) if prefix in name and suffix in name: return True elif key in name: return True return False def lowercase__ ( __snake_case : Dict , __snake_case : Any , __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = [] if model_name == "encodec_24khz" or "encodec_32khz": UpperCAmelCase_ : Optional[int] = MAPPING_24K elif model_name == "encodec_48khz": UpperCAmelCase_ : Union[str, Any] = MAPPING_48K else: raise ValueError(F"Unsupported model: {model_name}" ) for name, value in orig_dict.items(): if should_ignore(__snake_case , __snake_case ): logger.info(F"{name} was ignored" ) continue UpperCAmelCase_ : Any = False for key, mapped_key in MAPPING.items(): if "*" in key: UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = key.split('.*.' ) if prefix in name and suffix in name: UpperCAmelCase_ : str = suffix if key in name: # HACK otherwise .embed gets initialized with .embed_avg too if key.endswith('embed' ) and name.endswith('embed_avg' ): continue UpperCAmelCase_ : Union[str, Any] = True if "*" in mapped_key: UpperCAmelCase_ : str = name.split(__snake_case )[0].split('.' )[-2] UpperCAmelCase_ : str = mapped_key.replace('*' , __snake_case ) if "weight_g" in name: UpperCAmelCase_ : Dict = 'weight_g' elif "weight_v" in name: UpperCAmelCase_ : str = 'weight_v' elif "weight_ih_l0" in name: UpperCAmelCase_ : List[str] = 'weight_ih_l0' elif "weight_hh_l0" in name: UpperCAmelCase_ : Dict = 'weight_hh_l0' elif "bias_ih_l0" in name: UpperCAmelCase_ : Union[str, Any] = 'bias_ih_l0' elif "bias_hh_l0" in name: UpperCAmelCase_ : List[str] = 'bias_hh_l0' elif "weight_ih_l1" in name: UpperCAmelCase_ : Tuple = 'weight_ih_l1' elif "weight_hh_l1" in name: UpperCAmelCase_ : int = 'weight_hh_l1' elif "bias_ih_l1" in name: UpperCAmelCase_ : int = 'bias_ih_l1' elif "bias_hh_l1" in name: UpperCAmelCase_ : List[str] = 'bias_hh_l1' elif "bias" in name: UpperCAmelCase_ : List[Any] = 'bias' elif "weight" in name: UpperCAmelCase_ : List[str] = 'weight' elif "running_mean" in name: UpperCAmelCase_ : Optional[int] = 'running_mean' elif "running_var" in name: UpperCAmelCase_ : Tuple = 'running_var' elif "num_batches_tracked" in name: UpperCAmelCase_ : int = 'num_batches_tracked' else: UpperCAmelCase_ : Any = None set_recursively(__snake_case , __snake_case , __snake_case , __snake_case , __snake_case ) continue if not is_used: unused_weights.append(__snake_case ) logger.warning(F"Unused weights: {unused_weights}" ) @torch.no_grad() def lowercase__ ( __snake_case : Optional[int] , __snake_case : int , __snake_case : int , __snake_case : str=None , __snake_case : Any=None , ): '''simple docstring''' if config_path is not None: UpperCAmelCase_ : Tuple = EncodecConfig.from_pretrained(__snake_case ) else: UpperCAmelCase_ : Optional[Any] = EncodecConfig() if model_name == "encodec_24khz": pass # config is already correct elif model_name == "encodec_32khz": UpperCAmelCase_ : Dict = [8, 5, 4, 4] UpperCAmelCase_ : Dict = [2.2] UpperCAmelCase_ : Union[str, Any] = 64 UpperCAmelCase_ : Tuple = 32_000 UpperCAmelCase_ : List[Any] = 2_048 UpperCAmelCase_ : List[str] = False UpperCAmelCase_ : Tuple = False UpperCAmelCase_ : Union[str, Any] = False elif model_name == "encodec_48khz": UpperCAmelCase_ : Optional[int] = [8, 5, 4, 2] UpperCAmelCase_ : Optional[Any] = [3.0, 6.0, 12.0, 24.0] UpperCAmelCase_ : Optional[int] = 48_000 UpperCAmelCase_ : Optional[Any] = 2 UpperCAmelCase_ : int = False UpperCAmelCase_ : Optional[Any] = 'time_group_norm' UpperCAmelCase_ : Optional[Any] = True UpperCAmelCase_ : Optional[int] = 1.0 UpperCAmelCase_ : Optional[int] = 0.01 else: raise ValueError(F"Unknown model name: {model_name}" ) UpperCAmelCase_ : List[str] = EncodecModel(__snake_case ) UpperCAmelCase_ : List[str] = EncodecFeatureExtractor( feature_size=config.audio_channels , sampling_rate=config.sampling_rate , chunk_length_s=config.chunk_length_s , overlap=config.overlap , ) feature_extractor.save_pretrained(__snake_case ) UpperCAmelCase_ : Dict = torch.load(__snake_case ) if "best_state" in original_checkpoint: # we might have a training state saved, in which case discard the yaml results and just retain the weights UpperCAmelCase_ : List[str] = original_checkpoint['best_state'] recursively_load_weights(__snake_case , __snake_case , __snake_case ) model.save_pretrained(__snake_case ) if repo_id: print('Pushing to the hub...' ) feature_extractor.push_to_hub(__snake_case ) model.push_to_hub(__snake_case ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() parser.add_argument( '--model', default='encodec_24khz', type=str, help='The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.', ) parser.add_argument('--checkpoint_path', required=True, default=None, type=str, help='Path to original checkpoint') parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert') parser.add_argument( '--pytorch_dump_folder_path', required=True, default=None, type=str, help='Path to the output PyTorch model.' ) parser.add_argument( '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.' ) __UpperCAmelCase = parser.parse_args() convert_checkpoint( args.model, args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )
29
import warnings from ...utils import logging from .image_processing_imagegpt import ImageGPTImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , *_UpperCamelCase , **_UpperCamelCase ) -> None: warnings.warn( 'The class ImageGPTFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use ImageGPTImageProcessor instead.' , _UpperCamelCase , ) super().__init__(*_UpperCamelCase , **_UpperCamelCase )
29
1
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) def lowercase__ ( __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : List[Any] = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: UpperCAmelCase_ : Tuple = 192 UpperCAmelCase_ : str = 768 UpperCAmelCase_ : List[Any] = 12 UpperCAmelCase_ : Optional[int] = 3 UpperCAmelCase_ : Optional[Any] = [800, 1_333] UpperCAmelCase_ : Dict = False elif yolos_name == "yolos_s_dWr": UpperCAmelCase_ : Tuple = 330 UpperCAmelCase_ : List[str] = 14 UpperCAmelCase_ : Tuple = 6 UpperCAmelCase_ : List[str] = 1_320 elif "yolos_s" in yolos_name: UpperCAmelCase_ : Any = 384 UpperCAmelCase_ : Union[str, Any] = 1_536 UpperCAmelCase_ : List[str] = 12 UpperCAmelCase_ : Any = 6 elif "yolos_b" in yolos_name: UpperCAmelCase_ : Optional[int] = [800, 1_344] UpperCAmelCase_ : str = 91 UpperCAmelCase_ : Optional[Any] = 'huggingface/label-files' UpperCAmelCase_ : Any = 'coco-detection-id2label.json' UpperCAmelCase_ : Tuple = json.load(open(hf_hub_download(__snake_case , __snake_case , repo_type='dataset' ) , 'r' ) ) UpperCAmelCase_ : Optional[Any] = {int(__snake_case ): v for k, v in idalabel.items()} UpperCAmelCase_ : Optional[Any] = idalabel UpperCAmelCase_ : List[Any] = {v: k for k, v in idalabel.items()} return config def lowercase__ ( __snake_case : dict , __snake_case : YolosConfig , __snake_case : bool = False ): '''simple docstring''' for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) UpperCAmelCase_ : Optional[Any] = state_dict.pop(F"blocks.{i}.attn.qkv.weight" ) UpperCAmelCase_ : Tuple = state_dict.pop(F"blocks.{i}.attn.qkv.bias" ) # next, add query, keys and values (in that order) to the state dict UpperCAmelCase_ : Tuple = in_proj_weight[: config.hidden_size, :] UpperCAmelCase_ : Optional[int] = in_proj_bias[: config.hidden_size] UpperCAmelCase_ : Tuple = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] UpperCAmelCase_ : Optional[Any] = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] UpperCAmelCase_ : List[str] = in_proj_weight[-config.hidden_size :, :] UpperCAmelCase_ : str = in_proj_bias[-config.hidden_size :] def lowercase__ ( __snake_case : str ): '''simple docstring''' if "backbone" in name: UpperCAmelCase_ : List[str] = name.replace('backbone' , 'vit' ) if "cls_token" in name: UpperCAmelCase_ : List[Any] = name.replace('cls_token' , 'embeddings.cls_token' ) if "det_token" in name: UpperCAmelCase_ : Dict = name.replace('det_token' , 'embeddings.detection_tokens' ) if "mid_pos_embed" in name: UpperCAmelCase_ : Optional[int] = name.replace('mid_pos_embed' , 'encoder.mid_position_embeddings' ) if "pos_embed" in name: UpperCAmelCase_ : List[str] = name.replace('pos_embed' , 'embeddings.position_embeddings' ) if "patch_embed.proj" in name: UpperCAmelCase_ : Any = name.replace('patch_embed.proj' , 'embeddings.patch_embeddings.projection' ) if "blocks" in name: UpperCAmelCase_ : List[str] = name.replace('blocks' , 'encoder.layer' ) if "attn.proj" in name: UpperCAmelCase_ : List[str] = name.replace('attn.proj' , 'attention.output.dense' ) if "attn" in name: UpperCAmelCase_ : Dict = name.replace('attn' , 'attention.self' ) if "norm1" in name: UpperCAmelCase_ : List[Any] = name.replace('norm1' , 'layernorm_before' ) if "norm2" in name: UpperCAmelCase_ : List[Any] = name.replace('norm2' , 'layernorm_after' ) if "mlp.fc1" in name: UpperCAmelCase_ : List[Any] = name.replace('mlp.fc1' , 'intermediate.dense' ) if "mlp.fc2" in name: UpperCAmelCase_ : str = name.replace('mlp.fc2' , 'output.dense' ) if "class_embed" in name: UpperCAmelCase_ : Any = name.replace('class_embed' , 'class_labels_classifier' ) if "bbox_embed" in name: UpperCAmelCase_ : Dict = name.replace('bbox_embed' , 'bbox_predictor' ) if "vit.norm" in name: UpperCAmelCase_ : Any = name.replace('vit.norm' , 'vit.layernorm' ) return name def lowercase__ ( __snake_case : dict , __snake_case : YolosForObjectDetection ): '''simple docstring''' for key in orig_state_dict.copy().keys(): UpperCAmelCase_ : List[str] = orig_state_dict.pop(__snake_case ) if "qkv" in key: UpperCAmelCase_ : Any = key.split('.' ) UpperCAmelCase_ : Optional[int] = int(key_split[2] ) UpperCAmelCase_ : int = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: UpperCAmelCase_ : str = val[:dim, :] UpperCAmelCase_ : str = val[ dim : dim * 2, : ] UpperCAmelCase_ : int = val[-dim:, :] else: UpperCAmelCase_ : List[Any] = val[:dim] UpperCAmelCase_ : Optional[Any] = val[dim : dim * 2] UpperCAmelCase_ : List[str] = val[-dim:] else: UpperCAmelCase_ : List[str] = val return orig_state_dict def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = 'http://images.cocodataset.org/val2017/000000039769.jpg' UpperCAmelCase_ : Any = Image.open(requests.get(__snake_case , stream=__snake_case ).raw ) return im @torch.no_grad() def lowercase__ ( __snake_case : str , __snake_case : str , __snake_case : str , __snake_case : bool = False ): '''simple docstring''' UpperCAmelCase_ : str = get_yolos_config(__snake_case ) # load original state_dict UpperCAmelCase_ : Tuple = torch.load(__snake_case , map_location='cpu' )['model'] # load 🤗 model UpperCAmelCase_ : Optional[Any] = YolosForObjectDetection(__snake_case ) model.eval() UpperCAmelCase_ : List[str] = convert_state_dict(__snake_case , __snake_case ) model.load_state_dict(__snake_case ) # Check outputs on an image, prepared by YolosImageProcessor UpperCAmelCase_ : int = 800 if yolos_name != 'yolos_ti' else 512 UpperCAmelCase_ : str = YolosImageProcessor(format='coco_detection' , size=__snake_case ) UpperCAmelCase_ : Optional[Any] = image_processor(images=prepare_img() , return_tensors='pt' ) UpperCAmelCase_ : Optional[Any] = model(**__snake_case ) UpperCAmelCase_ , UpperCAmelCase_ : int = outputs.logits, outputs.pred_boxes UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = None, None if yolos_name == "yolos_ti": UpperCAmelCase_ : Optional[Any] = torch.tensor( [[-39.5022, -11.9820, -17.6888], [-29.9574, -9.9769, -17.7691], [-42.3281, -20.7200, -30.6294]] ) UpperCAmelCase_ : Union[str, Any] = torch.tensor( [[0.4021, 0.0836, 0.7979], [0.0184, 0.2609, 0.0364], [0.1781, 0.2004, 0.2095]] ) elif yolos_name == "yolos_s_200_pre": UpperCAmelCase_ : Any = torch.tensor( [[-24.0248, -10.3024, -14.8290], [-42.0392, -16.8200, -27.4334], [-27.2743, -11.8154, -18.7148]] ) UpperCAmelCase_ : Dict = torch.tensor( [[0.2559, 0.5455, 0.4706], [0.2989, 0.7279, 0.1875], [0.7732, 0.4017, 0.4462]] ) elif yolos_name == "yolos_s_300_pre": UpperCAmelCase_ : str = torch.tensor( [[-36.2220, -14.4385, -23.5457], [-35.6970, -14.7583, -21.3935], [-31.5939, -13.6042, -16.8049]] ) UpperCAmelCase_ : Optional[Any] = torch.tensor( [[0.7614, 0.2316, 0.4728], [0.7168, 0.4495, 0.3855], [0.4996, 0.1466, 0.9996]] ) elif yolos_name == "yolos_s_dWr": UpperCAmelCase_ : int = torch.tensor( [[-42.8668, -24.1049, -41.1690], [-34.7456, -14.1274, -24.9194], [-33.7898, -12.1946, -25.6495]] ) UpperCAmelCase_ : Union[str, Any] = torch.tensor( [[0.5587, 0.2773, 0.0605], [0.5004, 0.3014, 0.9994], [0.4999, 0.1548, 0.9994]] ) elif yolos_name == "yolos_base": UpperCAmelCase_ : Optional[int] = torch.tensor( [[-40.6064, -24.3084, -32.6447], [-55.1990, -30.7719, -35.5877], [-51.4311, -33.3507, -35.6462]] ) UpperCAmelCase_ : str = torch.tensor( [[0.5555, 0.2794, 0.0655], [0.9049, 0.2664, 0.1894], [0.9183, 0.1984, 0.1635]] ) else: raise ValueError(F"Unknown yolos_name: {yolos_name}" ) assert torch.allclose(logits[0, :3, :3] , __snake_case , atol=1E-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , __snake_case , atol=1E-4 ) Path(__snake_case ).mkdir(exist_ok=__snake_case ) print(F"Saving model {yolos_name} to {pytorch_dump_folder_path}" ) model.save_pretrained(__snake_case ) print(F"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(__snake_case ) if push_to_hub: UpperCAmelCase_ : List[str] = { 'yolos_ti': 'yolos-tiny', 'yolos_s_200_pre': 'yolos-small', 'yolos_s_300_pre': 'yolos-small-300', 'yolos_s_dWr': 'yolos-small-dwr', 'yolos_base': 'yolos-base', } print('Pushing to the hub...' ) UpperCAmelCase_ : str = model_mapping[yolos_name] image_processor.push_to_hub(__snake_case , organization='hustvl' ) model.push_to_hub(__snake_case , organization='hustvl' ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--yolos_name', default='yolos_s_200_pre', type=str, help=( 'Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',' ' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.' ), ) parser.add_argument( '--checkpoint_path', default=None, type=str, help='Path to the original state dict (.pth file).' ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) __UpperCAmelCase = parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
29
def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if not head: return True # split the list to two parts UpperCAmelCase_ , UpperCAmelCase_ : Any = head.next, head while fast and fast.next: UpperCAmelCase_ : str = fast.next.next UpperCAmelCase_ : Union[str, Any] = slow.next UpperCAmelCase_ : int = slow.next UpperCAmelCase_ : List[Any] = None # Don't forget here! But forget still works! # reverse the second part UpperCAmelCase_ : Tuple = None while second: UpperCAmelCase_ : int = second.next UpperCAmelCase_ : Any = node UpperCAmelCase_ : Optional[Any] = second UpperCAmelCase_ : Tuple = nxt # compare two parts # second part has the same or one less node while node: if node.val != head.val: return False UpperCAmelCase_ : Optional[Any] = node.next UpperCAmelCase_ : Dict = head.next return True def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' if not head or not head.next: return True # 1. Get the midpoint (slow) UpperCAmelCase_ : Any = head while fast and fast.next: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = fast.next.next, slow.next # 2. Push the second half into the stack UpperCAmelCase_ : List[str] = [slow.val] while slow.next: UpperCAmelCase_ : List[str] = slow.next stack.append(slow.val ) # 3. Comparison while stack: if stack.pop() != cur.val: return False UpperCAmelCase_ : int = cur.next return True def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if not head or not head.next: return True UpperCAmelCase_ : Tuple = {} UpperCAmelCase_ : int = 0 while head: if head.val in d: d[head.val].append(__snake_case ) else: UpperCAmelCase_ : List[Any] = [pos] UpperCAmelCase_ : Any = head.next pos += 1 UpperCAmelCase_ : Dict = pos - 1 UpperCAmelCase_ : Optional[int] = 0 for v in d.values(): if len(__snake_case ) % 2 != 0: middle += 1 else: UpperCAmelCase_ : int = 0 for i in range(0 , len(__snake_case ) ): if v[i] + v[len(__snake_case ) - 1 - step] != checksum: return False step += 1 if middle > 1: return False return True
29
1
def lowercase__ ( __snake_case : int = 4_000_000 ): '''simple docstring''' UpperCAmelCase_ : int = [0, 1] UpperCAmelCase_ : List[str] = 0 while fib[i] <= n: fib.append(fib[i] + fib[i + 1] ) if fib[i + 2] > n: break i += 1 UpperCAmelCase_ : str = 0 for j in range(len(__snake_case ) - 1 ): if fib[j] % 2 == 0: total += fib[j] return total if __name__ == "__main__": print(F'{solution() = }')
29
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = {'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST', 'ViTMSNModel', 'ViTMSNForImageClassification', 'ViTMSNPreTrainedModel', ] if TYPE_CHECKING: from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_msn import ( VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMSNForImageClassification, ViTMSNModel, ViTMSNPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
1
from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'RWKV/rwkv-4-169m-pile': 'https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json', 'RWKV/rwkv-4-430m-pile': 'https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json', 'RWKV/rwkv-4-1b5-pile': 'https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json', 'RWKV/rwkv-4-3b-pile': 'https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json', 'RWKV/rwkv-4-7b-pile': 'https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json', 'RWKV/rwkv-4-14b-pile': 'https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json', 'RWKV/rwkv-raven-1b5': 'https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json', 'RWKV/rwkv-raven-3b': 'https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json', 'RWKV/rwkv-raven-7b': 'https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json', 'RWKV/rwkv-raven-14b': 'https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json', } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Optional[int] = '''rwkv''' _snake_case : str = {'''max_position_embeddings''': '''context_length'''} def __init__( self , _UpperCamelCase=5_0_2_7_7 , _UpperCamelCase=1_0_2_4 , _UpperCamelCase=4_0_9_6 , _UpperCamelCase=3_2 , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase=1E-5 , _UpperCamelCase=0 , _UpperCamelCase=0 , _UpperCamelCase=6 , _UpperCamelCase=False , _UpperCamelCase=True , **_UpperCamelCase , ) -> Tuple: UpperCAmelCase_ : Union[str, Any] = vocab_size UpperCAmelCase_ : int = context_length UpperCAmelCase_ : List[str] = hidden_size UpperCAmelCase_ : Union[str, Any] = num_hidden_layers UpperCAmelCase_ : int = attention_hidden_size if attention_hidden_size is not None else hidden_size UpperCAmelCase_ : List[str] = intermediate_size if intermediate_size is not None else 4 * hidden_size UpperCAmelCase_ : Tuple = layer_norm_epsilon UpperCAmelCase_ : List[Any] = rescale_every UpperCAmelCase_ : Any = use_cache UpperCAmelCase_ : Tuple = bos_token_id UpperCAmelCase_ : Optional[Any] = eos_token_id super().__init__( tie_word_embeddings=_UpperCamelCase , bos_token_id=_UpperCamelCase , eos_token_id=_UpperCamelCase , **_UpperCamelCase )
29
__UpperCAmelCase = { 'Pillow': 'Pillow<10.0.0', 'accelerate': 'accelerate>=0.20.3', 'av': 'av==9.2.0', 'beautifulsoup4': 'beautifulsoup4', 'black': 'black~=23.1', 'codecarbon': 'codecarbon==1.2.0', 'cookiecutter': 'cookiecutter==1.7.3', 'dataclasses': 'dataclasses', 'datasets': 'datasets!=2.5.0', 'decord': 'decord==0.6.0', 'deepspeed': 'deepspeed>=0.9.3', 'diffusers': 'diffusers', 'dill': 'dill<0.3.5', 'evaluate': 'evaluate>=0.2.0', 'fairscale': 'fairscale>0.3', 'faiss-cpu': 'faiss-cpu', 'fastapi': 'fastapi', 'filelock': 'filelock', 'flax': 'flax>=0.4.1,<=0.7.0', 'ftfy': 'ftfy', 'fugashi': 'fugashi>=1.0', 'GitPython': 'GitPython<3.1.19', 'hf-doc-builder': 'hf-doc-builder>=0.3.0', 'huggingface-hub': 'huggingface-hub>=0.14.1,<1.0', 'importlib_metadata': 'importlib_metadata', 'ipadic': 'ipadic>=1.0.0,<2.0', 'isort': 'isort>=5.5.4', 'jax': 'jax>=0.2.8,!=0.3.2,<=0.4.13', 'jaxlib': 'jaxlib>=0.1.65,<=0.4.13', 'jieba': 'jieba', 'kenlm': 'kenlm', 'keras-nlp': 'keras-nlp>=0.3.1', 'librosa': 'librosa', 'nltk': 'nltk', 'natten': 'natten>=0.14.6', 'numpy': 'numpy>=1.17', 'onnxconverter-common': 'onnxconverter-common', 'onnxruntime-tools': 'onnxruntime-tools>=1.4.2', 'onnxruntime': 'onnxruntime>=1.4.0', 'opencv-python': 'opencv-python', 'optuna': 'optuna', 'optax': 'optax>=0.0.8,<=0.1.4', 'packaging': 'packaging>=20.0', 'parameterized': 'parameterized', 'phonemizer': 'phonemizer', 'protobuf': 'protobuf', 'psutil': 'psutil', 'pyyaml': 'pyyaml>=5.1', 'pydantic': 'pydantic<2', 'pytest': 'pytest>=7.2.0', 'pytest-timeout': 'pytest-timeout', 'pytest-xdist': 'pytest-xdist', 'python': 'python>=3.8.0', 'ray[tune]': 'ray[tune]', 'regex': 'regex!=2019.12.17', 'requests': 'requests', 'rhoknp': 'rhoknp>=1.1.0,<1.3.1', 'rjieba': 'rjieba', 'rouge-score': 'rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1', 'ruff': 'ruff>=0.0.241,<=0.0.259', 'sacrebleu': 'sacrebleu>=1.4.12,<2.0.0', 'sacremoses': 'sacremoses', 'safetensors': 'safetensors>=0.3.1', 'sagemaker': 'sagemaker>=2.31.0', 'scikit-learn': 'scikit-learn', 'sentencepiece': 'sentencepiece>=0.1.91,!=0.1.92', 'sigopt': 'sigopt', 'starlette': 'starlette', 'sudachipy': 'sudachipy>=0.6.6', 'sudachidict_core': 'sudachidict_core>=20220729', 'tensorflow-cpu': 'tensorflow-cpu>=2.6,<2.14', 'tensorflow': 'tensorflow>=2.6,<2.14', 'tensorflow-text': 'tensorflow-text<2.14', 'tf2onnx': 'tf2onnx', 'timeout-decorator': 'timeout-decorator', 'timm': 'timm', 'tokenizers': 'tokenizers>=0.11.1,!=0.11.3,<0.14', 'torch': 'torch>=1.9,!=1.12.0', 'torchaudio': 'torchaudio', 'torchvision': 'torchvision', 'pyctcdecode': 'pyctcdecode>=0.4.0', 'tqdm': 'tqdm>=4.27', 'unidic': 'unidic>=1.0.2', 'unidic_lite': 'unidic_lite>=1.0.7', 'urllib3': 'urllib3<2.0.0', 'uvicorn': 'uvicorn', }
29
1
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = '\n Examples:\n ```py\n >>> from PIL import Image\n >>> import torch\n >>> from diffusers import DiffusionPipeline\n >>> from diffusers.utils import export_to_gif, load_image\n\n >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")\n\n >>> repo = "openai/shap-e-img2img"\n >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n >>> pipe = pipe.to(device)\n\n >>> guidance_scale = 3.0\n >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"\n >>> image = load_image(image_url).convert("RGB")\n\n >>> images = pipe(\n ... image,\n ... guidance_scale=guidance_scale,\n ... num_inference_steps=64,\n ... frame_size=256,\n ... ).images\n\n >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")\n ```\n' @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Union[PIL.Image.Image, np.ndarray] class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Any: super().__init__() self.register_modules( prior=_UpperCamelCase , image_encoder=_UpperCamelCase , image_processor=_UpperCamelCase , scheduler=_UpperCamelCase , renderer=_UpperCamelCase , ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> List[Any]: if latents is None: UpperCAmelCase_ : str = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) else: if latents.shape != shape: raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}" ) UpperCAmelCase_ : Tuple = latents.to(_UpperCamelCase ) UpperCAmelCase_ : Tuple = latents * scheduler.init_noise_sigma return latents def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Union[str, Any]: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) UpperCAmelCase_ : int = torch.device(f"cuda:{gpu_id}" ) UpperCAmelCase_ : int = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_UpperCamelCase , _UpperCamelCase ) @property def __UpperCAmelCase ( self ) -> int: if self.device != torch.device('meta' ) or not hasattr(self.image_encoder , '_hf_hook' ): return self.device for module in self.image_encoder.modules(): if ( hasattr(_UpperCamelCase , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> str: if isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , torch.Tensor ): UpperCAmelCase_ : int = torch.cat(_UpperCamelCase , axis=0 ) if image[0].ndim == 4 else torch.stack(_UpperCamelCase , axis=0 ) if not isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : Optional[int] = self.image_processor(_UpperCamelCase , return_tensors='pt' ).pixel_values[0].unsqueeze(0 ) UpperCAmelCase_ : Tuple = image.to(dtype=self.image_encoder.dtype , device=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.image_encoder(_UpperCamelCase )['last_hidden_state'] UpperCAmelCase_ : Union[str, Any] = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 UpperCAmelCase_ : List[str] = image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) if do_classifier_free_guidance: UpperCAmelCase_ : Dict = torch.zeros_like(_UpperCamelCase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes UpperCAmelCase_ : Optional[int] = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(_UpperCamelCase ) def __call__( self , _UpperCamelCase , _UpperCamelCase = 1 , _UpperCamelCase = 2_5 , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = 4.0 , _UpperCamelCase = 6_4 , _UpperCamelCase = "pil" , _UpperCamelCase = True , ) -> Union[str, Any]: if isinstance(_UpperCamelCase , PIL.Image.Image ): UpperCAmelCase_ : Tuple = 1 elif isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : str = image.shape[0] elif isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): UpperCAmelCase_ : Optional[int] = len(_UpperCamelCase ) else: raise ValueError( f"`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : Tuple = self._execution_device UpperCAmelCase_ : str = batch_size * num_images_per_prompt UpperCAmelCase_ : str = guidance_scale > 1.0 UpperCAmelCase_ : str = self._encode_image(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # prior self.scheduler.set_timesteps(_UpperCamelCase , device=_UpperCamelCase ) UpperCAmelCase_ : int = self.scheduler.timesteps UpperCAmelCase_ : int = self.prior.config.num_embeddings UpperCAmelCase_ : Any = self.prior.config.embedding_dim UpperCAmelCase_ : List[str] = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim UpperCAmelCase_ : List[Any] = latents.reshape(latents.shape[0] , _UpperCamelCase , _UpperCamelCase ) for i, t in enumerate(self.progress_bar(_UpperCamelCase ) ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : Tuple = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : Optional[Any] = self.scheduler.scale_model_input(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : int = self.prior( _UpperCamelCase , timestep=_UpperCamelCase , proj_embedding=_UpperCamelCase , ).predicted_image_embedding # remove the variance UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: UpperCAmelCase_ , UpperCAmelCase_ : str = noise_pred.chunk(2 ) UpperCAmelCase_ : List[Any] = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) UpperCAmelCase_ : List[str] = self.scheduler.step( _UpperCamelCase , timestep=_UpperCamelCase , sample=_UpperCamelCase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = [] for i, latent in enumerate(_UpperCamelCase ): print() UpperCAmelCase_ : List[str] = self.renderer.decode( latent[None, :] , _UpperCamelCase , size=_UpperCamelCase , ray_batch_size=4_0_9_6 , n_coarse_samples=6_4 , n_fine_samples=1_2_8 , ) images.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = torch.stack(_UpperCamelCase ) if output_type not in ["np", "pil"]: raise ValueError(f"Only the output types `pil` and `np` are supported not output_type={output_type}" ) UpperCAmelCase_ : Dict = images.cpu().numpy() if output_type == "pil": UpperCAmelCase_ : List[str] = [self.numpy_to_pil(_UpperCamelCase ) for image in images] # Offload last model to CPU if hasattr(self , 'final_offload_hook' ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=_UpperCamelCase )
29
from dataclasses import dataclass from typing import Dict, Optional, Tuple, Union import torch import torch.nn as nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, apply_forward_hook from .attention_processor import AttentionProcessor, AttnProcessor from .modeling_utils import ModelMixin from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : "DiagonalGaussianDistribution" class lowerCamelCase (_snake_case , _snake_case ): '''simple docstring''' _snake_case : Optional[int] = True @register_to_config def __init__( self , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = ("DownEncoderBlock2D",) , _UpperCamelCase = ("UpDecoderBlock2D",) , _UpperCamelCase = (6_4,) , _UpperCamelCase = 1 , _UpperCamelCase = "silu" , _UpperCamelCase = 4 , _UpperCamelCase = 3_2 , _UpperCamelCase = 3_2 , _UpperCamelCase = 0.1_82_15 , ) -> List[Any]: super().__init__() # pass init params to Encoder UpperCAmelCase_ : List[str] = Encoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , down_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , act_fn=_UpperCamelCase , norm_num_groups=_UpperCamelCase , double_z=_UpperCamelCase , ) # pass init params to Decoder UpperCAmelCase_ : Dict = Decoder( in_channels=_UpperCamelCase , out_channels=_UpperCamelCase , up_block_types=_UpperCamelCase , block_out_channels=_UpperCamelCase , layers_per_block=_UpperCamelCase , norm_num_groups=_UpperCamelCase , act_fn=_UpperCamelCase , ) UpperCAmelCase_ : Any = nn.Convad(2 * latent_channels , 2 * latent_channels , 1 ) UpperCAmelCase_ : List[Any] = nn.Convad(_UpperCamelCase , _UpperCamelCase , 1 ) UpperCAmelCase_ : Any = False UpperCAmelCase_ : int = False # only relevant if vae tiling is enabled UpperCAmelCase_ : Optional[int] = self.config.sample_size UpperCAmelCase_ : int = ( self.config.sample_size[0] if isinstance(self.config.sample_size , (list, tuple) ) else self.config.sample_size ) UpperCAmelCase_ : Union[str, Any] = int(sample_size / (2 ** (len(self.config.block_out_channels ) - 1)) ) UpperCAmelCase_ : Optional[Any] = 0.25 def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=False ) -> List[str]: if isinstance(_UpperCamelCase , (Encoder, Decoder) ): UpperCAmelCase_ : Union[str, Any] = value def __UpperCAmelCase ( self , _UpperCamelCase = True ) -> int: UpperCAmelCase_ : Tuple = use_tiling def __UpperCAmelCase ( self ) -> Dict: self.enable_tiling(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: UpperCAmelCase_ : str = True def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Optional[int] = False @property # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors def __UpperCAmelCase ( self ) -> Dict[str, AttentionProcessor]: UpperCAmelCase_ : Optional[int] = {} def fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): UpperCAmelCase_ : Optional[int] = module.processor for sub_name, child in module.named_children(): fn_recursive_add_processors(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) return processors for name, module in self.named_children(): fn_recursive_add_processors(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) return processors def __UpperCAmelCase ( self , _UpperCamelCase ) -> List[Any]: UpperCAmelCase_ : Union[str, Any] = len(self.attn_processors.keys() ) if isinstance(_UpperCamelCase , _UpperCamelCase ) and len(_UpperCamelCase ) != count: raise ValueError( f"A dict of processors was passed, but the number of processors {len(_UpperCamelCase )} does not match the" f" number of attention layers: {count}. Please make sure to pass {count} processor classes." ) def fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): if hasattr(_UpperCamelCase , 'set_processor' ): if not isinstance(_UpperCamelCase , _UpperCamelCase ): module.set_processor(_UpperCamelCase ) else: module.set_processor(processor.pop(f"{name}.processor" ) ) for sub_name, child in module.named_children(): fn_recursive_attn_processor(f"{name}.{sub_name}" , _UpperCamelCase , _UpperCamelCase ) for name, module in self.named_children(): fn_recursive_attn_processor(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Union[str, Any]: self.set_attn_processor(AttnProcessor() ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size): return self.tiled_encode(_UpperCamelCase , return_dict=_UpperCamelCase ) if self.use_slicing and x.shape[0] > 1: UpperCAmelCase_ : Union[str, Any] = [self.encoder(_UpperCamelCase ) for x_slice in x.split(1 )] UpperCAmelCase_ : Tuple = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : List[Any] = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size): return self.tiled_decode(_UpperCamelCase , return_dict=_UpperCamelCase ) UpperCAmelCase_ : str = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.decoder(_UpperCamelCase ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) @apply_forward_hook def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_slicing and z.shape[0] > 1: UpperCAmelCase_ : List[str] = [self._decode(_UpperCamelCase ).sample for z_slice in z.split(1 )] UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase ) else: UpperCAmelCase_ : Any = self._decode(_UpperCamelCase ).sample if not return_dict: return (decoded,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : Tuple = min(a.shape[2] , b.shape[2] , _UpperCamelCase ) for y in range(_UpperCamelCase ): UpperCAmelCase_ : str = a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: UpperCAmelCase_ : Tuple = min(a.shape[3] , b.shape[3] , _UpperCamelCase ) for x in range(_UpperCamelCase ): UpperCAmelCase_ : int = a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent) return b def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> AutoencoderKLOutput: UpperCAmelCase_ : Any = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Tuple = int(self.tile_latent_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Optional[int] = self.tile_latent_min_size - blend_extent # Split the image into 512x512 tiles and encode them separately. UpperCAmelCase_ : List[str] = [] for i in range(0 , x.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : Any = [] for j in range(0 , x.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : Any = x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size] UpperCAmelCase_ : Dict = self.encoder(_UpperCamelCase ) UpperCAmelCase_ : List[str] = self.quant_conv(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : str = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Dict = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : List[str] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Union[str, Any] = torch.cat(_UpperCamelCase , dim=2 ) UpperCAmelCase_ : List[Any] = DiagonalGaussianDistribution(_UpperCamelCase ) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = True ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : str = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor) ) UpperCAmelCase_ : Dict = int(self.tile_sample_min_size * self.tile_overlap_factor ) UpperCAmelCase_ : Dict = self.tile_sample_min_size - blend_extent # Split z into overlapping 64x64 tiles and decode them separately. # The tiles have an overlap to avoid seams between tiles. UpperCAmelCase_ : Union[str, Any] = [] for i in range(0 , z.shape[2] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = [] for j in range(0 , z.shape[3] , _UpperCamelCase ): UpperCAmelCase_ : List[str] = z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size] UpperCAmelCase_ : Optional[Any] = self.post_quant_conv(_UpperCamelCase ) UpperCAmelCase_ : Tuple = self.decoder(_UpperCamelCase ) row.append(_UpperCamelCase ) rows.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = [] for i, row in enumerate(_UpperCamelCase ): UpperCAmelCase_ : List[Any] = [] for j, tile in enumerate(_UpperCamelCase ): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: UpperCAmelCase_ : Union[str, Any] = self.blend_v(rows[i - 1][j] , _UpperCamelCase , _UpperCamelCase ) if j > 0: UpperCAmelCase_ : Optional[Any] = self.blend_h(row[j - 1] , _UpperCamelCase , _UpperCamelCase ) result_row.append(tile[:, :, :row_limit, :row_limit] ) result_rows.append(torch.cat(_UpperCamelCase , dim=3 ) ) UpperCAmelCase_ : Dict = torch.cat(_UpperCamelCase , dim=2 ) if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = False , _UpperCamelCase = True , _UpperCamelCase = None , ) -> Union[DecoderOutput, torch.FloatTensor]: UpperCAmelCase_ : Optional[Any] = sample UpperCAmelCase_ : Union[str, Any] = self.encode(_UpperCamelCase ).latent_dist if sample_posterior: UpperCAmelCase_ : str = posterior.sample(generator=_UpperCamelCase ) else: UpperCAmelCase_ : int = posterior.mode() UpperCAmelCase_ : Dict = self.decode(_UpperCamelCase ).sample if not return_dict: return (dec,) return DecoderOutput(sample=_UpperCamelCase )
29
1
import json import os import unittest from transformers import DebertaTokenizer, DebertaTokenizerFast from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES from transformers.testing_utils import slow from ...test_tokenization_common import TokenizerTesterMixin class lowerCamelCase (_snake_case , unittest.TestCase ): '''simple docstring''' _snake_case : Dict = DebertaTokenizer _snake_case : str = True _snake_case : str = DebertaTokenizerFast def __UpperCAmelCase ( self ) -> Optional[Any]: super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt UpperCAmelCase_ : int = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', '\u0120', '\u0120l', '\u0120n', '\u0120lo', '\u0120low', 'er', '\u0120lowest', '\u0120newer', '\u0120wider', '[UNK]', ] UpperCAmelCase_ : Optional[Any] = dict(zip(_UpperCamelCase , range(len(_UpperCamelCase ) ) ) ) UpperCAmelCase_ : str = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', ''] UpperCAmelCase_ : int = {'unk_token': '[UNK]'} UpperCAmelCase_ : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) UpperCAmelCase_ : List[str] = 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 __UpperCAmelCase ( self , **_UpperCamelCase ) -> Optional[int]: kwargs.update(self.special_tokens_map ) return self.tokenizer_class.from_pretrained(self.tmpdirname , **_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase ) -> int: UpperCAmelCase_ : Tuple = 'lower newer' UpperCAmelCase_ : str = 'lower newer' return input_text, output_text def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Union[str, Any] = self.get_tokenizer() UpperCAmelCase_ : List[str] = 'lower newer' UpperCAmelCase_ : Any = ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er'] UpperCAmelCase_ : Any = tokenizer.tokenize(_UpperCamelCase ) self.assertListEqual(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : Any = tokens + [tokenizer.unk_token] UpperCAmelCase_ : Tuple = [0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9] self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase ) , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Tuple = self.get_tokenizer() UpperCAmelCase_ : List[str] = tokenizer('Hello' , 'World' ) UpperCAmelCase_ : List[str] = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1] self.assertListEqual(tokd['token_type_ids'] , _UpperCamelCase ) @slow def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Union[str, Any] = self.tokenizer_class.from_pretrained('microsoft/deberta-base' ) UpperCAmelCase_ : Dict = tokenizer.encode('sequence builders' , add_special_tokens=_UpperCamelCase ) UpperCAmelCase_ : int = tokenizer.encode('multi-sequence build' , add_special_tokens=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = tokenizer.encode( 'sequence builders' , add_special_tokens=_UpperCamelCase , add_prefix_space=_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = tokenizer.encode( 'sequence builders' , 'multi-sequence build' , add_special_tokens=_UpperCamelCase , add_prefix_space=_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(_UpperCamelCase ) UpperCAmelCase_ : Tuple = tokenizer.build_inputs_with_special_tokens(_UpperCamelCase , _UpperCamelCase ) assert encoded_sentence == encoded_text_from_decode assert encoded_pair == encoded_pair_from_decode @slow def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : List[str] = [self.tokenizer_class] if self.test_rust_tokenizer: tokenizer_classes.append(self.rust_tokenizer_class ) for tokenizer_class in tokenizer_classes: UpperCAmelCase_ : Any = tokenizer_class.from_pretrained('microsoft/deberta-base' ) UpperCAmelCase_ : int = [ 'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations', 'ALBERT incorporates two parameter reduction techniques', 'The first one is a factorized embedding parameterization. By decomposing the large vocabulary' ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of' ' vocabulary embedding.', ] UpperCAmelCase_ : str = tokenizer(_UpperCamelCase , padding=_UpperCamelCase ) UpperCAmelCase_ : str = [tokenizer.decode(_UpperCamelCase , skip_special_tokens=_UpperCamelCase ) for seq in encoding['input_ids']] # fmt: off UpperCAmelCase_ : Any = { 'input_ids': [ [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 3_5, 8_3, 2_5_1_9_1, 1_6_3, 1_8_8_5_4, 1_3, 1_2_1_5_6, 1_2, 1_6_1_0_1, 2_5_3_7_6, 1_3_8_0_7, 9, 2_2_2_0_5, 2_7_8_9_3, 1_6_3_5, 2, 0, 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, 2_1_1_8, 1_1_1_2_6, 5_6_5, 2_4_5_3_6, 8_0, 4_3_7_9_7, 4_8_7_8, 7_3_7_3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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_3_3, 7_8, 6_5, 1_6, 1_0, 3_7_2_4, 1_5_3_8, 3_3_1_8_3, 1_1_3_0_3, 4_3_7_9_7, 1_9_3_8, 4, 8_7_0, 2_4_1_6_5, 2_9_1_0_5, 5, 7_3_9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 3_6_1_7_3, 8_8, 8_0, 6_5_0, 7_8_2_1, 4_5_9_4_0, 6, 5_2, 2_5_5_9, 5, 1_8_3_6, 9, 5, 7_3_9_7, 1_3_1_7_1, 3_1, 5, 1_8_3_6, 9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 4, 2] ], 'token_type_ids': [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] ] } # fmt: on UpperCAmelCase_ : List[Any] = [ 'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations', 'ALBERT incorporates two parameter reduction techniques', 'The first one is a factorized embedding parameterization. By decomposing the large vocabulary' ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of' ' vocabulary embedding.', ] self.assertDictEqual(encoding.data , _UpperCamelCase ) for expected, decoded in zip(_UpperCamelCase , _UpperCamelCase ): self.assertEqual(_UpperCamelCase , _UpperCamelCase )
29
def lowercase__ ( __snake_case : int , __snake_case : int ): '''simple docstring''' if a < 0 or b < 0: raise ValueError('the value of both inputs must be positive' ) UpperCAmelCase_ : Tuple = str(bin(__snake_case ) )[2:] # remove the leading "0b" UpperCAmelCase_ : Union[str, Any] = str(bin(__snake_case ) )[2:] # remove the leading "0b" UpperCAmelCase_ : List[Any] = max(len(__snake_case ) , len(__snake_case ) ) return "0b" + "".join( str(int(char_a == '1' and char_b == '1' ) ) for char_a, char_b in zip(a_binary.zfill(__snake_case ) , b_binary.zfill(__snake_case ) ) ) if __name__ == "__main__": import doctest doctest.testmod()
29
1
def lowercase__ ( __snake_case : int , __snake_case : int ): '''simple docstring''' return abs(__snake_case ) if a == 0 else greatest_common_divisor(b % a , __snake_case ) def lowercase__ ( __snake_case : int , __snake_case : int ): '''simple docstring''' while y: # --> when y=0 then loop will terminate and return x as final GCD. UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = y, x % y return abs(__snake_case ) def lowercase__ ( ): '''simple docstring''' try: UpperCAmelCase_ : str = input('Enter two integers separated by comma (,): ' ).split(',' ) UpperCAmelCase_ : Union[str, Any] = int(nums[0] ) UpperCAmelCase_ : Optional[Any] = int(nums[1] ) print( F"greatest_common_divisor({num_a}, {num_a}) = " F"{greatest_common_divisor(__snake_case , __snake_case )}" ) print(F"By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(__snake_case , __snake_case )}" ) except (IndexError, UnboundLocalError, ValueError): print('Wrong input' ) if __name__ == "__main__": main()
29
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_convbert import ConvBertTokenizer __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {'vocab_file': 'vocab.txt'} __UpperCAmelCase = { 'vocab_file': { 'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt', 'YituTech/conv-bert-medium-small': ( 'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt' ), 'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt', } } __UpperCAmelCase = { 'YituTech/conv-bert-base': 512, 'YituTech/conv-bert-medium-small': 512, 'YituTech/conv-bert-small': 512, } __UpperCAmelCase = { 'YituTech/conv-bert-base': {'do_lower_case': True}, 'YituTech/conv-bert-medium-small': {'do_lower_case': True}, 'YituTech/conv-bert-small': {'do_lower_case': True}, } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Optional[int] = VOCAB_FILES_NAMES _snake_case : int = PRETRAINED_VOCAB_FILES_MAP _snake_case : Dict = PRETRAINED_INIT_CONFIGURATION _snake_case : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _snake_case : Any = ConvBertTokenizer def __init__( self , _UpperCamelCase=None , _UpperCamelCase=None , _UpperCamelCase=True , _UpperCamelCase="[UNK]" , _UpperCamelCase="[SEP]" , _UpperCamelCase="[PAD]" , _UpperCamelCase="[CLS]" , _UpperCamelCase="[MASK]" , _UpperCamelCase=True , _UpperCamelCase=None , **_UpperCamelCase , ) -> Dict: super().__init__( _UpperCamelCase , tokenizer_file=_UpperCamelCase , do_lower_case=_UpperCamelCase , unk_token=_UpperCamelCase , sep_token=_UpperCamelCase , pad_token=_UpperCamelCase , cls_token=_UpperCamelCase , mask_token=_UpperCamelCase , tokenize_chinese_chars=_UpperCamelCase , strip_accents=_UpperCamelCase , **_UpperCamelCase , ) UpperCAmelCase_ : Optional[int] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('lowercase' , _UpperCamelCase ) != do_lower_case or normalizer_state.get('strip_accents' , _UpperCamelCase ) != strip_accents or normalizer_state.get('handle_chinese_chars' , _UpperCamelCase ) != tokenize_chinese_chars ): UpperCAmelCase_ : Any = getattr(_UpperCamelCase , normalizer_state.pop('type' ) ) UpperCAmelCase_ : str = do_lower_case UpperCAmelCase_ : List[Any] = strip_accents UpperCAmelCase_ : str = tokenize_chinese_chars UpperCAmelCase_ : Tuple = normalizer_class(**_UpperCamelCase ) UpperCAmelCase_ : Any = do_lower_case def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=None ) -> List[str]: UpperCAmelCase_ : int = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> List[int]: UpperCAmelCase_ : Union[str, Any] = [self.sep_token_id] UpperCAmelCase_ : int = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None ) -> Tuple[str]: UpperCAmelCase_ : Any = self._tokenizer.model.save(_UpperCamelCase , name=_UpperCamelCase ) return tuple(_UpperCamelCase )
29
1
import os import unittest from huggingface_hub.utils import are_progress_bars_disabled import transformers.models.bart.tokenization_bart from transformers import logging from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context from transformers.utils.logging import disable_progress_bar, enable_progress_bar class lowerCamelCase (unittest.TestCase ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : List[str] = logging.get_logger() # the current default level is logging.WARNING UpperCAmelCase_ : str = logging.get_verbosity() logging.set_verbosity_error() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_warning() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_info() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_debug() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) # restore to the original level logging.set_verbosity(_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Dict: UpperCAmelCase_ : Dict = logging.get_verbosity() UpperCAmelCase_ : List[str] = logging.get_logger('transformers.models.bart.tokenization_bart' ) UpperCAmelCase_ : Dict = 'Testing 1, 2, 3' # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`) if level_origin <= logging.WARNING: with CaptureLogger(_UpperCamelCase ) as cl: logger.warning(_UpperCamelCase ) self.assertEqual(cl.out , msg + '\n' ) # this is setting the level for all of `transformers.*` loggers logging.set_verbosity_error() # should not be able to log warnings with CaptureLogger(_UpperCamelCase ) as cl: logger.warning(_UpperCamelCase ) self.assertEqual(cl.out , '' ) # should be able to log warnings again logging.set_verbosity_warning() with CaptureLogger(_UpperCamelCase ) as cl: logger.warning(_UpperCamelCase ) self.assertEqual(cl.out , msg + '\n' ) # restore to the original level logging.set_verbosity(_UpperCamelCase ) @mockenv(TRANSFORMERS_VERBOSITY='error' ) def __UpperCAmelCase ( self ) -> Union[str, Any]: # reset for the env var to take effect, next time some logger call is made transformers.utils.logging._reset_library_root_logger() # this action activates the env var UpperCAmelCase_ : List[str] = logging.get_logger('transformers.models.bart.tokenization_bart' ) UpperCAmelCase_ : Tuple = os.getenv('TRANSFORMERS_VERBOSITY' , _UpperCamelCase ) UpperCAmelCase_ : List[str] = logging.log_levels[env_level_str] UpperCAmelCase_ : Dict = logging.get_verbosity() self.assertEqual( _UpperCamelCase , _UpperCamelCase , f"TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}" , ) # restore to the original level UpperCAmelCase_ : Tuple = '' transformers.utils.logging._reset_library_root_logger() @mockenv(TRANSFORMERS_VERBOSITY='super-error' ) def __UpperCAmelCase ( self ) -> List[Any]: # reset for the env var to take effect, next time some logger call is made transformers.utils.logging._reset_library_root_logger() UpperCAmelCase_ : Any = logging.logging.getLogger() with CaptureLogger(_UpperCamelCase ) as cl: # this action activates the env var logging.get_logger('transformers.models.bart.tokenization_bart' ) self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error' , cl.out ) # no need to restore as nothing was changed def __UpperCAmelCase ( self ) -> Union[str, Any]: # testing `logger.warning_advice()` transformers.utils.logging._reset_library_root_logger() UpperCAmelCase_ : Optional[Any] = logging.get_logger('transformers.models.bart.tokenization_bart' ) UpperCAmelCase_ : Dict = 'Testing 1, 2, 3' with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1' ): # nothing should be logged as env var disables this method with CaptureLogger(_UpperCamelCase ) as cl: logger.warning_advice(_UpperCamelCase ) self.assertEqual(cl.out , '' ) with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='' ): # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset with CaptureLogger(_UpperCamelCase ) as cl: logger.warning_advice(_UpperCamelCase ) self.assertEqual(cl.out , msg + '\n' ) def lowercase__ ( ): '''simple docstring''' disable_progress_bar() assert are_progress_bars_disabled() enable_progress_bar() assert not are_progress_bars_disabled()
29
from typing import List from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'snap-research/efficientformer-l1-300': ( 'https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json' ), } class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Optional[int] = '''efficientformer''' def __init__( self , _UpperCamelCase = [3, 2, 6, 4] , _UpperCamelCase = [4_8, 9_6, 2_2_4, 4_4_8] , _UpperCamelCase = [True, True, True, True] , _UpperCamelCase = 4_4_8 , _UpperCamelCase = 3_2 , _UpperCamelCase = 4 , _UpperCamelCase = 7 , _UpperCamelCase = 5 , _UpperCamelCase = 8 , _UpperCamelCase = 4 , _UpperCamelCase = 0.0 , _UpperCamelCase = 1_6 , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = 3 , _UpperCamelCase = 2 , _UpperCamelCase = 1 , _UpperCamelCase = 0.0 , _UpperCamelCase = 1 , _UpperCamelCase = True , _UpperCamelCase = True , _UpperCamelCase = 1E-5 , _UpperCamelCase = "gelu" , _UpperCamelCase = 0.02 , _UpperCamelCase = 1E-12 , _UpperCamelCase = 2_2_4 , _UpperCamelCase = 1E-05 , **_UpperCamelCase , ) -> None: super().__init__(**_UpperCamelCase ) UpperCAmelCase_ : int = hidden_act UpperCAmelCase_ : Union[str, Any] = hidden_dropout_prob UpperCAmelCase_ : Tuple = hidden_sizes UpperCAmelCase_ : Union[str, Any] = num_hidden_layers UpperCAmelCase_ : List[str] = num_attention_heads UpperCAmelCase_ : List[Any] = initializer_range UpperCAmelCase_ : int = layer_norm_eps UpperCAmelCase_ : List[str] = patch_size UpperCAmelCase_ : Union[str, Any] = num_channels UpperCAmelCase_ : Optional[Any] = depths UpperCAmelCase_ : List[Any] = mlp_expansion_ratio UpperCAmelCase_ : List[str] = downsamples UpperCAmelCase_ : List[Any] = dim UpperCAmelCase_ : Tuple = key_dim UpperCAmelCase_ : Optional[int] = attention_ratio UpperCAmelCase_ : str = resolution UpperCAmelCase_ : Dict = pool_size UpperCAmelCase_ : Union[str, Any] = downsample_patch_size UpperCAmelCase_ : List[str] = downsample_stride UpperCAmelCase_ : List[str] = downsample_pad UpperCAmelCase_ : Any = drop_path_rate UpperCAmelCase_ : Dict = num_metaad_blocks UpperCAmelCase_ : Dict = distillation UpperCAmelCase_ : int = use_layer_scale UpperCAmelCase_ : Any = layer_scale_init_value UpperCAmelCase_ : Any = image_size UpperCAmelCase_ : Dict = batch_norm_eps
29
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) __UpperCAmelCase = { 'configuration_lxmert': ['LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LxmertConfig'], 'tokenization_lxmert': ['LxmertTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['LxmertTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'LxmertEncoder', 'LxmertForPreTraining', 'LxmertForQuestionAnswering', 'LxmertModel', 'LxmertPreTrainedModel', 'LxmertVisualFeatureEncoder', 'LxmertXLayer', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFLxmertForPreTraining', 'TFLxmertMainLayer', 'TFLxmertModel', 'TFLxmertPreTrainedModel', 'TFLxmertVisualFeatureEncoder', ] if TYPE_CHECKING: from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig from .tokenization_lxmert import LxmertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_lxmert_fast import LxmertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_lxmert import ( LxmertEncoder, LxmertForPreTraining, LxmertForQuestionAnswering, LxmertModel, LxmertPreTrainedModel, LxmertVisualFeatureEncoder, LxmertXLayer, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_lxmert import ( TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFLxmertForPreTraining, TFLxmertMainLayer, TFLxmertModel, TFLxmertPreTrainedModel, TFLxmertVisualFeatureEncoder, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name __UpperCAmelCase = '\n Examples:\n ```py\n >>> from PIL import Image\n >>> import torch\n >>> from diffusers import DiffusionPipeline\n >>> from diffusers.utils import export_to_gif, load_image\n\n >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")\n\n >>> repo = "openai/shap-e-img2img"\n >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n >>> pipe = pipe.to(device)\n\n >>> guidance_scale = 3.0\n >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"\n >>> image = load_image(image_url).convert("RGB")\n\n >>> images = pipe(\n ... image,\n ... guidance_scale=guidance_scale,\n ... num_inference_steps=64,\n ... frame_size=256,\n ... ).images\n\n >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")\n ```\n' @dataclass class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Union[PIL.Image.Image, np.ndarray] class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> Any: super().__init__() self.register_modules( prior=_UpperCamelCase , image_encoder=_UpperCamelCase , image_processor=_UpperCamelCase , scheduler=_UpperCamelCase , renderer=_UpperCamelCase , ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> List[Any]: if latents is None: UpperCAmelCase_ : str = randn_tensor(_UpperCamelCase , generator=_UpperCamelCase , device=_UpperCamelCase , dtype=_UpperCamelCase ) else: if latents.shape != shape: raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}" ) UpperCAmelCase_ : Tuple = latents.to(_UpperCamelCase ) UpperCAmelCase_ : Tuple = latents * scheduler.init_noise_sigma return latents def __UpperCAmelCase ( self , _UpperCamelCase=0 ) -> Union[str, Any]: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`' ) UpperCAmelCase_ : int = torch.device(f"cuda:{gpu_id}" ) UpperCAmelCase_ : int = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_UpperCamelCase , _UpperCamelCase ) @property def __UpperCAmelCase ( self ) -> int: if self.device != torch.device('meta' ) or not hasattr(self.image_encoder , '_hf_hook' ): return self.device for module in self.image_encoder.modules(): if ( hasattr(_UpperCamelCase , '_hf_hook' ) and hasattr(module._hf_hook , 'execution_device' ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ) -> str: if isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , torch.Tensor ): UpperCAmelCase_ : int = torch.cat(_UpperCamelCase , axis=0 ) if image[0].ndim == 4 else torch.stack(_UpperCamelCase , axis=0 ) if not isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : Optional[int] = self.image_processor(_UpperCamelCase , return_tensors='pt' ).pixel_values[0].unsqueeze(0 ) UpperCAmelCase_ : Tuple = image.to(dtype=self.image_encoder.dtype , device=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = self.image_encoder(_UpperCamelCase )['last_hidden_state'] UpperCAmelCase_ : Union[str, Any] = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 UpperCAmelCase_ : List[str] = image_embeds.repeat_interleave(_UpperCamelCase , dim=0 ) if do_classifier_free_guidance: UpperCAmelCase_ : Dict = torch.zeros_like(_UpperCamelCase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes UpperCAmelCase_ : Optional[int] = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(_UpperCamelCase ) def __call__( self , _UpperCamelCase , _UpperCamelCase = 1 , _UpperCamelCase = 2_5 , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = 4.0 , _UpperCamelCase = 6_4 , _UpperCamelCase = "pil" , _UpperCamelCase = True , ) -> Union[str, Any]: if isinstance(_UpperCamelCase , PIL.Image.Image ): UpperCAmelCase_ : Tuple = 1 elif isinstance(_UpperCamelCase , torch.Tensor ): UpperCAmelCase_ : str = image.shape[0] elif isinstance(_UpperCamelCase , _UpperCamelCase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): UpperCAmelCase_ : Optional[int] = len(_UpperCamelCase ) else: raise ValueError( f"`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(_UpperCamelCase )}" ) UpperCAmelCase_ : Tuple = self._execution_device UpperCAmelCase_ : str = batch_size * num_images_per_prompt UpperCAmelCase_ : str = guidance_scale > 1.0 UpperCAmelCase_ : str = self._encode_image(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # prior self.scheduler.set_timesteps(_UpperCamelCase , device=_UpperCamelCase ) UpperCAmelCase_ : int = self.scheduler.timesteps UpperCAmelCase_ : int = self.prior.config.num_embeddings UpperCAmelCase_ : Any = self.prior.config.embedding_dim UpperCAmelCase_ : List[str] = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim UpperCAmelCase_ : List[Any] = latents.reshape(latents.shape[0] , _UpperCamelCase , _UpperCamelCase ) for i, t in enumerate(self.progress_bar(_UpperCamelCase ) ): # expand the latents if we are doing classifier free guidance UpperCAmelCase_ : Tuple = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents UpperCAmelCase_ : Optional[Any] = self.scheduler.scale_model_input(_UpperCamelCase , _UpperCamelCase ) UpperCAmelCase_ : int = self.prior( _UpperCamelCase , timestep=_UpperCamelCase , proj_embedding=_UpperCamelCase , ).predicted_image_embedding # remove the variance UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: UpperCAmelCase_ , UpperCAmelCase_ : str = noise_pred.chunk(2 ) UpperCAmelCase_ : List[Any] = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) UpperCAmelCase_ : List[str] = self.scheduler.step( _UpperCamelCase , timestep=_UpperCamelCase , sample=_UpperCamelCase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = [] for i, latent in enumerate(_UpperCamelCase ): print() UpperCAmelCase_ : List[str] = self.renderer.decode( latent[None, :] , _UpperCamelCase , size=_UpperCamelCase , ray_batch_size=4_0_9_6 , n_coarse_samples=6_4 , n_fine_samples=1_2_8 , ) images.append(_UpperCamelCase ) UpperCAmelCase_ : Optional[int] = torch.stack(_UpperCamelCase ) if output_type not in ["np", "pil"]: raise ValueError(f"Only the output types `pil` and `np` are supported not output_type={output_type}" ) UpperCAmelCase_ : Dict = images.cpu().numpy() if output_type == "pil": UpperCAmelCase_ : List[str] = [self.numpy_to_pil(_UpperCamelCase ) for image in images] # Offload last model to CPU if hasattr(self , 'final_offload_hook' ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=_UpperCamelCase )
29
1
from __future__ import annotations import unittest import numpy as np from transformers import LayoutLMConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers.models.layoutlm.modeling_tf_layoutlm import ( TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFLayoutLMForMaskedLM, TFLayoutLMForQuestionAnswering, TFLayoutLMForSequenceClassification, TFLayoutLMForTokenClassification, TFLayoutLMModel, ) class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase=1_3 , _UpperCamelCase=7 , _UpperCamelCase=True , _UpperCamelCase=True , _UpperCamelCase=True , _UpperCamelCase=True , _UpperCamelCase=9_9 , _UpperCamelCase=3_2 , _UpperCamelCase=2 , _UpperCamelCase=4 , _UpperCamelCase=3_7 , _UpperCamelCase="gelu" , _UpperCamelCase=0.1 , _UpperCamelCase=0.1 , _UpperCamelCase=5_1_2 , _UpperCamelCase=1_6 , _UpperCamelCase=2 , _UpperCamelCase=0.02 , _UpperCamelCase=3 , _UpperCamelCase=4 , _UpperCamelCase=None , _UpperCamelCase=1_0_0_0 , ) -> Any: UpperCAmelCase_ : Union[str, Any] = parent UpperCAmelCase_ : Tuple = batch_size UpperCAmelCase_ : int = seq_length UpperCAmelCase_ : Dict = is_training UpperCAmelCase_ : str = use_input_mask UpperCAmelCase_ : List[Any] = use_token_type_ids UpperCAmelCase_ : Any = use_labels UpperCAmelCase_ : Optional[Any] = vocab_size UpperCAmelCase_ : Dict = hidden_size UpperCAmelCase_ : str = num_hidden_layers UpperCAmelCase_ : Optional[int] = num_attention_heads UpperCAmelCase_ : int = intermediate_size UpperCAmelCase_ : List[Any] = hidden_act UpperCAmelCase_ : Dict = hidden_dropout_prob UpperCAmelCase_ : str = attention_probs_dropout_prob UpperCAmelCase_ : Tuple = max_position_embeddings UpperCAmelCase_ : Optional[int] = type_vocab_size UpperCAmelCase_ : Optional[Any] = type_sequence_label_size UpperCAmelCase_ : List[str] = initializer_range UpperCAmelCase_ : str = num_labels UpperCAmelCase_ : Tuple = num_choices UpperCAmelCase_ : List[Any] = scope UpperCAmelCase_ : Union[str, Any] = range_bbox def __UpperCAmelCase ( self ) -> Optional[int]: UpperCAmelCase_ : Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) # convert bbox to numpy since TF does not support item assignment UpperCAmelCase_ : Optional[int] = ids_tensor([self.batch_size, self.seq_length, 4] , self.range_bbox ).numpy() # Ensure that bbox is legal for i in range(bbox.shape[0] ): for j in range(bbox.shape[1] ): if bbox[i, j, 3] < bbox[i, j, 1]: UpperCAmelCase_ : Optional[int] = bbox[i, j, 3] UpperCAmelCase_ : Tuple = bbox[i, j, 1] UpperCAmelCase_ : Union[str, Any] = t if bbox[i, j, 2] < bbox[i, j, 0]: UpperCAmelCase_ : List[str] = bbox[i, j, 2] UpperCAmelCase_ : Tuple = bbox[i, j, 0] UpperCAmelCase_ : Tuple = t UpperCAmelCase_ : Optional[Any] = tf.convert_to_tensor(_UpperCamelCase ) UpperCAmelCase_ : str = None if self.use_input_mask: UpperCAmelCase_ : Dict = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase_ : Union[str, Any] = None if self.use_token_type_ids: UpperCAmelCase_ : str = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCAmelCase_ : str = None UpperCAmelCase_ : Any = None UpperCAmelCase_ : Optional[Any] = None if self.use_labels: UpperCAmelCase_ : Optional[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCAmelCase_ : List[Any] = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) UpperCAmelCase_ : List[str] = ids_tensor([self.batch_size] , self.num_choices ) UpperCAmelCase_ : Tuple = LayoutLMConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , ) return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Optional[int]: UpperCAmelCase_ : Any = TFLayoutLMModel(config=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = model(_UpperCamelCase , _UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = model(_UpperCamelCase , _UpperCamelCase , token_type_ids=_UpperCamelCase ) UpperCAmelCase_ : Tuple = model(_UpperCamelCase , _UpperCamelCase ) 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 , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Optional[Any]: UpperCAmelCase_ : List[Any] = TFLayoutLMForMaskedLM(config=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = model(_UpperCamelCase , _UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase , labels=_UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> int: UpperCAmelCase_ : List[Any] = self.num_labels UpperCAmelCase_ : Union[str, Any] = TFLayoutLMForSequenceClassification(config=_UpperCamelCase ) UpperCAmelCase_ : Dict = model(_UpperCamelCase , _UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Optional[int]: UpperCAmelCase_ : List[Any] = self.num_labels UpperCAmelCase_ : int = TFLayoutLMForTokenClassification(config=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = model(_UpperCamelCase , _UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase , labels=_UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any: UpperCAmelCase_ : List[str] = TFLayoutLMForQuestionAnswering(config=_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = model(_UpperCamelCase , _UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Dict = self.prepare_config_and_inputs() ( ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ( UpperCAmelCase_ ) , ) : Tuple = config_and_inputs UpperCAmelCase_ : List[Any] = { 'input_ids': input_ids, 'bbox': bbox, 'token_type_ids': token_type_ids, 'attention_mask': input_mask, } return config, inputs_dict @require_tf class lowerCamelCase (_snake_case , _snake_case , unittest.TestCase ): '''simple docstring''' _snake_case : int = ( ( TFLayoutLMModel, TFLayoutLMForMaskedLM, TFLayoutLMForTokenClassification, TFLayoutLMForSequenceClassification, TFLayoutLMForQuestionAnswering, ) if is_tf_available() else () ) _snake_case : List[Any] = ( { '''feature-extraction''': TFLayoutLMModel, '''fill-mask''': TFLayoutLMForMaskedLM, '''text-classification''': TFLayoutLMForSequenceClassification, '''token-classification''': TFLayoutLMForTokenClassification, '''zero-shot''': TFLayoutLMForSequenceClassification, } if is_tf_available() else {} ) _snake_case : Optional[int] = False _snake_case : Dict = True _snake_case : Dict = 1_0 def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Tuple = TFLayoutLMModelTester(self ) UpperCAmelCase_ : Any = ConfigTester(self , config_class=_UpperCamelCase , hidden_size=3_7 ) def __UpperCAmelCase ( self ) -> List[Any]: self.config_tester.run_common_tests() def __UpperCAmelCase ( self ) -> List[Any]: UpperCAmelCase_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[int]: UpperCAmelCase_ : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: UpperCAmelCase_ : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Union[str, Any]: UpperCAmelCase_ : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase ) @slow def __UpperCAmelCase ( self ) -> List[str]: for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase_ : List[Any] = TFLayoutLMModel.from_pretrained(_UpperCamelCase ) self.assertIsNotNone(_UpperCamelCase ) @unittest.skip('Onnx compliancy broke with TF 2.10' ) def __UpperCAmelCase ( self ) -> Tuple: pass def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Dict = tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]] ) # noqa: E231 UpperCAmelCase_ : Any = tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],] ) # noqa: E231 UpperCAmelCase_ : str = tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]] ) # noqa: E231 UpperCAmelCase_ : Any = tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,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: E231 # these are sequence labels (i.e. at the token level) UpperCAmelCase_ : int = tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]] ) # noqa: E231 # fmt: on return input_ids, attention_mask, bbox, token_type_ids, labels @require_tf class lowerCamelCase (unittest.TestCase ): '''simple docstring''' @slow def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : List[Any] = TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased' ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = prepare_layoutlm_batch_inputs() # forward pass UpperCAmelCase_ : Union[str, Any] = model(input_ids=_UpperCamelCase , bbox=_UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase ) # test the sequence output on [0, :3, :3] UpperCAmelCase_ : Any = tf.convert_to_tensor( [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]] , ) self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3] , _UpperCamelCase , atol=1E-3 ) ) # test the pooled output on [1, :3] UpperCAmelCase_ : Tuple = tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52] ) self.assertTrue(np.allclose(outputs.pooler_output[1, :3] , _UpperCamelCase , atol=1E-3 ) ) @slow def __UpperCAmelCase ( self ) -> str: # initialize model with randomly initialized sequence classification head UpperCAmelCase_ : Union[str, Any] = TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased' , num_labels=2 ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : List[str] = prepare_layoutlm_batch_inputs() # forward pass UpperCAmelCase_ : str = model( input_ids=_UpperCamelCase , bbox=_UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase , labels=tf.convert_to_tensor([1, 1] ) , ) # test whether we get a loss as a scalar UpperCAmelCase_ : List[str] = outputs.loss UpperCAmelCase_ : Tuple = (2,) self.assertEqual(loss.shape , _UpperCamelCase ) # test the shape of the logits UpperCAmelCase_ : Dict = outputs.logits UpperCAmelCase_ : List[str] = (2, 2) self.assertEqual(logits.shape , _UpperCamelCase ) @slow def __UpperCAmelCase ( self ) -> List[Any]: # initialize model with randomly initialized token classification head UpperCAmelCase_ : int = TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased' , num_labels=1_3 ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = prepare_layoutlm_batch_inputs() # forward pass UpperCAmelCase_ : str = model( input_ids=_UpperCamelCase , bbox=_UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase , labels=_UpperCamelCase ) # test the shape of the logits UpperCAmelCase_ : int = outputs.logits UpperCAmelCase_ : str = tf.convert_to_tensor((2, 2_5, 1_3) ) self.assertEqual(logits.shape , _UpperCamelCase ) @slow def __UpperCAmelCase ( self ) -> List[str]: # initialize model with randomly initialized token classification head UpperCAmelCase_ : Tuple = TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased' ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : int = prepare_layoutlm_batch_inputs() # forward pass UpperCAmelCase_ : Tuple = model(input_ids=_UpperCamelCase , bbox=_UpperCamelCase , attention_mask=_UpperCamelCase , token_type_ids=_UpperCamelCase ) # test the shape of the logits UpperCAmelCase_ : Tuple = tf.convert_to_tensor((2, 2_5) ) self.assertEqual(outputs.start_logits.shape , _UpperCamelCase ) self.assertEqual(outputs.end_logits.shape , _UpperCamelCase )
29
import random import unittest import torch from diffusers import IFImgaImgSuperResolutionPipeline from diffusers.utils import floats_tensor from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import skip_mps, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin from . import IFPipelineTesterMixin @skip_mps class lowerCamelCase (_snake_case , _snake_case , unittest.TestCase ): '''simple docstring''' _snake_case : Union[str, Any] = IFImgaImgSuperResolutionPipeline _snake_case : Union[str, Any] = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''} _snake_case : List[Any] = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''} ) _snake_case : List[str] = PipelineTesterMixin.required_optional_params - {'''latents'''} def __UpperCAmelCase ( self ) -> Optional[Any]: return self._get_superresolution_dummy_components() def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase=0 ) -> Any: if str(_UpperCamelCase ).startswith('mps' ): UpperCAmelCase_ : List[Any] = torch.manual_seed(_UpperCamelCase ) else: UpperCAmelCase_ : int = torch.Generator(device=_UpperCamelCase ).manual_seed(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Dict = floats_tensor((1, 3, 1_6, 1_6) , rng=random.Random(_UpperCamelCase ) ).to(_UpperCamelCase ) UpperCAmelCase_ : Tuple = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'original_image': original_image, 'generator': generator, 'num_inference_steps': 2, 'output_type': 'numpy', } return inputs @unittest.skipIf( torch_device != 'cuda' or not is_xformers_available() , reason='XFormers attention is only available with CUDA and `xformers` installed' , ) def __UpperCAmelCase ( self ) -> Any: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 ) def __UpperCAmelCase ( self ) -> Dict: self._test_save_load_optional_components() @unittest.skipIf(torch_device != 'cuda' , reason='float16 requires CUDA' ) def __UpperCAmelCase ( self ) -> str: # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder super().test_save_load_floataa(expected_max_diff=1E-1 ) def __UpperCAmelCase ( self ) -> List[Any]: self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 ) def __UpperCAmelCase ( self ) -> Union[str, Any]: self._test_save_load_local() def __UpperCAmelCase ( self ) -> Dict: self._test_inference_batch_single_identical( expected_max_diff=1E-2 , )
29
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available, is_vision_available, ) __UpperCAmelCase = {'configuration_beit': ['BEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BeitConfig', 'BeitOnnxConfig']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['BeitFeatureExtractor'] __UpperCAmelCase = ['BeitImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'BEIT_PRETRAINED_MODEL_ARCHIVE_LIST', 'BeitForImageClassification', 'BeitForMaskedImageModeling', 'BeitForSemanticSegmentation', 'BeitModel', 'BeitPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'FlaxBeitForImageClassification', 'FlaxBeitForMaskedImageModeling', 'FlaxBeitModel', 'FlaxBeitPreTrainedModel', ] if TYPE_CHECKING: from .configuration_beit import BEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, BeitConfig, BeitOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_beit import BeitFeatureExtractor from .image_processing_beit import BeitImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_beit import ( BEIT_PRETRAINED_MODEL_ARCHIVE_LIST, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation, BeitModel, BeitPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_beit import ( FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling, FlaxBeitModel, FlaxBeitPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = { 'configuration_time_series_transformer': [ 'TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TimeSeriesTransformerConfig', ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST', 'TimeSeriesTransformerForPrediction', 'TimeSeriesTransformerModel', 'TimeSeriesTransformerPreTrainedModel', ] if TYPE_CHECKING: from .configuration_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimeSeriesTransformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimeSeriesTransformerForPrediction, TimeSeriesTransformerModel, TimeSeriesTransformerPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
1
import inspect import unittest from transformers import SegformerConfig, is_torch_available, is_vision_available from transformers.models.auto import get_values from transformers.testing_utils import 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 if is_torch_available(): import torch from transformers import ( MODEL_MAPPING, SegformerForImageClassification, SegformerForSemanticSegmentation, SegformerModel, ) from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import SegformerImageProcessor class lowerCamelCase (_snake_case ): '''simple docstring''' def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : Union[str, Any] = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(_UpperCamelCase , 'hidden_sizes' ) ) self.parent.assertTrue(hasattr(_UpperCamelCase , 'num_attention_heads' ) ) self.parent.assertTrue(hasattr(_UpperCamelCase , 'num_encoder_blocks' ) ) class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase , _UpperCamelCase=1_3 , _UpperCamelCase=6_4 , _UpperCamelCase=3 , _UpperCamelCase=4 , _UpperCamelCase=[2, 2, 2, 2] , _UpperCamelCase=[8, 4, 2, 1] , _UpperCamelCase=[1_6, 3_2, 6_4, 1_2_8] , _UpperCamelCase=[1, 4, 8, 1_6] , _UpperCamelCase=[1, 2, 4, 8] , _UpperCamelCase=True , _UpperCamelCase=True , _UpperCamelCase="gelu" , _UpperCamelCase=0.1 , _UpperCamelCase=0.1 , _UpperCamelCase=0.02 , _UpperCamelCase=3 , _UpperCamelCase=None , ) -> List[Any]: UpperCAmelCase_ : Optional[int] = parent UpperCAmelCase_ : Union[str, Any] = batch_size UpperCAmelCase_ : Dict = image_size UpperCAmelCase_ : Dict = num_channels UpperCAmelCase_ : Optional[int] = num_encoder_blocks UpperCAmelCase_ : Union[str, Any] = sr_ratios UpperCAmelCase_ : Optional[Any] = depths UpperCAmelCase_ : str = hidden_sizes UpperCAmelCase_ : int = downsampling_rates UpperCAmelCase_ : Any = num_attention_heads UpperCAmelCase_ : Any = is_training UpperCAmelCase_ : int = use_labels UpperCAmelCase_ : Tuple = hidden_act UpperCAmelCase_ : List[str] = hidden_dropout_prob UpperCAmelCase_ : Tuple = attention_probs_dropout_prob UpperCAmelCase_ : Optional[int] = initializer_range UpperCAmelCase_ : Any = num_labels UpperCAmelCase_ : List[str] = scope def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase_ : Dict = None if self.use_labels: UpperCAmelCase_ : Any = ids_tensor([self.batch_size, self.image_size, self.image_size] , self.num_labels ) UpperCAmelCase_ : str = self.get_config() return config, pixel_values, labels def __UpperCAmelCase ( self ) -> Union[str, Any]: return SegformerConfig( image_size=self.image_size , num_channels=self.num_channels , num_encoder_blocks=self.num_encoder_blocks , depths=self.depths , hidden_sizes=self.hidden_sizes , num_attention_heads=self.num_attention_heads , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , initializer_range=self.initializer_range , ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Dict: UpperCAmelCase_ : str = SegformerModel(config=_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() UpperCAmelCase_ : List[str] = model(_UpperCamelCase ) UpperCAmelCase_ : str = self.image_size // (self.downsampling_rates[-1] * 2) self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width) ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> List[str]: UpperCAmelCase_ : int = self.num_labels UpperCAmelCase_ : Optional[Any] = SegformerForSemanticSegmentation(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() UpperCAmelCase_ : Any = model(_UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4) ) UpperCAmelCase_ : int = model(_UpperCamelCase , labels=_UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4) ) self.parent.assertGreater(result.loss , 0.0 ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Union[str, Any]: UpperCAmelCase_ : List[Any] = 1 UpperCAmelCase_ : Dict = SegformerForSemanticSegmentation(config=_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() UpperCAmelCase_ : Tuple = torch.randint(0 , 1 , (self.batch_size, self.image_size, self.image_size) ).to(_UpperCamelCase ) UpperCAmelCase_ : str = model(_UpperCamelCase , labels=_UpperCamelCase ) self.parent.assertGreater(result.loss , 0.0 ) def __UpperCAmelCase ( self ) -> Optional[Any]: UpperCAmelCase_ : Any = self.prepare_config_and_inputs() UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : str = config_and_inputs UpperCAmelCase_ : Optional[int] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class lowerCamelCase (_snake_case , _snake_case , unittest.TestCase ): '''simple docstring''' _snake_case : Optional[Any] = ( ( SegformerModel, SegformerForSemanticSegmentation, SegformerForImageClassification, ) if is_torch_available() else () ) _snake_case : int = ( { '''feature-extraction''': SegformerModel, '''image-classification''': SegformerForImageClassification, '''image-segmentation''': SegformerForSemanticSegmentation, } if is_torch_available() else {} ) _snake_case : Optional[Any] = True _snake_case : Dict = False _snake_case : Any = False _snake_case : int = False def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Any = SegformerModelTester(self ) UpperCAmelCase_ : int = SegformerConfigTester(self , config_class=_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: self.config_tester.run_common_tests() def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Union[str, Any]: UpperCAmelCase_ : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_binary_image_segmentation(*_UpperCamelCase ) def __UpperCAmelCase ( self ) -> Tuple: UpperCAmelCase_ : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_segmentation(*_UpperCamelCase ) @unittest.skip('SegFormer does not use inputs_embeds' ) def __UpperCAmelCase ( self ) -> Union[str, Any]: pass @unittest.skip('SegFormer does not have get_input_embeddings method and get_output_embeddings methods' ) def __UpperCAmelCase ( self ) -> str: pass def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ , UpperCAmelCase_ : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase_ : List[Any] = model_class(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase_ : int = [*signature.parameters.keys()] UpperCAmelCase_ : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ , UpperCAmelCase_ : int = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase_ : Union[str, Any] = True for model_class in self.all_model_classes: UpperCAmelCase_ : Union[str, Any] = True UpperCAmelCase_ : str = False UpperCAmelCase_ : List[str] = True UpperCAmelCase_ : Optional[Any] = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): UpperCAmelCase_ : int = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) UpperCAmelCase_ : int = outputs.attentions UpperCAmelCase_ : Tuple = sum(self.model_tester.depths ) self.assertEqual(len(_UpperCamelCase ) , _UpperCamelCase ) # check that output_attentions also work using config del inputs_dict["output_attentions"] UpperCAmelCase_ : Optional[Any] = True UpperCAmelCase_ : Any = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): UpperCAmelCase_ : int = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) UpperCAmelCase_ : Optional[Any] = outputs.attentions self.assertEqual(len(_UpperCamelCase ) , _UpperCamelCase ) # verify the first attentions (first block, first layer) UpperCAmelCase_ : Optional[int] = (self.model_tester.image_size // 4) ** 2 UpperCAmelCase_ : List[Any] = (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2 self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] , ) # verify the last attentions (last block, last layer) UpperCAmelCase_ : int = (self.model_tester.image_size // 3_2) ** 2 UpperCAmelCase_ : Dict = (self.model_tester.image_size // (3_2 * self.model_tester.sr_ratios[-1])) ** 2 self.assertListEqual( list(attentions[-1].shape[-3:] ) , [self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len] , ) UpperCAmelCase_ : List[Any] = len(_UpperCamelCase ) # Check attention is always last and order is fine UpperCAmelCase_ : Union[str, Any] = True UpperCAmelCase_ : Optional[Any] = True UpperCAmelCase_ : str = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): UpperCAmelCase_ : Union[str, Any] = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) self.assertEqual(out_len + 1 , len(_UpperCamelCase ) ) UpperCAmelCase_ : List[str] = outputs.attentions self.assertEqual(len(_UpperCamelCase ) , _UpperCamelCase ) # verify the first attentions (first block, first layer) UpperCAmelCase_ : Union[str, Any] = (self.model_tester.image_size // 4) ** 2 UpperCAmelCase_ : List[Any] = (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2 self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len] , ) def __UpperCAmelCase ( self ) -> Optional[int]: def check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): UpperCAmelCase_ : Dict = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): UpperCAmelCase_ : List[str] = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) UpperCAmelCase_ : Dict = outputs.hidden_states UpperCAmelCase_ : Optional[int] = self.model_tester.num_encoder_blocks self.assertEqual(len(_UpperCamelCase ) , _UpperCamelCase ) # verify the first hidden states (first block) self.assertListEqual( list(hidden_states[0].shape[-3:] ) , [ self.model_tester.hidden_sizes[0], self.model_tester.image_size // 4, self.model_tester.image_size // 4, ] , ) UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase_ : List[Any] = True check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCAmelCase_ : List[Any] = True check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) def __UpperCAmelCase ( self ) -> Optional[Any]: if not self.model_tester.is_training: return UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase_ : str = True for model_class in self.all_model_classes: if model_class in get_values(_UpperCamelCase ): continue UpperCAmelCase_ : str = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.train() UpperCAmelCase_ : int = self._prepare_for_class(_UpperCamelCase , _UpperCamelCase , return_labels=_UpperCamelCase ) UpperCAmelCase_ : str = model(**_UpperCamelCase ).loss loss.backward() @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def __UpperCAmelCase ( self ) -> Tuple: pass @slow def __UpperCAmelCase ( self ) -> Dict: for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase_ : List[Any] = SegformerModel.from_pretrained(_UpperCamelCase ) self.assertIsNotNone(_UpperCamelCase ) def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : List[str] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch class lowerCamelCase (unittest.TestCase ): '''simple docstring''' @slow def __UpperCAmelCase ( self ) -> Optional[Any]: # only resize + normalize UpperCAmelCase_ : int = SegformerImageProcessor( image_scale=(5_1_2, 5_1_2) , keep_ratio=_UpperCamelCase , align=_UpperCamelCase , do_random_crop=_UpperCamelCase ) UpperCAmelCase_ : List[Any] = SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512' ).to( _UpperCamelCase ) UpperCAmelCase_ : Any = prepare_img() UpperCAmelCase_ : str = image_processor(images=_UpperCamelCase , return_tensors='pt' ) UpperCAmelCase_ : Tuple = encoded_inputs.pixel_values.to(_UpperCamelCase ) with torch.no_grad(): UpperCAmelCase_ : int = model(_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8) ) self.assertEqual(outputs.logits.shape , _UpperCamelCase ) UpperCAmelCase_ : Any = torch.tensor( [ [[-4.63_10, -5.52_32, -6.23_56], [-5.19_21, -6.14_44, -6.59_96], [-5.44_24, -6.27_90, -6.75_74]], [[-12.13_91, -13.31_22, -13.95_54], [-12.87_32, -13.93_52, -14.35_63], [-12.94_38, -13.82_26, -14.25_13]], [[-12.51_34, -13.46_86, -14.49_15], [-12.86_69, -14.43_43, -14.77_58], [-13.25_23, -14.58_19, -15.06_94]], ] ).to(_UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] , _UpperCamelCase , atol=1E-4 ) ) @slow def __UpperCAmelCase ( self ) -> List[Any]: # only resize + normalize UpperCAmelCase_ : Optional[Any] = SegformerImageProcessor( image_scale=(5_1_2, 5_1_2) , keep_ratio=_UpperCamelCase , align=_UpperCamelCase , do_random_crop=_UpperCamelCase ) UpperCAmelCase_ : Any = SegformerForSemanticSegmentation.from_pretrained( 'nvidia/segformer-b1-finetuned-cityscapes-1024-1024' ).to(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = prepare_img() UpperCAmelCase_ : Union[str, Any] = image_processor(images=_UpperCamelCase , return_tensors='pt' ) UpperCAmelCase_ : Union[str, Any] = encoded_inputs.pixel_values.to(_UpperCamelCase ) with torch.no_grad(): UpperCAmelCase_ : List[str] = model(_UpperCamelCase ) UpperCAmelCase_ : List[Any] = torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8) ) self.assertEqual(outputs.logits.shape , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = torch.tensor( [ [[-13.57_48, -13.91_11, -12.65_00], [-14.35_00, -15.36_83, -14.23_28], [-14.75_32, -16.04_24, -15.60_87]], [[-17.16_51, -15.87_25, -12.96_53], [-17.25_80, -17.37_18, -14.82_23], [-16.60_58, -16.87_83, -16.74_52]], [[-3.64_56, -3.02_09, -1.42_03], [-3.07_97, -3.19_59, -2.00_00], [-1.87_57, -1.92_17, -1.69_97]], ] ).to(_UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] , _UpperCamelCase , atol=1E-1 ) ) @slow def __UpperCAmelCase ( self ) -> Optional[int]: # only resize + normalize UpperCAmelCase_ : int = SegformerImageProcessor( image_scale=(5_1_2, 5_1_2) , keep_ratio=_UpperCamelCase , align=_UpperCamelCase , do_random_crop=_UpperCamelCase ) UpperCAmelCase_ : List[str] = SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512' ).to( _UpperCamelCase ) UpperCAmelCase_ : int = prepare_img() UpperCAmelCase_ : str = image_processor(images=_UpperCamelCase , return_tensors='pt' ) UpperCAmelCase_ : Any = encoded_inputs.pixel_values.to(_UpperCamelCase ) with torch.no_grad(): UpperCAmelCase_ : List[Any] = model(_UpperCamelCase ) UpperCAmelCase_ : str = outputs.logits.detach().cpu() UpperCAmelCase_ : Tuple = image_processor.post_process_semantic_segmentation(outputs=_UpperCamelCase , target_sizes=[(5_0_0, 3_0_0)] ) UpperCAmelCase_ : Tuple = torch.Size((5_0_0, 3_0_0) ) self.assertEqual(segmentation[0].shape , _UpperCamelCase ) UpperCAmelCase_ : Tuple = image_processor.post_process_semantic_segmentation(outputs=_UpperCamelCase ) UpperCAmelCase_ : List[str] = torch.Size((1_2_8, 1_2_8) ) self.assertEqual(segmentation[0].shape , _UpperCamelCase )
29
import os import shutil from pathlib import Path from typing import Optional, Union import numpy as np from huggingface_hub import hf_hub_download from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging if is_onnx_available(): import onnxruntime as ort __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'tensor(bool)': np.bool_, 'tensor(int8)': np.inta, 'tensor(uint8)': np.uinta, 'tensor(int16)': np.intaa, 'tensor(uint16)': np.uintaa, 'tensor(int32)': np.intaa, 'tensor(uint32)': np.uintaa, 'tensor(int64)': np.intaa, 'tensor(uint64)': np.uintaa, 'tensor(float16)': np.floataa, 'tensor(float)': np.floataa, 'tensor(double)': np.floataa, } class lowerCamelCase : '''simple docstring''' def __init__( self , _UpperCamelCase=None , **_UpperCamelCase ) -> Dict: logger.info('`diffusers.OnnxRuntimeModel` is experimental and might change in the future.' ) UpperCAmelCase_ : Any = model UpperCAmelCase_ : int = kwargs.get('model_save_dir' , _UpperCamelCase ) UpperCAmelCase_ : List[Any] = kwargs.get('latest_model_name' , _UpperCamelCase ) def __call__( self , **_UpperCamelCase ) -> str: UpperCAmelCase_ : Optional[int] = {k: np.array(_UpperCamelCase ) for k, v in kwargs.items()} return self.model.run(_UpperCamelCase , _UpperCamelCase ) @staticmethod def __UpperCAmelCase ( _UpperCamelCase , _UpperCamelCase=None , _UpperCamelCase=None ) -> List[Any]: if provider is None: logger.info('No onnxruntime provider specified, using CPUExecutionProvider' ) UpperCAmelCase_ : List[str] = 'CPUExecutionProvider' return ort.InferenceSession(_UpperCamelCase , providers=[provider] , sess_options=_UpperCamelCase ) def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase = None , **_UpperCamelCase ) -> Dict: UpperCAmelCase_ : Any = file_name if file_name is not None else ONNX_WEIGHTS_NAME UpperCAmelCase_ : Optional[Any] = self.model_save_dir.joinpath(self.latest_model_name ) UpperCAmelCase_ : str = Path(_UpperCamelCase ).joinpath(_UpperCamelCase ) try: shutil.copyfile(_UpperCamelCase , _UpperCamelCase ) except shutil.SameFileError: pass # copy external weights (for models >2GB) UpperCAmelCase_ : Optional[Any] = self.model_save_dir.joinpath(_UpperCamelCase ) if src_path.exists(): UpperCAmelCase_ : List[Any] = Path(_UpperCamelCase ).joinpath(_UpperCamelCase ) try: shutil.copyfile(_UpperCamelCase , _UpperCamelCase ) except shutil.SameFileError: pass def __UpperCAmelCase ( self , _UpperCamelCase , **_UpperCamelCase , ) -> List[str]: if os.path.isfile(_UpperCamelCase ): logger.error(f"Provided path ({save_directory}) should be a directory, not a file" ) return os.makedirs(_UpperCamelCase , exist_ok=_UpperCamelCase ) # saving model weights/files self._save_pretrained(_UpperCamelCase , **_UpperCamelCase ) @classmethod def __UpperCAmelCase ( cls , _UpperCamelCase , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = False , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = None , _UpperCamelCase = None , **_UpperCamelCase , ) -> List[str]: UpperCAmelCase_ : List[str] = file_name if file_name is not None else ONNX_WEIGHTS_NAME # load model from local directory if os.path.isdir(_UpperCamelCase ): UpperCAmelCase_ : Union[str, Any] = OnnxRuntimeModel.load_model( os.path.join(_UpperCamelCase , _UpperCamelCase ) , provider=_UpperCamelCase , sess_options=_UpperCamelCase ) UpperCAmelCase_ : Tuple = Path(_UpperCamelCase ) # load model from hub else: # download model UpperCAmelCase_ : List[str] = hf_hub_download( repo_id=_UpperCamelCase , filename=_UpperCamelCase , use_auth_token=_UpperCamelCase , revision=_UpperCamelCase , cache_dir=_UpperCamelCase , force_download=_UpperCamelCase , ) UpperCAmelCase_ : Union[str, Any] = Path(_UpperCamelCase ).parent UpperCAmelCase_ : List[str] = Path(_UpperCamelCase ).name UpperCAmelCase_ : Union[str, Any] = OnnxRuntimeModel.load_model(_UpperCamelCase , provider=_UpperCamelCase , sess_options=_UpperCamelCase ) return cls(model=_UpperCamelCase , **_UpperCamelCase ) @classmethod def __UpperCAmelCase ( cls , _UpperCamelCase , _UpperCamelCase = True , _UpperCamelCase = None , _UpperCamelCase = None , **_UpperCamelCase , ) -> Optional[int]: UpperCAmelCase_ : List[str] = None if len(str(_UpperCamelCase ).split('@' ) ) == 2: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = model_id.split('@' ) return cls._from_pretrained( model_id=_UpperCamelCase , revision=_UpperCamelCase , cache_dir=_UpperCamelCase , force_download=_UpperCamelCase , use_auth_token=_UpperCamelCase , **_UpperCamelCase , )
29
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = {'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'IBertForMaskedLM', 'IBertForMultipleChoice', 'IBertForQuestionAnswering', 'IBertForSequenceClassification', 'IBertForTokenClassification', 'IBertModel', 'IBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ibert import ( IBERT_PRETRAINED_MODEL_ARCHIVE_LIST, IBertForMaskedLM, IBertForMultipleChoice, IBertForQuestionAnswering, IBertForSequenceClassification, IBertForTokenClassification, IBertModel, IBertPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
import contextlib import csv import json import os import sqlitea import tarfile import textwrap import zipfile import pyarrow as pa import pyarrow.parquet as pq import pytest import datasets import datasets.config @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Tuple = 10 UpperCAmelCase_ : Tuple = datasets.Features( { 'tokens': datasets.Sequence(datasets.Value('string' ) ), 'labels': datasets.Sequence(datasets.ClassLabel(names=['negative', 'positive'] ) ), 'answers': datasets.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), 'id': datasets.Value('int64' ), } ) UpperCAmelCase_ : Tuple = datasets.Dataset.from_dict( { 'tokens': [['foo'] * 5] * n, 'labels': [[1] * 5] * n, 'answers': [{'answer_start': [97], 'text': ['1976']}] * 10, 'id': list(range(__snake_case ) ), } , features=__snake_case , ) return dataset @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : List[str] ): '''simple docstring''' UpperCAmelCase_ : str = str(tmp_path_factory.mktemp('data' ) / 'file.arrow' ) dataset.map(cache_file_name=__snake_case ) return filename # FILE_CONTENT + files __UpperCAmelCase = '\\n Text data.\n Second line of data.' @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'file.txt' UpperCAmelCase_ : Tuple = FILE_CONTENT with open(__snake_case , 'w' ) as f: f.write(__snake_case ) return filename @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] ): '''simple docstring''' import bza UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'file.txt.bz2' UpperCAmelCase_ : str = bytes(__snake_case , 'utf-8' ) with bza.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' import gzip UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'file.txt.gz' ) UpperCAmelCase_ : Dict = bytes(__snake_case , 'utf-8' ) with gzip.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' if datasets.config.LZ4_AVAILABLE: import lza.frame UpperCAmelCase_ : Any = tmp_path_factory.mktemp('data' ) / 'file.txt.lz4' UpperCAmelCase_ : Any = bytes(__snake_case , 'utf-8' ) with lza.frame.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : List[Any] ): '''simple docstring''' if datasets.config.PY7ZR_AVAILABLE: import pyazr UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'file.txt.7z' with pyazr.SevenZipFile(__snake_case , 'w' ) as archive: archive.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] , __snake_case : List[Any] ): '''simple docstring''' import tarfile UpperCAmelCase_ : Any = tmp_path_factory.mktemp('data' ) / 'file.txt.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' import lzma UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'file.txt.xz' UpperCAmelCase_ : Any = bytes(__snake_case , 'utf-8' ) with lzma.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[int] , __snake_case : Optional[Any] ): '''simple docstring''' import zipfile UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'file.txt.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' if datasets.config.ZSTANDARD_AVAILABLE: import zstandard as zstd UpperCAmelCase_ : Tuple = tmp_path_factory.mktemp('data' ) / 'file.txt.zst' UpperCAmelCase_ : List[str] = bytes(__snake_case , 'utf-8' ) with zstd.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'file.xml' UpperCAmelCase_ : List[Any] = textwrap.dedent( '\\n <?xml version="1.0" encoding="UTF-8" ?>\n <tmx version="1.4">\n <header segtype="sentence" srclang="ca" />\n <body>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 1</seg></tuv>\n <tuv xml:lang="en"><seg>Content 1</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 2</seg></tuv>\n <tuv xml:lang="en"><seg>Content 2</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 3</seg></tuv>\n <tuv xml:lang="en"><seg>Content 3</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 4</seg></tuv>\n <tuv xml:lang="en"><seg>Content 4</seg></tuv>\n </tu>\n <tu>\n <tuv xml:lang="ca"><seg>Contingut 5</seg></tuv>\n <tuv xml:lang="en"><seg>Content 5</seg></tuv>\n </tu>\n </body>\n </tmx>' ) with open(__snake_case , 'w' ) as f: f.write(__snake_case ) return filename __UpperCAmelCase = [ {'col_1': '0', 'col_2': 0, 'col_3': 0.0}, {'col_1': '1', 'col_2': 1, 'col_3': 1.0}, {'col_1': '2', 'col_2': 2, 'col_3': 2.0}, {'col_1': '3', 'col_2': 3, 'col_3': 3.0}, ] __UpperCAmelCase = [ {'col_1': '4', 'col_2': 4, 'col_3': 4.0}, {'col_1': '5', 'col_2': 5, 'col_3': 5.0}, ] __UpperCAmelCase = { 'col_1': ['0', '1', '2', '3'], 'col_2': [0, 1, 2, 3], 'col_3': [0.0, 1.0, 2.0, 3.0], } __UpperCAmelCase = [ {'col_3': 0.0, 'col_1': '0', 'col_2': 0}, {'col_3': 1.0, 'col_1': '1', 'col_2': 1}, ] __UpperCAmelCase = [ {'col_1': 's0', 'col_2': 0, 'col_3': 0.0}, {'col_1': 's1', 'col_2': 1, 'col_3': 1.0}, {'col_1': 's2', 'col_2': 2, 'col_3': 2.0}, {'col_1': 's3', 'col_2': 3, 'col_3': 3.0}, ] @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return DATA_DICT_OF_LISTS @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : List[Any] = datasets.Dataset.from_dict(__snake_case ) UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.arrow' ) dataset.map(cache_file_name=__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset.sqlite' ) with contextlib.closing(sqlitea.connect(__snake_case ) ) as con: UpperCAmelCase_ : List[Any] = con.cursor() cur.execute('CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)' ) for item in DATA: cur.execute('INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)' , tuple(item.values() ) ) con.commit() return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.csv' ) with open(__snake_case , 'w' , newline='' ) as f: UpperCAmelCase_ : Tuple = csv.DictWriter(__snake_case , fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset2.csv' ) with open(__snake_case , 'w' , newline='' ) as f: UpperCAmelCase_ : Optional[Any] = csv.DictWriter(__snake_case , fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Any ): '''simple docstring''' import bza UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'dataset.csv.bz2' with open(__snake_case , 'rb' ) as f: UpperCAmelCase_ : int = f.read() # data = bytes(FILE_CONTENT, "utf-8") with bza.open(__snake_case , 'wb' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[str] , __snake_case : Tuple , __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Optional[int] , __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(csv_path.replace('.csv' , '.CSV' ) ) ) f.write(__snake_case , arcname=os.path.basename(csva_path.replace('.csv' , '.CSV' ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : int , __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.csv.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : int = str(tmp_path_factory.mktemp('data' ) / 'dataset.parquet' ) UpperCAmelCase_ : Dict = pa.schema( { 'col_1': pa.string(), 'col_2': pa.intaa(), 'col_3': pa.floataa(), } ) with open(__snake_case , 'wb' ) as f: UpperCAmelCase_ : List[Any] = pq.ParquetWriter(__snake_case , schema=__snake_case ) UpperCAmelCase_ : Any = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__snake_case ) )] for k in DATA[0]} , schema=__snake_case ) writer.write_table(__snake_case ) writer.close() return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) UpperCAmelCase_ : Optional[int] = {'data': DATA} with open(__snake_case , 'w' ) as f: json.dump(__snake_case , __snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) UpperCAmelCase_ : Tuple = {'data': DATA_DICT_OF_LISTS} with open(__snake_case , 'w' ) as f: json.dump(__snake_case , __snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] ): '''simple docstring''' UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : int = str(tmp_path_factory.mktemp('data' ) / 'dataset_312.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA_312: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset-str.jsonl' ) with open(__snake_case , 'w' ) as f: for item in DATA_STR: f.write(json.dumps(__snake_case ) + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : Dict ): '''simple docstring''' import gzip UpperCAmelCase_ : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt.gz' ) with open(__snake_case , 'rb' ) as orig_file: with gzip.open(__snake_case , 'wb' ) as zipped_file: zipped_file.writelines(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : int , __snake_case : Any ): '''simple docstring''' import gzip UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.gz' ) with open(__snake_case , 'rb' ) as orig_file: with gzip.open(__snake_case , 'wb' ) as zipped_file: zipped_file.writelines(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : Dict , __snake_case : Optional[int] ): '''simple docstring''' UpperCAmelCase_ : int = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Optional[Any] , __snake_case : str , __snake_case : Dict , __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : str = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('nested' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : Union[str, Any] , __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : Optional[int] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.jsonl.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple , __snake_case : str , __snake_case : Union[str, Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) f.add(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : Any , __snake_case : Any , __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.tar' with tarfile.TarFile(__snake_case , 'w' ) as f: f.add(__snake_case , arcname=os.path.join('nested' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Any = ['0', '1', '2', '3'] UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt' ) with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = ['0', '1', '2', '3'] UpperCAmelCase_ : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.txt' ) with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Tuple ): '''simple docstring''' UpperCAmelCase_ : Dict = ['0', '1', '2', '3'] UpperCAmelCase_ : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset.abc' with open(__snake_case , 'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any , __snake_case : Union[str, Any] , __snake_case : List[Any] ): '''simple docstring''' UpperCAmelCase_ : List[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.text.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict , __snake_case : str , __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.text.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) f.write(__snake_case , arcname=os.path.join('main_dir' , os.path.basename(__snake_case ) ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Union[str, Any] , __snake_case : str , __snake_case : Optional[int] ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = tmp_path_factory.mktemp('data' ) / 'dataset.ext.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename('unsupported.ext' ) ) f.write(__snake_case , arcname=os.path.basename('unsupported_2.ext' ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Dict ): '''simple docstring''' UpperCAmelCase_ : Tuple = '\n'.join(['First', 'Second\u2029with Unicode new line', 'Third'] ) UpperCAmelCase_ : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset_with_unicode_new_lines.txt' ) with open(__snake_case , 'w' , encoding='utf-8' ) as f: f.write(__snake_case ) return path @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return os.path.join('tests' , 'features' , 'data' , 'test_image_rgb.jpg' ) @pytest.fixture(scope='session' ) def lowercase__ ( ): '''simple docstring''' return os.path.join('tests' , 'features' , 'data' , 'test_audio_44100.wav' ) @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : str , __snake_case : List[str] ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.img.zip' with zipfile.ZipFile(__snake_case , 'w' ) as f: f.write(__snake_case , arcname=os.path.basename(__snake_case ) ) f.write(__snake_case , arcname=os.path.basename(__snake_case ).replace('.jpg' , '2.jpg' ) ) return path @pytest.fixture(scope='session' ) def lowercase__ ( __snake_case : Any ): '''simple docstring''' UpperCAmelCase_ : Optional[Any] = tmp_path_factory.mktemp('data_dir' ) (data_dir / "subdir").mkdir() with open(data_dir / 'subdir' / 'train.txt' , 'w' ) as f: f.write('foo\n' * 10 ) with open(data_dir / 'subdir' / 'test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) # hidden file with open(data_dir / 'subdir' / '.test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) # hidden directory (data_dir / ".subdir").mkdir() with open(data_dir / '.subdir' / 'train.txt' , 'w' ) as f: f.write('foo\n' * 10 ) with open(data_dir / '.subdir' / 'test.txt' , 'w' ) as f: f.write('bar\n' * 10 ) return data_dir
29
1
import subprocess import sys from transformers import BertConfig, BertModel, BertTokenizer, pipeline from transformers.testing_utils import TestCasePlus, require_torch class lowerCamelCase (_snake_case ): '''simple docstring''' @require_torch def __UpperCAmelCase ( self ) -> List[Any]: # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before # `transformers` is loaded, and it's too late for inside pytest - so we are changing it # while running an external program # python one-liner segments # this must be loaded before socket.socket is monkey-patched UpperCAmelCase_ : str = '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n ' UpperCAmelCase_ : Union[str, Any] = '\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n ' UpperCAmelCase_ : Optional[int] = '\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError("Offline mode is enabled, we shouldn\'t access internet")\nsocket.socket = offline_socket\n ' # Force fetching the files so that we can use the cache UpperCAmelCase_ : List[Any] = 'hf-internal-testing/tiny-random-bert' BertConfig.from_pretrained(_UpperCamelCase ) BertModel.from_pretrained(_UpperCamelCase ) BertTokenizer.from_pretrained(_UpperCamelCase ) pipeline(task='fill-mask' , model=_UpperCamelCase ) # baseline - just load from_pretrained with normal network UpperCAmelCase_ : Dict = [sys.executable, '-c', '\n'.join([load, run, mock] )] # should succeed UpperCAmelCase_ : str = self.get_env() # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files UpperCAmelCase_ : Tuple = '1' UpperCAmelCase_ : Any = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() ) @require_torch def __UpperCAmelCase ( self ) -> List[str]: # python one-liner segments # this must be loaded before socket.socket is monkey-patched UpperCAmelCase_ : Optional[int] = '\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n ' UpperCAmelCase_ : List[Any] = '\nmname = "hf-internal-testing/tiny-random-bert"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task="fill-mask", model=mname)\nprint("success")\n ' UpperCAmelCase_ : List[str] = '\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Faking flaky internet")\nsocket.socket = offline_socket\n ' # Force fetching the files so that we can use the cache UpperCAmelCase_ : Optional[int] = 'hf-internal-testing/tiny-random-bert' BertConfig.from_pretrained(_UpperCamelCase ) BertModel.from_pretrained(_UpperCamelCase ) BertTokenizer.from_pretrained(_UpperCamelCase ) pipeline(task='fill-mask' , model=_UpperCamelCase ) # baseline - just load from_pretrained with normal network UpperCAmelCase_ : str = [sys.executable, '-c', '\n'.join([load, run, mock] )] # should succeed UpperCAmelCase_ : Tuple = self.get_env() UpperCAmelCase_ : Union[str, Any] = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() ) @require_torch def __UpperCAmelCase ( self ) -> str: # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before # `transformers` is loaded, and it's too late for inside pytest - so we are changing it # while running an external program # python one-liner segments # this must be loaded before socket.socket is monkey-patched UpperCAmelCase_ : str = '\nfrom transformers import BertConfig, BertModel, BertTokenizer\n ' UpperCAmelCase_ : List[Any] = '\nmname = "hf-internal-testing/tiny-random-bert-sharded"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint("success")\n ' UpperCAmelCase_ : str = '\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError("Offline mode is enabled")\nsocket.socket = offline_socket\n ' # baseline - just load from_pretrained with normal network UpperCAmelCase_ : List[Any] = [sys.executable, '-c', '\n'.join([load, run] )] # should succeed UpperCAmelCase_ : str = self.get_env() UpperCAmelCase_ : str = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() ) # next emulate no network UpperCAmelCase_ : str = [sys.executable, '-c', '\n'.join([load, mock, run] )] # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this. # env["TRANSFORMERS_OFFLINE"] = "0" # result = subprocess.run(cmd, env=env, check=False, capture_output=True) # self.assertEqual(result.returncode, 1, result.stderr) # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files UpperCAmelCase_ : List[Any] = '1' UpperCAmelCase_ : int = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() ) @require_torch def __UpperCAmelCase ( self ) -> List[str]: UpperCAmelCase_ : Any = '\nfrom transformers import pipeline\n ' UpperCAmelCase_ : Optional[int] = '\nmname = "hf-internal-testing/tiny-random-bert"\npipe = pipeline(model=mname)\n ' UpperCAmelCase_ : Tuple = '\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error("Offline mode is enabled")\nsocket.socket = offline_socket\n ' UpperCAmelCase_ : str = self.get_env() UpperCAmelCase_ : Optional[Any] = '1' UpperCAmelCase_ : str = [sys.executable, '-c', '\n'.join([load, mock, run] )] UpperCAmelCase_ : List[Any] = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 1 , result.stderr ) self.assertIn( 'You cannot infer task automatically within `pipeline` when using offline mode' , result.stderr.decode().replace('\n' , '' ) , ) @require_torch def __UpperCAmelCase ( self ) -> str: UpperCAmelCase_ : Dict = '\nfrom transformers import AutoModel\n ' UpperCAmelCase_ : str = '\nmname = "hf-internal-testing/test_dynamic_model"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint("success")\n ' # baseline - just load from_pretrained with normal network UpperCAmelCase_ : Union[str, Any] = [sys.executable, '-c', '\n'.join([load, run] )] # should succeed UpperCAmelCase_ : Any = self.get_env() UpperCAmelCase_ : List[Any] = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() ) # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files UpperCAmelCase_ : Tuple = '1' UpperCAmelCase_ : Optional[Any] = subprocess.run(_UpperCamelCase , env=_UpperCamelCase , check=_UpperCamelCase , capture_output=_UpperCamelCase ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn('success' , result.stdout.decode() )
29
from __future__ import annotations def lowercase__ ( __snake_case : tuple[int, int] , __snake_case : int ): '''simple docstring''' UpperCAmelCase_ , UpperCAmelCase_ : Tuple = position UpperCAmelCase_ : str = [ (y + 1, x + 2), (y - 1, x + 2), (y + 1, x - 2), (y - 1, x - 2), (y + 2, x + 1), (y + 2, x - 1), (y - 2, x + 1), (y - 2, x - 1), ] UpperCAmelCase_ : Optional[Any] = [] for position in positions: UpperCAmelCase_ , UpperCAmelCase_ : Tuple = position if 0 <= y_test < n and 0 <= x_test < n: permissible_positions.append(__snake_case ) return permissible_positions def lowercase__ ( __snake_case : list[list[int]] ): '''simple docstring''' return not any(elem == 0 for row in board for elem in row ) def lowercase__ ( __snake_case : list[list[int]] , __snake_case : tuple[int, int] , __snake_case : int ): '''simple docstring''' if is_complete(__snake_case ): return True for position in get_valid_pos(__snake_case , len(__snake_case ) ): UpperCAmelCase_ , UpperCAmelCase_ : Any = position if board[y][x] == 0: UpperCAmelCase_ : Optional[Any] = curr + 1 if open_knight_tour_helper(__snake_case , __snake_case , curr + 1 ): return True UpperCAmelCase_ : List[Any] = 0 return False def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : str = [[0 for i in range(__snake_case )] for j in range(__snake_case )] for i in range(__snake_case ): for j in range(__snake_case ): UpperCAmelCase_ : Optional[Any] = 1 if open_knight_tour_helper(__snake_case , (i, j) , 1 ): return board UpperCAmelCase_ : List[Any] = 0 UpperCAmelCase_ : List[str] = F"Open Kight Tour cannot be performed on a board of size {n}" raise ValueError(__snake_case ) if __name__ == "__main__": import doctest doctest.testmod()
29
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = { 'configuration_timesformer': ['TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TimesformerConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST', 'TimesformerModel', 'TimesformerForVideoClassification', 'TimesformerPreTrainedModel', ] if TYPE_CHECKING: from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_timesformer import ( TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimesformerForVideoClassification, TimesformerModel, TimesformerPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
29
def lowercase__ ( __snake_case : int ): '''simple docstring''' UpperCAmelCase_ : list[list[int]] = [[0 for _ in range(__snake_case )] for _ in range(m + 1 )] for i in range(m + 1 ): UpperCAmelCase_ : Optional[Any] = 1 for n in range(m + 1 ): for k in range(1 , __snake_case ): memo[n][k] += memo[n][k - 1] if n - k > 0: memo[n][k] += memo[n - k - 1][k] return memo[m][m - 1] if __name__ == "__main__": import sys if len(sys.argv) == 1: try: __UpperCAmelCase = int(input('Enter a number: ').strip()) print(partition(n)) except ValueError: print('Please enter a number.') else: try: __UpperCAmelCase = int(sys.argv[1]) print(partition(n)) except ValueError: print('Please pass a number.')
29
1