Datasets:

infinityofspace

/

python_codestyles-single-500

like 0

'''simple docstring''' import copy import tempfile import unittest from huggingface_hub import HfFolder, delete_repo from parameterized import parameterized from requests.exceptions import HTTPError from transformers import AutoConfig, GenerationConfig from transformers.testing_utils import TOKEN, USER, is_staging_test class snake_case__ ( unittest.TestCase ): @parameterized.expand([(None,), ('foo.json',)] ) def A_ ( self : str , __a : Optional[Any] ) -> Dict: '''simple docstring''' __snake_case : Dict = GenerationConfig( do_sample=__a , temperature=0.7 , length_penalty=1.0 , bad_words_ids=[[1, 2, 3], [4, 5]] , ) with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__a , config_name=__a ) __snake_case : Optional[int] = GenerationConfig.from_pretrained(__a , config_name=__a ) # Checks parameters that were specified self.assertEqual(loaded_config.do_sample , __a ) self.assertEqual(loaded_config.temperature , 0.7 ) self.assertEqual(loaded_config.length_penalty , 1.0 ) self.assertEqual(loaded_config.bad_words_ids , [[1, 2, 3], [4, 5]] ) # Checks parameters that were not specified (defaults) self.assertEqual(loaded_config.top_k , 50 ) self.assertEqual(loaded_config.max_length , 20 ) self.assertEqual(loaded_config.max_time , __a ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : str = AutoConfig.from_pretrained('gpt2' ) __snake_case : Optional[int] = GenerationConfig.from_model_config(__a ) __snake_case : str = GenerationConfig() # The generation config has loaded a few non-default parameters from the model config self.assertNotEqual(__a , __a ) # One of those parameters is eos_token_id -- check if it matches self.assertNotEqual(generation_config_from_model.eos_token_id , default_generation_config.eos_token_id ) self.assertEqual(generation_config_from_model.eos_token_id , model_config.eos_token_id ) def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' __snake_case : Optional[int] = GenerationConfig() __snake_case : Any = { 'max_new_tokens': 1024, 'foo': 'bar', } __snake_case : Optional[Any] = copy.deepcopy(__a ) __snake_case : Tuple = generation_config.update(**__a ) # update_kwargs was not modified (no side effects) self.assertEqual(__a , __a ) # update_kwargs was used to update the config on valid attributes self.assertEqual(generation_config.max_new_tokens , 1024 ) # `.update()` returns a dictionary of unused kwargs self.assertEqual(__a , {'foo': 'bar'} ) def A_ ( self : Dict ) -> str: '''simple docstring''' __snake_case : int = GenerationConfig() __snake_case : Tuple = 'bar' with tempfile.TemporaryDirectory('test-generation-config' ) as tmp_dir: generation_config.save_pretrained(__a ) __snake_case : List[str] = GenerationConfig.from_pretrained(__a ) # update_kwargs was used to update the config on valid attributes self.assertEqual(new_config.foo , 'bar' ) __snake_case : List[str] = GenerationConfig.from_model_config(__a ) assert not hasattr(__a , 'foo' ) # no new kwargs should be initialized if from config def A_ ( self : Tuple ) -> str: '''simple docstring''' __snake_case : List[Any] = GenerationConfig() self.assertEqual(default_config.temperature , 1.0 ) self.assertEqual(default_config.do_sample , __a ) self.assertEqual(default_config.num_beams , 1 ) __snake_case : List[Any] = GenerationConfig( do_sample=__a , temperature=0.7 , length_penalty=1.0 , bad_words_ids=[[1, 2, 3], [4, 5]] , ) self.assertEqual(config.temperature , 0.7 ) self.assertEqual(config.do_sample , __a ) self.assertEqual(config.num_beams , 1 ) with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__a ) __snake_case : List[str] = GenerationConfig.from_pretrained(__a , temperature=1.0 ) self.assertEqual(loaded_config.temperature , 1.0 ) self.assertEqual(loaded_config.do_sample , __a ) self.assertEqual(loaded_config.num_beams , 1 ) # default value @is_staging_test class snake_case__ ( unittest.TestCase ): @classmethod def A_ ( cls : List[str] ) -> Optional[int]: '''simple docstring''' __snake_case : List[str] = TOKEN HfFolder.save_token(__a ) @classmethod def A_ ( cls : Dict ) -> List[Any]: '''simple docstring''' try: delete_repo(token=cls._token , repo_id='test-generation-config' ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id='valid_org/test-generation-config-org' ) except HTTPError: pass def A_ ( self : List[Any] ) -> Dict: '''simple docstring''' __snake_case : Optional[Any] = GenerationConfig( do_sample=__a , temperature=0.7 , length_penalty=1.0 , ) config.push_to_hub('test-generation-config' , use_auth_token=self._token ) __snake_case : str = GenerationConfig.from_pretrained(f'''{USER}/test-generation-config''' ) for k, v in config.to_dict().items(): if k != "transformers_version": self.assertEqual(__a , getattr(__a , __a ) ) # Reset repo delete_repo(token=self._token , repo_id='test-generation-config' ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained( __a , repo_id='test-generation-config' , push_to_hub=__a , use_auth_token=self._token ) __snake_case : List[str] = GenerationConfig.from_pretrained(f'''{USER}/test-generation-config''' ) for k, v in config.to_dict().items(): if k != "transformers_version": self.assertEqual(__a , getattr(__a , __a ) ) def A_ ( self : Optional[Any] ) -> Optional[int]: '''simple docstring''' __snake_case : Optional[int] = GenerationConfig( do_sample=__a , temperature=0.7 , length_penalty=1.0 , ) config.push_to_hub('valid_org/test-generation-config-org' , use_auth_token=self._token ) __snake_case : Dict = GenerationConfig.from_pretrained('valid_org/test-generation-config-org' ) for k, v in config.to_dict().items(): if k != "transformers_version": self.assertEqual(__a , getattr(__a , __a ) ) # Reset repo delete_repo(token=self._token , repo_id='valid_org/test-generation-config-org' ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained( __a , repo_id='valid_org/test-generation-config-org' , push_to_hub=__a , use_auth_token=self._token ) __snake_case : Dict = GenerationConfig.from_pretrained('valid_org/test-generation-config-org' ) for k, v in config.to_dict().items(): if k != "transformers_version": self.assertEqual(__a , getattr(__a , __a ) )

'''simple docstring''' from tempfile import TemporaryDirectory from unittest import TestCase from unittest.mock import MagicMock, patch from transformers import AutoModel, TFAutoModel from transformers.onnx import FeaturesManager from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch @require_torch @require_tf class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : List[Any] ) -> int: '''simple docstring''' __snake_case : Optional[int] = SMALL_MODEL_IDENTIFIER __snake_case : str = 'pt' __snake_case : Union[str, Any] = 'tf' def A_ ( self : Dict , __a : Tuple ) -> Dict: '''simple docstring''' __snake_case : Optional[int] = AutoModel.from_pretrained(self.test_model ) model_pt.save_pretrained(__a ) def A_ ( self : Any , __a : Optional[Any] ) -> Dict: '''simple docstring''' __snake_case : Union[str, Any] = TFAutoModel.from_pretrained(self.test_model , from_pt=__a ) model_tf.save_pretrained(__a ) def A_ ( self : Any ) -> Tuple: '''simple docstring''' __snake_case : Tuple = 'mock_framework' # Framework provided - return whatever the user provides __snake_case : int = FeaturesManager.determine_framework(self.test_model , __a ) self.assertEqual(__a , __a ) # Local checkpoint and framework provided - return provided framework # PyTorch checkpoint with TemporaryDirectory() as local_pt_ckpt: self._setup_pt_ckpt(__a ) __snake_case : List[Any] = FeaturesManager.determine_framework(__a , __a ) self.assertEqual(__a , __a ) # TensorFlow checkpoint with TemporaryDirectory() as local_tf_ckpt: self._setup_tf_ckpt(__a ) __snake_case : Tuple = FeaturesManager.determine_framework(__a , __a ) self.assertEqual(__a , __a ) def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' # PyTorch checkpoint with TemporaryDirectory() as local_pt_ckpt: self._setup_pt_ckpt(__a ) __snake_case : Tuple = FeaturesManager.determine_framework(__a ) self.assertEqual(__a , self.framework_pt ) # TensorFlow checkpoint with TemporaryDirectory() as local_tf_ckpt: self._setup_tf_ckpt(__a ) __snake_case : Union[str, Any] = FeaturesManager.determine_framework(__a ) self.assertEqual(__a , self.framework_tf ) # Invalid local checkpoint with TemporaryDirectory() as local_invalid_ckpt: with self.assertRaises(__a ): __snake_case : Optional[int] = FeaturesManager.determine_framework(__a ) def A_ ( self : Any ) -> List[Any]: '''simple docstring''' __snake_case : Union[str, Any] = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ): __snake_case : int = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_pt ) # PyTorch not in environment -> use TensorFlow __snake_case : Tuple = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_torch_available' , __a ): __snake_case : Dict = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_tf ) # Both in environment -> use PyTorch __snake_case : Optional[Any] = MagicMock(return_value=__a ) __snake_case : Tuple = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ), patch( 'transformers.onnx.features.is_torch_available' , __a ): __snake_case : Dict = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_pt ) # Both not in environment -> raise error __snake_case : str = MagicMock(return_value=__a ) __snake_case : List[Any] = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ), patch( 'transformers.onnx.features.is_torch_available' , __a ): with self.assertRaises(__a ): __snake_case : Tuple = FeaturesManager.determine_framework(self.test_model )

'''simple docstring''' from __future__ import annotations import inspect import unittest from typing import List, Tuple from transformers import RegNetConfig from transformers.testing_utils import require_tf, require_vision, slow from transformers.utils import cached_property, is_tf_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class snake_case__ : def __init__( self : str , __a : Optional[int] , __a : str=3 , __a : Optional[int]=32 , __a : Optional[Any]=3 , __a : Optional[int]=10 , __a : List[Any]=[10, 20, 30, 40] , __a : Dict=[1, 1, 2, 1] , __a : Tuple=True , __a : Union[str, Any]=True , __a : Dict="relu" , __a : Any=3 , __a : str=None , ) -> int: '''simple docstring''' __snake_case : str = parent __snake_case : Union[str, Any] = batch_size __snake_case : List[str] = image_size __snake_case : Tuple = num_channels __snake_case : Any = embeddings_size __snake_case : List[Any] = hidden_sizes __snake_case : str = depths __snake_case : int = is_training __snake_case : List[str] = use_labels __snake_case : Tuple = hidden_act __snake_case : Any = num_labels __snake_case : List[str] = scope __snake_case : Dict = len(__a ) def A_ ( self : int ) -> Optional[int]: '''simple docstring''' __snake_case : Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __snake_case : str = None if self.use_labels: __snake_case : Optional[int] = ids_tensor([self.batch_size] , self.num_labels ) __snake_case : Tuple = self.get_config() return config, pixel_values, labels def A_ ( self : Optional[Any] ) -> Dict: '''simple docstring''' return RegNetConfig( num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , ) def A_ ( self : Optional[Any] , __a : Any , __a : Union[str, Any] , __a : Union[str, Any] ) -> str: '''simple docstring''' __snake_case : Union[str, Any] = TFRegNetModel(config=__a ) __snake_case : Union[str, Any] = model(__a , training=__a ) # 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 // 32, self.image_size // 32) , ) def A_ ( self : List[str] , __a : Dict , __a : Union[str, Any] , __a : Optional[Any] ) -> Tuple: '''simple docstring''' __snake_case : List[str] = self.num_labels __snake_case : List[Any] = TFRegNetForImageClassification(__a ) __snake_case : Optional[int] = model(__a , labels=__a , training=__a ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def A_ ( self : int ) -> List[Any]: '''simple docstring''' __snake_case : List[Any] = self.prepare_config_and_inputs() __snake_case : Any = config_and_inputs __snake_case : Any = {'pixel_values': pixel_values} return config, inputs_dict @require_tf class snake_case__ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else () A__ = ( {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification} if is_tf_available() else {} ) A__ = False A__ = False A__ = False A__ = False A__ = False def A_ ( self : List[str] ) -> Tuple: '''simple docstring''' __snake_case : str = TFRegNetModelTester(self ) __snake_case : Optional[Any] = ConfigTester(self , config_class=__a , has_text_modality=__a ) def A_ ( self : Optional[int] ) -> Tuple: '''simple docstring''' return @unittest.skip(reason='RegNet does not use inputs_embeds' ) def A_ ( self : List[Any] ) -> List[str]: '''simple docstring''' pass @unittest.skipIf( not is_tf_available() or len(tf.config.list_physical_devices('GPU' ) ) == 0 , reason='TF does not support backprop for grouped convolutions on CPU.' , ) @slow def A_ ( self : List[str] ) -> Any: '''simple docstring''' super().test_keras_fit() @unittest.skip(reason='RegNet does not support input and output embeddings' ) def A_ ( self : str ) -> str: '''simple docstring''' pass def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' __snake_case : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __snake_case : Tuple = model_class(__a ) __snake_case : List[str] = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __snake_case : Optional[int] = [*signature.parameters.keys()] __snake_case : Any = ['pixel_values'] self.assertListEqual(arg_names[:1] , __a ) def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__a ) def A_ ( self : Optional[Any] ) -> Dict: '''simple docstring''' def check_hidden_states_output(__a : List[str] , __a : List[Any] , __a : Optional[Any] ): __snake_case : List[Any] = model_class(__a ) __snake_case : int = model(**self._prepare_for_class(__a , __a ) , training=__a ) __snake_case : Optional[int] = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states __snake_case : List[Any] = self.model_tester.num_stages self.assertEqual(len(__a ) , expected_num_stages + 1 ) # RegNet'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 // 2, self.model_tester.image_size // 2] , ) __snake_case : int = self.model_tester.prepare_config_and_inputs_for_common() __snake_case : Optional[int] = ['basic', 'bottleneck'] for model_class in self.all_model_classes: for layer_type in layers_type: __snake_case : List[str] = layer_type __snake_case : Optional[Any] = True check_hidden_states_output(__a , __a , __a ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __snake_case : str = True check_hidden_states_output(__a , __a , __a ) def A_ ( self : Tuple ) -> List[str]: '''simple docstring''' __snake_case : int = self.model_tester.prepare_config_and_inputs_for_common() def check_equivalence(__a : Optional[int] , __a : Tuple , __a : Union[str, Any] , __a : List[Any]={} ): __snake_case : Optional[Any] = model(__a , return_dict=__a , **__a ) __snake_case : Tuple = model(__a , return_dict=__a , **__a ).to_tuple() def recursive_check(__a : Tuple , __a : Optional[int] ): if isinstance(__a , (List, Tuple) ): for tuple_iterable_value, dict_iterable_value in zip(__a , __a ): recursive_check(__a , __a ) elif tuple_object is None: return else: self.assertTrue( all(tf.equal(__a , __a ) ) , msg=( 'Tuple and dict output are not equal. Difference:' f''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object ) )}''' ) , ) recursive_check(__a , __a ) for model_class in self.all_model_classes: __snake_case : List[str] = model_class(__a ) __snake_case : List[Any] = self._prepare_for_class(__a , __a ) __snake_case : str = self._prepare_for_class(__a , __a ) check_equivalence(__a , __a , __a ) __snake_case : List[str] = self._prepare_for_class(__a , __a , return_labels=__a ) __snake_case : Tuple = self._prepare_for_class(__a , __a , return_labels=__a ) check_equivalence(__a , __a , __a ) __snake_case : Union[str, Any] = self._prepare_for_class(__a , __a ) __snake_case : Union[str, Any] = self._prepare_for_class(__a , __a ) check_equivalence(__a , __a , __a , {'output_hidden_states': True} ) __snake_case : Optional[Any] = self._prepare_for_class(__a , __a , return_labels=__a ) __snake_case : Any = self._prepare_for_class(__a , __a , return_labels=__a ) check_equivalence(__a , __a , __a , {'output_hidden_states': True} ) def A_ ( self : str ) -> Optional[int]: '''simple docstring''' __snake_case : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__a ) @slow def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __snake_case : Tuple = TFRegNetModel.from_pretrained(__a ) self.assertIsNotNone(__a ) def a_ ( ) -> Optional[int]: __snake_case : Any = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_tf @require_vision class snake_case__ ( unittest.TestCase ): @cached_property def A_ ( self : List[Any] ) -> str: '''simple docstring''' return ( AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def A_ ( self : Optional[Any] ) -> Optional[int]: '''simple docstring''' __snake_case : List[str] = TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) __snake_case : str = self.default_image_processor __snake_case : Union[str, Any] = prepare_img() __snake_case : str = image_processor(images=__a , return_tensors='tf' ) # forward pass __snake_case : Optional[int] = model(**__a , training=__a ) # verify the logits __snake_case : List[str] = tf.TensorShape((1, 1000) ) self.assertEqual(outputs.logits.shape , __a ) __snake_case : List[str] = tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6] ) tf.debugging.assert_near(outputs.logits[0, :3] , __a , atol=1e-4 )

'''simple docstring''' import os import unittest from transformers import BatchEncoding from transformers.models.bert.tokenization_bert import ( BasicTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.models.prophetnet.tokenization_prophetnet import VOCAB_FILES_NAMES, ProphetNetTokenizer from transformers.testing_utils import require_torch, slow from ...test_tokenization_common import TokenizerTesterMixin class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ProphetNetTokenizer A__ = False def A_ ( self : Optional[int] ) -> Dict: '''simple docstring''' super().setUp() __snake_case : Dict = [ '[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest', ] __snake_case : Any = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def A_ ( self : int , __a : Union[str, Any] ) -> List[str]: '''simple docstring''' __snake_case : Optional[int] = 'UNwant\u00E9d,running' __snake_case : List[str] = 'unwanted, running' return input_text, output_text def A_ ( self : Union[str, Any] ) -> str: '''simple docstring''' __snake_case : Dict = self.tokenizer_class(self.vocab_file ) __snake_case : List[str] = tokenizer.tokenize('UNwant\u00E9d,running' ) self.assertListEqual(__a , ['un', '##want', '##ed', ',', 'runn', '##ing'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__a ) , [9, 6, 7, 12, 10, 11] ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : List[str] = BasicTokenizer() self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz' ) , ['ah', '\u535A', '\u63A8', 'zz'] ) def A_ ( self : Union[str, Any] ) -> str: '''simple docstring''' __snake_case : Optional[int] = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['hello', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' __snake_case : List[Any] = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hällo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['h\u00E9llo'] ) def A_ ( self : int ) -> Any: '''simple docstring''' __snake_case : int = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : Optional[int] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Union[str, Any] = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Dict = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Any ) -> List[str]: '''simple docstring''' __snake_case : str = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HäLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Union[str, Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : List[Any] = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HaLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Optional[int] ) -> List[str]: '''simple docstring''' __snake_case : Optional[Any] = BasicTokenizer(do_lower_case=__a , never_split=['[UNK]'] ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? [UNK]' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'] ) def A_ ( self : Optional[int] ) -> List[Any]: '''simple docstring''' __snake_case : Any = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing'] __snake_case : List[Any] = {} for i, token in enumerate(__a ): __snake_case : List[str] = i __snake_case : Any = WordpieceTokenizer(vocab=__a , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('unwanted running' ) , ['un', '##want', '##ed', 'runn', '##ing'] ) self.assertListEqual(tokenizer.tokenize('unwantedX running' ) , ['[UNK]', 'runn', '##ing'] ) @require_torch def A_ ( self : Union[str, Any] ) -> Tuple: '''simple docstring''' __snake_case : Optional[Any] = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' ) __snake_case : int = ['A long paragraph for summarization.', 'Another paragraph for summarization.'] __snake_case : str = [1037, 2146, 20423, 2005, 7680, 7849, 3989, 1012, 102] __snake_case : Union[str, Any] = tokenizer(__a , padding=__a , return_tensors='pt' ) self.assertIsInstance(__a , __a ) __snake_case : int = list(batch.input_ids.numpy()[0] ) self.assertListEqual(__a , __a ) self.assertEqual((2, 9) , batch.input_ids.shape ) self.assertEqual((2, 9) , batch.attention_mask.shape ) def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' self.assertTrue(_is_whitespace(' ' ) ) self.assertTrue(_is_whitespace('\t' ) ) self.assertTrue(_is_whitespace('\r' ) ) self.assertTrue(_is_whitespace('\n' ) ) self.assertTrue(_is_whitespace('\u00A0' ) ) self.assertFalse(_is_whitespace('A' ) ) self.assertFalse(_is_whitespace('-' ) ) def A_ ( self : Dict ) -> Optional[Any]: '''simple docstring''' self.assertTrue(_is_control('\u0005' ) ) self.assertFalse(_is_control('A' ) ) self.assertFalse(_is_control(' ' ) ) self.assertFalse(_is_control('\t' ) ) self.assertFalse(_is_control('\r' ) ) def A_ ( self : List[Any] ) -> int: '''simple docstring''' self.assertTrue(_is_punctuation('-' ) ) self.assertTrue(_is_punctuation('$' ) ) self.assertTrue(_is_punctuation('`' ) ) self.assertTrue(_is_punctuation('.' ) ) self.assertFalse(_is_punctuation('A' ) ) self.assertFalse(_is_punctuation(' ' ) ) @slow def A_ ( self : str ) -> Optional[int]: '''simple docstring''' __snake_case : str = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' ) __snake_case : Optional[int] = tokenizer.encode('sequence builders' , add_special_tokens=__a ) __snake_case : Optional[int] = tokenizer.encode('multi-sequence build' , add_special_tokens=__a ) __snake_case : Optional[Any] = tokenizer.build_inputs_with_special_tokens(__a ) __snake_case : List[Any] = tokenizer.build_inputs_with_special_tokens(__a , __a ) assert encoded_sentence == text + [102] assert encoded_pair == text + [102] + text_a + [102]

'''simple docstring''' import argparse from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta from transformers.utils import logging logging.set_verbosity_info() def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : int ,_UpperCAmelCase : int ) -> Any: # Initialise PyTorch model __snake_case : List[str] = TaConfig.from_json_file(_UpperCAmelCase ) print(f'''Building PyTorch model from configuration: {config}''' ) __snake_case : Optional[Any] = TaForConditionalGeneration(_UpperCAmelCase ) # Load weights from tf checkpoint load_tf_weights_in_ta(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) # Save pytorch-model print(f'''Save PyTorch model to {pytorch_dump_path}''' ) model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": A__ : str = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture.''' ), ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) A__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available A__ : Optional[Any] = { '''configuration_nllb_moe''': [ '''NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NllbMoeConfig''', ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ '''NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST''', '''NllbMoeForConditionalGeneration''', '''NllbMoeModel''', '''NllbMoePreTrainedModel''', '''NllbMoeTop2Router''', '''NllbMoeSparseMLP''', ] if TYPE_CHECKING: from .configuration_nllb_moe import ( NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP, NllbMoeConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nllb_moe import ( NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST, NllbMoeForConditionalGeneration, NllbMoeModel, NllbMoePreTrainedModel, NllbMoeSparseMLP, NllbMoeTopaRouter, ) else: import sys A__ : str = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class snake_case__ : A__ = 42 A__ = None A__ = None A__ : List[str] = namedtuple('''CoinsDistribResult''', '''moves excess''') def a_ ( _UpperCAmelCase : TreeNode | None ) -> int: if root is None: return 0 # Validation def count_nodes(_UpperCAmelCase : TreeNode | None ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(_UpperCAmelCase : TreeNode | None ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(_UpperCAmelCase ) != count_coins(_UpperCAmelCase ): raise ValueError('The nodes number should be same as the number of coins' ) # Main calculation def get_distrib(_UpperCAmelCase : TreeNode | None ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 ,1 ) __snake_case : Tuple = get_distrib(node.left ) __snake_case : List[Any] = get_distrib(node.right ) __snake_case : List[Any] = 1 - left_distrib_excess __snake_case : Any = 1 - right_distrib_excess __snake_case : Union[str, Any] = ( left_distrib_moves + right_distrib_moves + abs(_UpperCAmelCase ) + abs(_UpperCAmelCase ) ) __snake_case : Optional[Any] = node.data - coins_to_left - coins_to_right return CoinsDistribResult(_UpperCAmelCase ,_UpperCAmelCase ) return get_distrib(_UpperCAmelCase )[0] if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' def a_ ( _UpperCAmelCase : int ) -> list: # bit count represents no. of bits in the gray code if bit_count < 0: raise ValueError('The given input must be positive' ) # get the generated string sequence __snake_case : Optional[Any] = gray_code_sequence_string(_UpperCAmelCase ) # # convert them to integers for i in range(len(_UpperCAmelCase ) ): __snake_case : Optional[Any] = int(sequence[i] ,2 ) return sequence def a_ ( _UpperCAmelCase : int ) -> list: # The approach is a recursive one # Base case achieved when either n = 0 or n=1 if bit_count == 0: return ["0"] if bit_count == 1: return ["0", "1"] __snake_case : Dict = 1 << bit_count # defines the length of the sequence # 1<< n is equivalent to 2^n # recursive answer will generate answer for n-1 bits __snake_case : Dict = gray_code_sequence_string(bit_count - 1 ) __snake_case : Any = [] # append 0 to first half of the smaller sequence generated for i in range(seq_len // 2 ): __snake_case : str = '0' + smaller_sequence[i] sequence.append(_UpperCAmelCase ) # append 1 to second half ... start from the end of the list for i in reversed(range(seq_len // 2 ) ): __snake_case : Any = '1' + smaller_sequence[i] sequence.append(_UpperCAmelCase ) return sequence if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' import argparse import torch from transformers import ( UniSpeechSatConfig, UniSpeechSatForAudioFrameClassification, UniSpeechSatForSequenceClassification, UniSpeechSatForXVector, WavaVecaFeatureExtractor, logging, ) logging.set_verbosity_info() A__ : Union[str, Any] = logging.get_logger(__name__) def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Dict ,_UpperCAmelCase : Any ) -> int: __snake_case : List[Any] = UniSpeechSatForSequenceClassification.from_pretrained(_UpperCAmelCase ,config=_UpperCAmelCase ) __snake_case : List[str] = downstream_dict['projector.weight'] __snake_case : int = downstream_dict['projector.bias'] __snake_case : str = downstream_dict['model.post_net.linear.weight'] __snake_case : Tuple = downstream_dict['model.post_net.linear.bias'] return model def a_ ( _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : Any ,_UpperCAmelCase : List[str] ) -> str: __snake_case : List[Any] = UniSpeechSatForAudioFrameClassification.from_pretrained(_UpperCAmelCase ,config=_UpperCAmelCase ) __snake_case : Optional[Any] = downstream_dict['model.linear.weight'] __snake_case : Union[str, Any] = downstream_dict['model.linear.bias'] return model def a_ ( _UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : List[str] ,_UpperCAmelCase : Optional[int] ) -> Tuple: __snake_case : Dict = UniSpeechSatForXVector.from_pretrained(_UpperCAmelCase ,config=_UpperCAmelCase ) __snake_case : List[Any] = downstream_dict['connector.weight'] __snake_case : int = downstream_dict['connector.bias'] for i, kernel_size in enumerate(hf_config.tdnn_kernel ): __snake_case : List[str] = downstream_dict[ f'''model.framelevel_feature_extractor.module.{i}.kernel.weight''' ] __snake_case : int = downstream_dict[f'''model.framelevel_feature_extractor.module.{i}.kernel.bias'''] __snake_case : Union[str, Any] = downstream_dict['model.utterancelevel_feature_extractor.linear1.weight'] __snake_case : Any = downstream_dict['model.utterancelevel_feature_extractor.linear1.bias'] __snake_case : Union[str, Any] = downstream_dict['model.utterancelevel_feature_extractor.linear2.weight'] __snake_case : Tuple = downstream_dict['model.utterancelevel_feature_extractor.linear2.bias'] __snake_case : int = downstream_dict['objective.W'] return model @torch.no_grad() def a_ ( _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : List[str] ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Optional[int] ) -> Union[str, Any]: __snake_case : int = torch.load(_UpperCAmelCase ,map_location='cpu' ) __snake_case : Union[str, Any] = checkpoint['Downstream'] __snake_case : List[Any] = UniSpeechSatConfig.from_pretrained(_UpperCAmelCase ) __snake_case : List[Any] = WavaVecaFeatureExtractor.from_pretrained( _UpperCAmelCase ,return_attention_mask=_UpperCAmelCase ,do_normalize=_UpperCAmelCase ) __snake_case : Any = hf_config.architectures[0] if arch.endswith('ForSequenceClassification' ): __snake_case : Optional[Any] = convert_classification(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) elif arch.endswith('ForAudioFrameClassification' ): __snake_case : Optional[int] = convert_diarization(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) elif arch.endswith('ForXVector' ): __snake_case : Tuple = convert_xvector(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) else: raise NotImplementedError(f'''S3PRL weights conversion is not supported for {arch}''' ) if hf_config.use_weighted_layer_sum: __snake_case : Optional[Any] = checkpoint['Featurizer']['weights'] hf_feature_extractor.save_pretrained(_UpperCAmelCase ) hf_model.save_pretrained(_UpperCAmelCase ) if __name__ == "__main__": A__ : Tuple = argparse.ArgumentParser() parser.add_argument( '''--base_model_name''', default=None, type=str, help='''Name of the huggingface pretrained base model.''' ) parser.add_argument('''--config_path''', default=None, type=str, help='''Path to the huggingface classifier config.''') parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to the s3prl checkpoint.''') parser.add_argument('''--model_dump_path''', default=None, type=str, help='''Path to the final converted model.''') A__ : str = parser.parse_args() convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)

'''simple docstring''' import json import os import shutil import tempfile import unittest import numpy as np from transformers import BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer from transformers.testing_utils import require_tokenizers, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor @require_tokenizers @require_vision class snake_case__ ( unittest.TestCase ): def A_ ( self : int ) -> List[Any]: '''simple docstring''' __snake_case : Any = tempfile.mkdtemp() # fmt: off __snake_case : List[str] = ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest'] # fmt: on __snake_case : Any = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) __snake_case : List[str] = { 'do_resize': True, 'size': {'height': 18, 'width': 18}, 'do_normalize': True, 'image_mean': [0.5, 0.5, 0.5], 'image_std': [0.5, 0.5, 0.5], } __snake_case : Optional[Any] = os.path.join(self.tmpdirname , __a ) with open(self.image_processor_file , 'w' , encoding='utf-8' ) as fp: json.dump(__a , __a ) def A_ ( self : Optional[int] , **__a : Dict ) -> int: '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **__a ) def A_ ( self : int , **__a : Dict ) -> Tuple: '''simple docstring''' return ViTImageProcessor.from_pretrained(self.tmpdirname , **__a ) def A_ ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' shutil.rmtree(self.tmpdirname ) def A_ ( self : str ) -> List[str]: '''simple docstring''' __snake_case : Optional[Any] = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta )] __snake_case : List[str] = [Image.fromarray(np.moveaxis(__a , 0 , -1 ) ) for x in image_inputs] return image_inputs def A_ ( self : List[str] ) -> Optional[int]: '''simple docstring''' __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Dict = self.get_image_processor() __snake_case : Any = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) processor.save_pretrained(self.tmpdirname ) __snake_case : Any = VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() ) self.assertIsInstance(processor.image_processor , __a ) def A_ ( self : str ) -> Optional[int]: '''simple docstring''' __snake_case : Optional[Any] = VisionTextDualEncoderProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) __snake_case : Optional[Any] = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)' ) __snake_case : Tuple = self.get_image_processor(do_normalize=__a , padding_value=1.0 ) __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=__a , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , __a ) def A_ ( self : Optional[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Tuple = self.get_image_processor() __snake_case : int = self.get_tokenizer() __snake_case : str = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : int = self.prepare_image_inputs() __snake_case : List[str] = image_processor(__a , return_tensors='np' ) __snake_case : List[str] = processor(images=__a , return_tensors='np' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def A_ ( self : Optional[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Dict = self.get_image_processor() __snake_case : int = self.get_tokenizer() __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : Optional[int] = 'lower newer' __snake_case : Dict = processor(text=__a ) __snake_case : List[Any] = tokenizer(__a ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Dict = self.get_image_processor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : List[Any] = 'lower newer' __snake_case : Optional[Any] = self.prepare_image_inputs() __snake_case : Union[str, Any] = processor(text=__a , images=__a ) self.assertListEqual(list(inputs.keys() ) , ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values'] ) # test if it raises when no input is passed with self.assertRaises(__a ): processor() def A_ ( self : Tuple ) -> Any: '''simple docstring''' __snake_case : Union[str, Any] = self.get_image_processor() __snake_case : Any = self.get_tokenizer() __snake_case : Dict = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __snake_case : int = processor.batch_decode(__a ) __snake_case : Optional[Any] = tokenizer.batch_decode(__a ) self.assertListEqual(__a , __a ) def A_ ( self : Optional[int] ) -> Optional[Any]: '''simple docstring''' __snake_case : List[str] = self.get_image_processor() __snake_case : Dict = self.get_tokenizer() __snake_case : Dict = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : Union[str, Any] = 'lower newer' __snake_case : Tuple = self.prepare_image_inputs() __snake_case : Union[str, Any] = processor(text=__a , images=__a ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names )

'''simple docstring''' import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def a_ ( *_UpperCAmelCase : Any ,_UpperCAmelCase : Optional[Union[Dict, Any]] = None ,_UpperCAmelCase : str=True ,_UpperCAmelCase : str=2 ) -> Optional[int]: from .. import __version__ __snake_case : Union[str, Any] = take_from __snake_case : List[str] = () if not isinstance(args[0] ,_UpperCAmelCase ): __snake_case : List[str] = (args,) for attribute, version_name, message in args: if version.parse(version.parse(_UpperCAmelCase ).base_version ) >= version.parse(_UpperCAmelCase ): raise ValueError( f'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' f''' version {__version__} is >= {version_name}''' ) __snake_case : str = None if isinstance(_UpperCAmelCase ,_UpperCAmelCase ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(_UpperCAmelCase ),) __snake_case : str = f'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(_UpperCAmelCase ,_UpperCAmelCase ): values += (getattr(_UpperCAmelCase ,_UpperCAmelCase ),) __snake_case : Optional[int] = f'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Optional[Any] = f'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : List[str] = warning + ' ' if standard_warn else '' warnings.warn(warning + message ,_UpperCAmelCase ,stacklevel=_UpperCAmelCase ) if isinstance(_UpperCAmelCase ,_UpperCAmelCase ) and len(_UpperCAmelCase ) > 0: __snake_case : Optional[int] = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : Union[str, Any] = call_frame.filename __snake_case : Any = call_frame.lineno __snake_case : Tuple = call_frame.function __snake_case : Any = next(iter(deprecated_kwargs.items() ) ) raise TypeError(f'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(_UpperCAmelCase ) == 0: return elif len(_UpperCAmelCase ) == 1: return values[0] return values

'''simple docstring''' import argparse import json from collections import OrderedDict import torch from huggingface_hub import cached_download, hf_hub_url from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification def a_ ( _UpperCAmelCase : List[Any] ) -> Tuple: __snake_case : str = [] 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 a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Optional[int] ) -> List[str]: __snake_case : 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 a_ ( _UpperCAmelCase : Union[str, Any] ) -> Dict: __snake_case : Union[str, Any] = [] token.append((f'''cvt.encoder.stages.{idx}.cls_token''', 'stage2.cls_token') ) return token def a_ ( ) -> Optional[Any]: __snake_case : 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 a_ ( _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : Any ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Optional[Any] ) -> Tuple: __snake_case : List[str] = 'imagenet-1k-id2label.json' __snake_case : Dict = 10_00 __snake_case : Union[str, Any] = 'huggingface/label-files' __snake_case : str = num_labels __snake_case : str = json.load(open(cached_download(hf_hub_url(_UpperCAmelCase ,_UpperCAmelCase ,repo_type='dataset' ) ) ,'r' ) ) __snake_case : Tuple = {int(_UpperCAmelCase ): v for k, v in idalabel.items()} __snake_case : Optional[Any] = idalabel __snake_case : str = {v: k for k, v in idalabel.items()} __snake_case : Dict = CvtConfig(num_labels=_UpperCAmelCase ,idalabel=_UpperCAmelCase ,labelaid=_UpperCAmelCase ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit('/' ,1 )[-1][4:6] == "13": __snake_case : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit('/' ,1 )[-1][4:6] == "21": __snake_case : str = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: __snake_case : Dict = [2, 2, 20] __snake_case : Any = [3, 12, 16] __snake_case : Tuple = [1_92, 7_68, 10_24] __snake_case : str = CvtForImageClassification(_UpperCAmelCase ) __snake_case : List[Any] = AutoImageProcessor.from_pretrained('facebook/convnext-base-224-22k-1k' ) __snake_case : int = image_size __snake_case : int = torch.load(_UpperCAmelCase ,map_location=torch.device('cpu' ) ) __snake_case : List[Any] = OrderedDict() __snake_case : Union[str, Any] = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: __snake_case : Optional[Any] = list_of_state_dict + cls_token(_UpperCAmelCase ) __snake_case : Tuple = list_of_state_dict + embeddings(_UpperCAmelCase ) for cnt in range(config.depth[idx] ): __snake_case : Optional[int] = list_of_state_dict + attention(_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : str = list_of_state_dict + final() for gg in list_of_state_dict: print(_UpperCAmelCase ) for i in range(len(_UpperCAmelCase ) ): __snake_case : List[str] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(_UpperCAmelCase ) model.save_pretrained(_UpperCAmelCase ) image_processor.save_pretrained(_UpperCAmelCase ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": A__ : Dict = 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_8_4, 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.''' ) A__ : Tuple = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)

'''simple docstring''' import os import re import sys import traceback import warnings from pathlib import Path from typing import Dict, Optional, Union from uuid import uuida from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami from huggingface_hub.file_download import REGEX_COMMIT_HASH from huggingface_hub.utils import ( EntryNotFoundError, RepositoryNotFoundError, RevisionNotFoundError, is_jinja_available, ) from packaging import version from requests import HTTPError from .. import __version__ from .constants import ( DEPRECATED_REVISION_ARGS, DIFFUSERS_CACHE, HUGGINGFACE_CO_RESOLVE_ENDPOINT, SAFETENSORS_WEIGHTS_NAME, WEIGHTS_NAME, ) from .import_utils import ( ENV_VARS_TRUE_VALUES, _flax_version, _jax_version, _onnxruntime_version, _torch_version, is_flax_available, is_onnx_available, is_torch_available, ) from .logging import get_logger A__ : List[str] = get_logger(__name__) A__ : int = Path(__file__).parent / '''model_card_template.md''' A__ : str = uuida().hex A__ : Optional[Any] = os.getenv('''HF_HUB_OFFLINE''', '''''').upper() in ENV_VARS_TRUE_VALUES A__ : Optional[int] = os.getenv('''DISABLE_TELEMETRY''', '''''').upper() in ENV_VARS_TRUE_VALUES A__ : Any = HUGGINGFACE_CO_RESOLVE_ENDPOINT + '''/api/telemetry/''' def a_ ( _UpperCAmelCase : Union[Dict, str, None] = None ) -> str: __snake_case : List[str] = f'''diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}''' if DISABLE_TELEMETRY or HF_HUB_OFFLINE: return ua + "; telemetry/off" if is_torch_available(): ua += f'''; torch/{_torch_version}''' if is_flax_available(): ua += f'''; jax/{_jax_version}''' ua += f'''; flax/{_flax_version}''' if is_onnx_available(): ua += f'''; onnxruntime/{_onnxruntime_version}''' # CI will set this value to True if os.environ.get('DIFFUSERS_IS_CI' ,'' ).upper() in ENV_VARS_TRUE_VALUES: ua += "; is_ci/true" if isinstance(_UpperCAmelCase ,_UpperCAmelCase ): ua += "; " + "; ".join(f'''{k}/{v}''' for k, v in user_agent.items() ) elif isinstance(_UpperCAmelCase ,_UpperCAmelCase ): ua += "; " + user_agent return ua def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : Optional[str] = None ,_UpperCAmelCase : Optional[str] = None ) -> str: if token is None: __snake_case : Optional[int] = HfFolder.get_token() if organization is None: __snake_case : Union[str, Any] = whoami(_UpperCAmelCase )['name'] return f'''{username}/{model_id}''' else: return f'''{organization}/{model_id}''' def a_ ( _UpperCAmelCase : Dict ,_UpperCAmelCase : List[Any] ) -> int: if not is_jinja_available(): raise ValueError( 'Modelcard rendering is based on Jinja templates.' ' Please make sure to have `jinja` installed before using `create_model_card`.' ' To install it, please run `pip install Jinja2`.' ) if hasattr(_UpperCAmelCase ,'local_rank' ) and args.local_rank not in [-1, 0]: return __snake_case : str = args.hub_token if hasattr(_UpperCAmelCase ,'hub_token' ) else None __snake_case : Optional[int] = get_full_repo_name(_UpperCAmelCase ,token=_UpperCAmelCase ) __snake_case : int = ModelCard.from_template( card_data=ModelCardData( # Card metadata object that will be converted to YAML block language='en' ,license='apache-2.0' ,library_name='diffusers' ,tags=[] ,datasets=args.dataset_name ,metrics=[] ,) ,template_path=_UpperCAmelCase ,model_name=_UpperCAmelCase ,repo_name=_UpperCAmelCase ,dataset_name=args.dataset_name if hasattr(_UpperCAmelCase ,'dataset_name' ) else None ,learning_rate=args.learning_rate ,train_batch_size=args.train_batch_size ,eval_batch_size=args.eval_batch_size ,gradient_accumulation_steps=( args.gradient_accumulation_steps if hasattr(_UpperCAmelCase ,'gradient_accumulation_steps' ) else None ) ,adam_betaa=args.adam_betaa if hasattr(_UpperCAmelCase ,'adam_beta1' ) else None ,adam_betaa=args.adam_betaa if hasattr(_UpperCAmelCase ,'adam_beta2' ) else None ,adam_weight_decay=args.adam_weight_decay if hasattr(_UpperCAmelCase ,'adam_weight_decay' ) else None ,adam_epsilon=args.adam_epsilon if hasattr(_UpperCAmelCase ,'adam_epsilon' ) else None ,lr_scheduler=args.lr_scheduler if hasattr(_UpperCAmelCase ,'lr_scheduler' ) else None ,lr_warmup_steps=args.lr_warmup_steps if hasattr(_UpperCAmelCase ,'lr_warmup_steps' ) else None ,ema_inv_gamma=args.ema_inv_gamma if hasattr(_UpperCAmelCase ,'ema_inv_gamma' ) else None ,ema_power=args.ema_power if hasattr(_UpperCAmelCase ,'ema_power' ) else None ,ema_max_decay=args.ema_max_decay if hasattr(_UpperCAmelCase ,'ema_max_decay' ) else None ,mixed_precision=args.mixed_precision ,) __snake_case : List[Any] = os.path.join(args.output_dir ,'README.md' ) model_card.save(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : Optional[str] ,_UpperCAmelCase : Optional[str] = None ) -> Dict: if resolved_file is None or commit_hash is not None: return commit_hash __snake_case : List[str] = str(Path(_UpperCAmelCase ).as_posix() ) __snake_case : List[Any] = re.search(r'snapshots/([^/]+)/' ,_UpperCAmelCase ) if search is None: return None __snake_case : str = search.groups()[0] return commit_hash if REGEX_COMMIT_HASH.match(_UpperCAmelCase ) else None # Old default cache path, potentially to be migrated. # This logic was more or less taken from `transformers`, with the following differences: # - Diffusers doesn't use custom environment variables to specify the cache path. # - There is no need to migrate the cache format, just move the files to the new location. A__ : Optional[Any] = os.path.expanduser( os.getenv('''HF_HOME''', os.path.join(os.getenv('''XDG_CACHE_HOME''', '''~/.cache'''), '''huggingface''')) ) A__ : List[str] = os.path.join(hf_cache_home, '''diffusers''') def a_ ( _UpperCAmelCase : Optional[str] = None ,_UpperCAmelCase : Optional[str] = None ) -> None: if new_cache_dir is None: __snake_case : Tuple = DIFFUSERS_CACHE if old_cache_dir is None: __snake_case : str = old_diffusers_cache __snake_case : str = Path(_UpperCAmelCase ).expanduser() __snake_case : int = Path(_UpperCAmelCase ).expanduser() for old_blob_path in old_cache_dir.glob('**/blobs/*' ): if old_blob_path.is_file() and not old_blob_path.is_symlink(): __snake_case : Optional[Any] = new_cache_dir / old_blob_path.relative_to(_UpperCAmelCase ) new_blob_path.parent.mkdir(parents=_UpperCAmelCase ,exist_ok=_UpperCAmelCase ) os.replace(_UpperCAmelCase ,_UpperCAmelCase ) try: os.symlink(_UpperCAmelCase ,_UpperCAmelCase ) except OSError: logger.warning( 'Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.' ) # At this point, old_cache_dir contains symlinks to the new cache (it can still be used). A__ : str = os.path.join(DIFFUSERS_CACHE, '''version_diffusers_cache.txt''') if not os.path.isfile(cache_version_file): A__ : List[Any] = 0 else: with open(cache_version_file) as f: try: A__ : Tuple = int(f.read()) except ValueError: A__ : List[str] = 0 if cache_version < 1: A__ : Any = os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0 if old_cache_is_not_empty: logger.warning( '''The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your ''' '''existing cached models. This is a one-time operation, you can interrupt it or run it ''' '''later by calling `diffusers.utils.hub_utils.move_cache()`.''' ) try: move_cache() except Exception as e: A__ : int = '''\n'''.join(traceback.format_tb(e.__traceback__)) logger.error( F"""There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease """ '''file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole ''' '''message and we will do our best to help.''' ) if cache_version < 1: try: os.makedirs(DIFFUSERS_CACHE, exist_ok=True) with open(cache_version_file, '''w''') as f: f.write('''1''') except Exception: logger.warning( F"""There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure """ '''the directory exists and can be written to.''' ) def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : Optional[str] = None ) -> str: if variant is not None: __snake_case : List[Any] = weights_name.split('.' ) __snake_case : Dict = splits[:-1] + [variant] + splits[-1:] __snake_case : Optional[Any] = '.'.join(_UpperCAmelCase ) return weights_name def a_ ( _UpperCAmelCase : Dict ,*, _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : List[str] ,_UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : int ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : int ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : str ,_UpperCAmelCase : List[str]=None ,) -> Optional[Any]: __snake_case : Optional[Any] = str(_UpperCAmelCase ) if os.path.isfile(_UpperCAmelCase ): return pretrained_model_name_or_path elif os.path.isdir(_UpperCAmelCase ): if os.path.isfile(os.path.join(_UpperCAmelCase ,_UpperCAmelCase ) ): # Load from a PyTorch checkpoint __snake_case : Tuple = os.path.join(_UpperCAmelCase ,_UpperCAmelCase ) return model_file elif subfolder is not None and os.path.isfile( os.path.join(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) ): __snake_case : List[Any] = os.path.join(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ) return model_file else: raise EnvironmentError( f'''Error no file named {weights_name} found in directory {pretrained_model_name_or_path}.''' ) else: # 1. First check if deprecated way of loading from branches is used if ( revision in DEPRECATED_REVISION_ARGS and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME) and version.parse(version.parse(_UpperCAmelCase ).base_version ) >= version.parse('0.20.0' ) ): try: __snake_case : Optional[Any] = hf_hub_download( _UpperCAmelCase ,filename=_add_variant(_UpperCAmelCase ,_UpperCAmelCase ) ,cache_dir=_UpperCAmelCase ,force_download=_UpperCAmelCase ,proxies=_UpperCAmelCase ,resume_download=_UpperCAmelCase ,local_files_only=_UpperCAmelCase ,use_auth_token=_UpperCAmelCase ,user_agent=_UpperCAmelCase ,subfolder=_UpperCAmelCase ,revision=revision or commit_hash ,) warnings.warn( f'''Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.''' ,_UpperCAmelCase ,) return model_file except: # noqa: E722 warnings.warn( f'''You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(_UpperCAmelCase ,_UpperCAmelCase )} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(_UpperCAmelCase ,_UpperCAmelCase )}\' so that the correct variant file can be added.''' ,_UpperCAmelCase ,) try: # 2. Load model file as usual __snake_case : List[Any] = hf_hub_download( _UpperCAmelCase ,filename=_UpperCAmelCase ,cache_dir=_UpperCAmelCase ,force_download=_UpperCAmelCase ,proxies=_UpperCAmelCase ,resume_download=_UpperCAmelCase ,local_files_only=_UpperCAmelCase ,use_auth_token=_UpperCAmelCase ,user_agent=_UpperCAmelCase ,subfolder=_UpperCAmelCase ,revision=revision or commit_hash ,) return model_file except RepositoryNotFoundError: raise EnvironmentError( f'''{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier ''' 'listed on \'https://huggingface.co/models\'\nIf this is a private repository, make sure to pass a ' 'token having permission to this repo with `use_auth_token` or log in with `huggingface-cli ' 'login`.' ) except RevisionNotFoundError: raise EnvironmentError( f'''{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for ''' 'this model name. Check the model page at ' f'''\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions.''' ) except EntryNotFoundError: raise EnvironmentError( f'''{pretrained_model_name_or_path} does not appear to have a file named {weights_name}.''' ) except HTTPError as err: raise EnvironmentError( f'''There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}''' ) except ValueError: raise EnvironmentError( f'''We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it''' f''' in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a''' f''' directory containing a file named {weights_name} or''' ' \nCheckout your internet connection or see how to run the library in' ' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.' ) except EnvironmentError: raise EnvironmentError( f'''Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from ''' '\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. ' f'''Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory ''' f'''containing a file named {weights_name}''' )

'''simple docstring''' from __future__ import annotations A__ : List[Any] = list[list[int]] # assigning initial values to the grid A__ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution A__ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def a_ ( _UpperCAmelCase : Matrix ,_UpperCAmelCase : int ,_UpperCAmelCase : int ,_UpperCAmelCase : int ) -> bool: for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def a_ ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def a_ ( _UpperCAmelCase : Matrix ) -> Matrix | None: if location := find_empty_location(_UpperCAmelCase ): __snake_case , __snake_case : Optional[int] = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 ,10 ): if is_safe(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ): __snake_case : Union[str, Any] = digit if sudoku(_UpperCAmelCase ) is not None: return grid __snake_case : Optional[Any] = 0 return None def a_ ( _UpperCAmelCase : Matrix ) -> None: for row in grid: for cell in row: print(_UpperCAmelCase ,end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print('''\nExample grid:\n''' + '''=''' * 2_0) print_solution(example_grid) print('''\nExample grid solution:''') A__ : List[str] = sudoku(example_grid) if solution is not None: print_solution(solution) else: print('''Cannot find a solution.''')

import os from collections import deque import torch from torch.utils.data import Dataset class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def __init__( self : List[str] , __a : Tuple="" , __a : Any="train" ) -> Optional[Any]: '''simple docstring''' assert os.path.isdir(__a ) __snake_case : str = [] __snake_case : List[str] = os.listdir(__a ) for story_filename in story_filenames_list: if "summary" in story_filename: continue __snake_case : str = os.path.join(__a , __a ) if not os.path.isfile(__a ): continue self.documents.append(__a ) def __len__( self : Optional[Any] ) -> Optional[int]: '''simple docstring''' return len(self.documents ) def __getitem__( self : Tuple , __a : Tuple ) -> int: '''simple docstring''' __snake_case : Optional[Any] = self.documents[idx] __snake_case : Any = document_path.split('/' )[-1] with open(__a , encoding='utf-8' ) as source: __snake_case : List[str] = source.read() __snake_case : Any = process_story(__a ) return document_name, story_lines, summary_lines def a_ ( _UpperCAmelCase : Optional[int] ) -> Tuple: __snake_case : Union[str, Any] = list(filter(lambda _UpperCAmelCase : len(_UpperCAmelCase ) != 0 ,[line.strip() for line in raw_story.split('\n' )] ) ) # for some unknown reason some lines miss a period, add it __snake_case : Tuple = [_add_missing_period(_UpperCAmelCase ) for line in nonempty_lines] # gather article lines __snake_case : Optional[Any] = [] __snake_case : str = deque(_UpperCAmelCase ) while True: try: __snake_case : str = lines.popleft() if element.startswith('@highlight' ): break story_lines.append(_UpperCAmelCase ) except IndexError: # if "@highlight" is absent from the file we pop # all elements until there is None, raising an exception. return story_lines, [] # gather summary lines __snake_case : Optional[Any] = list(filter(lambda _UpperCAmelCase : not t.startswith('@highlight' ) ,_UpperCAmelCase ) ) return story_lines, summary_lines def a_ ( _UpperCAmelCase : Union[str, Any] ) -> int: __snake_case : List[Any] = ['.', '!', '?', '...', '\'', '`', '"', '\u2019', '\u2019', ')'] if line.startswith('@highlight' ): return line if line[-1] in END_TOKENS: return line return line + "." def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : str ) -> int: if len(_UpperCAmelCase ) > block_size: return sequence[:block_size] else: sequence.extend([pad_token_id] * (block_size - len(_UpperCAmelCase )) ) return sequence def a_ ( _UpperCAmelCase : List[Any] ,_UpperCAmelCase : List[str] ) -> List[str]: __snake_case : Optional[Any] = torch.ones_like(_UpperCAmelCase ) __snake_case : List[Any] = sequence == pad_token_id __snake_case : Tuple = 0 return mask def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : List[str] ,_UpperCAmelCase : Optional[Any] ) -> Dict: __snake_case : Optional[int] = [tokenizer.encode(_UpperCAmelCase ) for line in story_lines] __snake_case : Union[str, Any] = [token for sentence in story_lines_token_ids for token in sentence] __snake_case : Any = [tokenizer.encode(_UpperCAmelCase ) for line in summary_lines] __snake_case : str = [token for sentence in summary_lines_token_ids for token in sentence] return story_token_ids, summary_token_ids def a_ ( _UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : str ) -> Tuple: __snake_case : int = [] for sequence in batch: __snake_case : Union[str, Any] = -1 __snake_case : List[Any] = [] for s in sequence: if s == separator_token_id: sentence_num += 1 embeddings.append(sentence_num % 2 ) batch_embeddings.append(_UpperCAmelCase ) return torch.tensor(_UpperCAmelCase )

'''simple docstring''' import unittest import numpy as np import torch from torch import nn from transformers import ( CLIPImageProcessor, CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer, CLIPVisionConfig, CLIPVisionModelWithProjection, ) from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler from diffusers.utils import torch_device from diffusers.utils.testing_utils import enable_full_determinism, skip_mps from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = KandinskyVaaPriorPipeline A__ = ['''prompt'''] A__ = ['''prompt''', '''negative_prompt'''] A__ = [ '''num_images_per_prompt''', '''generator''', '''num_inference_steps''', '''latents''', '''negative_prompt''', '''guidance_scale''', '''output_type''', '''return_dict''', ] A__ = False @property def A_ ( self : Dict ) -> List[str]: '''simple docstring''' return 32 @property def A_ ( self : Any ) -> str: '''simple docstring''' return 32 @property def A_ ( self : str ) -> Optional[int]: '''simple docstring''' return self.time_input_dim @property def A_ ( self : str ) -> int: '''simple docstring''' return self.time_input_dim * 4 @property def A_ ( self : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return 100 @property def A_ ( self : Tuple ) -> List[str]: '''simple docstring''' __snake_case : Tuple = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) return tokenizer @property def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Union[str, Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) return CLIPTextModelWithProjection(__a ) @property def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Any = { 'num_attention_heads': 2, 'attention_head_dim': 12, 'embedding_dim': self.text_embedder_hidden_size, 'num_layers': 1, } __snake_case : List[Any] = PriorTransformer(**__a ) # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0 __snake_case : Any = nn.Parameter(torch.ones(model.clip_std.shape ) ) return model @property def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Optional[Any] = CLIPVisionConfig( hidden_size=self.text_embedder_hidden_size , image_size=224 , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , num_attention_heads=4 , num_channels=3 , num_hidden_layers=5 , patch_size=14 , ) __snake_case : Optional[Any] = CLIPVisionModelWithProjection(__a ) return model @property def A_ ( self : Dict ) -> List[Any]: '''simple docstring''' __snake_case : Dict = CLIPImageProcessor( crop_size=224 , do_center_crop=__a , do_normalize=__a , do_resize=__a , image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3] , image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1] , resample=3 , size=224 , ) return image_processor def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' __snake_case : Tuple = self.dummy_prior __snake_case : List[str] = self.dummy_image_encoder __snake_case : str = self.dummy_text_encoder __snake_case : List[str] = self.dummy_tokenizer __snake_case : List[str] = self.dummy_image_processor __snake_case : Any = UnCLIPScheduler( variance_type='fixed_small_log' , prediction_type='sample' , num_train_timesteps=1000 , clip_sample=__a , clip_sample_range=1_0.0 , ) __snake_case : str = { 'prior': prior, 'image_encoder': image_encoder, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'scheduler': scheduler, 'image_processor': image_processor, } return components def A_ ( self : List[Any] , __a : Optional[Any] , __a : Tuple=0 ) -> Any: '''simple docstring''' if str(__a ).startswith('mps' ): __snake_case : List[str] = torch.manual_seed(__a ) else: __snake_case : List[str] = torch.Generator(device=__a ).manual_seed(__a ) __snake_case : List[Any] = { 'prompt': 'horse', 'generator': generator, 'guidance_scale': 4.0, 'num_inference_steps': 2, 'output_type': 'np', } return inputs def A_ ( self : str ) -> Dict: '''simple docstring''' __snake_case : str = 'cpu' __snake_case : List[str] = self.get_dummy_components() __snake_case : Tuple = self.pipeline_class(**__a ) __snake_case : Optional[Any] = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[int] = pipe(**self.get_dummy_inputs(__a ) ) __snake_case : List[str] = output.image_embeds __snake_case : str = pipe( **self.get_dummy_inputs(__a ) , return_dict=__a , )[0] __snake_case : Union[str, Any] = image[0, -10:] __snake_case : Any = image_from_tuple[0, -10:] assert image.shape == (1, 32) __snake_case : List[Any] = np.array( [-0.0_5_3_2, 1.7_1_2_0, 0.3_6_5_6, -1.0_8_5_2, -0.8_9_4_6, -1.1_7_5_6, 0.4_3_4_8, 0.2_4_8_2, 0.5_1_4_6, -0.1_1_5_6] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2 @skip_mps def A_ ( self : Tuple ) -> Optional[int]: '''simple docstring''' __snake_case : Union[str, Any] = torch_device == 'cpu' __snake_case : Dict = True __snake_case : Union[str, Any] = False self._test_inference_batch_single_identical( test_max_difference=__a , relax_max_difference=__a , test_mean_pixel_difference=__a , ) @skip_mps def A_ ( self : str ) -> Union[str, Any]: '''simple docstring''' __snake_case : Dict = torch_device == 'cpu' __snake_case : Optional[Any] = False self._test_attention_slicing_forward_pass( test_max_difference=__a , test_mean_pixel_difference=__a , )

'''simple docstring''' from __future__ import annotations from scipy.special import comb # type: ignore class snake_case__ : def __init__( self : int , __a : list[tuple[float, float]] ) -> Dict: '''simple docstring''' __snake_case : List[Any] = list_of_points # Degree determines the flexibility of the curve. # Degree = 1 will produce a straight line. __snake_case : Union[str, Any] = len(__a ) - 1 def A_ ( self : str , __a : float ) -> list[float]: '''simple docstring''' assert 0 <= t <= 1, "Time t must be between 0 and 1." __snake_case : list[float] = [] for i in range(len(self.list_of_points ) ): # basis function for each i output_values.append( comb(self.degree , __a ) * ((1 - t) ** (self.degree - i)) * (t**i) ) # the basis must sum up to 1 for it to produce a valid Bezier curve. assert round(sum(__a ) , 5 ) == 1 return output_values def A_ ( self : List[Any] , __a : float ) -> tuple[float, float]: '''simple docstring''' assert 0 <= t <= 1, "Time t must be between 0 and 1." __snake_case : List[Any] = self.basis_function(__a ) __snake_case : List[Any] = 0.0 __snake_case : List[Any] = 0.0 for i in range(len(self.list_of_points ) ): # For all points, sum up the product of i-th basis function and i-th point. x += basis_function[i] * self.list_of_points[i][0] y += basis_function[i] * self.list_of_points[i][1] return (x, y) def A_ ( self : Any , __a : float = 0.0_1 ) -> str: '''simple docstring''' from matplotlib import pyplot as plt # type: ignore __snake_case : list[float] = [] # x coordinates of points to plot __snake_case : list[float] = [] # y coordinates of points to plot __snake_case : Dict = 0.0 while t <= 1: __snake_case : Optional[Any] = self.bezier_curve_function(__a ) to_plot_x.append(value[0] ) to_plot_y.append(value[1] ) t += step_size __snake_case : List[Any] = [i[0] for i in self.list_of_points] __snake_case : Optional[int] = [i[1] for i in self.list_of_points] plt.plot( __a , __a , color='blue' , label='Curve of Degree ' + str(self.degree ) , ) plt.scatter(__a , __a , color='red' , label='Control Points' ) plt.legend() plt.show() if __name__ == "__main__": import doctest doctest.testmod() BezierCurve([(1, 2), (3, 5)]).plot_curve() # degree 1 BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve() # degree 2 BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve() # degree 3

'''simple docstring''' from math import factorial A__ : dict[str, int] = {str(digit): factorial(digit) for digit in range(1_0)} def a_ ( _UpperCAmelCase : int ) -> int: if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise TypeError('Parameter number must be int' ) if number < 0: raise ValueError('Parameter number must be greater than or equal to 0' ) # Converts number in string to iterate on its digits and adds its factorial. return sum(DIGIT_FACTORIAL[digit] for digit in str(_UpperCAmelCase ) ) def a_ ( _UpperCAmelCase : int = 60 ,_UpperCAmelCase : int = 1_00_00_00 ) -> int: if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ) or not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise TypeError('Parameters chain_length and number_limit must be int' ) if chain_length <= 0 or number_limit <= 0: raise ValueError( 'Parameters chain_length and number_limit must be greater than 0' ) # the counter for the chains with the exact desired length __snake_case : List[str] = 0 # the cached sizes of the previous chains __snake_case : dict[int, int] = {} for start_chain_element in range(1 ,_UpperCAmelCase ): # The temporary set will contain the elements of the chain __snake_case : Optional[int] = set() __snake_case : List[Any] = 0 # Stop computing the chain when you find a cached size, a repeating item or the # length is greater then the desired one. __snake_case : str = start_chain_element while ( chain_element not in chain_sets_lengths and chain_element not in chain_set and chain_set_length <= chain_length ): chain_set.add(_UpperCAmelCase ) chain_set_length += 1 __snake_case : Tuple = digit_factorial_sum(_UpperCAmelCase ) if chain_element in chain_sets_lengths: chain_set_length += chain_sets_lengths[chain_element] __snake_case : Optional[Any] = chain_set_length # If chain contains the exact amount of elements increase the counter if chain_set_length == chain_length: chains_counter += 1 return chains_counter if __name__ == "__main__": import doctest doctest.testmod() print(F"""{solution()}""")

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging A__ : Union[str, Any] = logging.get_logger(__name__) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''timm_backbone''' def __init__( self : Optional[Any] , __a : List[str]=None , __a : int=3 , __a : Tuple=True , __a : Tuple=True , __a : Tuple=None , **__a : Tuple , ) -> Optional[Any]: '''simple docstring''' super().__init__(**__a ) __snake_case : Any = backbone __snake_case : Union[str, Any] = num_channels __snake_case : Optional[int] = features_only __snake_case : str = use_pretrained_backbone __snake_case : Any = True __snake_case : Union[str, Any] = out_indices if out_indices is not None else (-1,)

'''simple docstring''' def a_ ( _UpperCAmelCase : int = 1_00 ) -> int: __snake_case : Any = n * (n + 1) * (2 * n + 1) / 6 __snake_case : Union[str, Any] = (n * (n + 1) / 2) ** 2 return int(square_of_sum - sum_of_squares ) if __name__ == "__main__": print(F"""{solution() = }""")

'''simple docstring''' from __future__ import annotations from cmath import sqrt def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : int ,_UpperCAmelCase : int ) -> tuple[complex, complex]: if a == 0: raise ValueError('Coefficient \'a\' must not be zero.' ) __snake_case : int = b * b - 4 * a * c __snake_case : Optional[int] = (-b + sqrt(_UpperCAmelCase )) / (2 * a) __snake_case : List[Any] = (-b - sqrt(_UpperCAmelCase )) / (2 * a) return ( root_a.real if not root_a.imag else root_a, root_a.real if not root_a.imag else root_a, ) def a_ ( ) -> Optional[int]: __snake_case : Union[str, Any] = quadratic_roots(a=5 ,b=6 ,c=1 ) print(f'''The solutions are: {solutiona} and {solutiona}''' ) if __name__ == "__main__": main()

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available A__ : int = { '''configuration_groupvit''': [ '''GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GroupViTConfig''', '''GroupViTOnnxConfig''', '''GroupViTTextConfig''', '''GroupViTVisionConfig''', ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Tuple = [ '''GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''GroupViTModel''', '''GroupViTPreTrainedModel''', '''GroupViTTextModel''', '''GroupViTVisionModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Optional[int] = [ '''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 A__ : List[str] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class snake_case__ ( unittest.TestCase ): def __init__( self : Optional[Any] , __a : str , __a : int=13 , __a : List[str]=3 , __a : int=224 , __a : str=30 , __a : Tuple=400 , __a : int=True , __a : Any=None , __a : List[str]=True , __a : Optional[Any]=[0.5, 0.5, 0.5] , __a : List[Any]=[0.5, 0.5, 0.5] , ) -> Optional[Any]: '''simple docstring''' __snake_case : Union[str, Any] = size if size is not None else {'height': 18, 'width': 18} __snake_case : List[Any] = parent __snake_case : Optional[Any] = batch_size __snake_case : str = num_channels __snake_case : List[Any] = image_size __snake_case : Optional[Any] = min_resolution __snake_case : Optional[Any] = max_resolution __snake_case : Dict = do_resize __snake_case : Union[str, Any] = size __snake_case : List[Any] = do_normalize __snake_case : List[str] = image_mean __snake_case : Any = image_std def A_ ( self : Optional[int] ) -> str: '''simple docstring''' return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, } @require_torch @require_vision class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ViTImageProcessor if is_vision_available() else None def A_ ( self : Optional[Any] ) -> str: '''simple docstring''' __snake_case : Optional[Any] = EfficientFormerImageProcessorTester(self ) @property def A_ ( self : Optional[Any] ) -> List[str]: '''simple docstring''' return self.image_proc_tester.prepare_image_processor_dict() def A_ ( self : Tuple ) -> int: '''simple docstring''' __snake_case : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(__a , 'image_mean' ) ) self.assertTrue(hasattr(__a , 'image_std' ) ) self.assertTrue(hasattr(__a , 'do_normalize' ) ) self.assertTrue(hasattr(__a , 'do_resize' ) ) self.assertTrue(hasattr(__a , 'size' ) ) def A_ ( self : Optional[Any] ) -> Union[str, Any]: '''simple docstring''' pass def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' __snake_case : Any = self.image_processing_class(**self.image_processor_dict ) # create random PIL images __snake_case : Union[str, Any] = prepare_image_inputs(self.image_proc_tester , equal_resolution=__a ) for image in image_inputs: self.assertIsInstance(__a , Image.Image ) # Test not batched input __snake_case : int = image_processor(image_inputs[0] , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , ) # Test batched __snake_case : int = image_processor(__a , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , ) def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : int = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors __snake_case : List[str] = prepare_image_inputs(self.image_proc_tester , equal_resolution=__a , numpify=__a ) for image in image_inputs: self.assertIsInstance(__a , np.ndarray ) # Test not batched input __snake_case : Optional[Any] = image_processor(image_inputs[0] , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , ) # Test batched __snake_case : Union[str, Any] = image_processor(__a , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , ) def A_ ( self : int ) -> Optional[Any]: '''simple docstring''' __snake_case : int = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors __snake_case : Any = prepare_image_inputs(self.image_proc_tester , equal_resolution=__a , torchify=__a ) for image in image_inputs: self.assertIsInstance(__a , torch.Tensor ) # Test not batched input __snake_case : List[str] = image_processor(image_inputs[0] , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , ) # Test batched __snake_case : str = image_processor(__a , return_tensors='pt' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['height'], self.image_proc_tester.size['width'], ) , )

'''simple docstring''' import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline from diffusers.pipelines.shap_e import ShapERenderer from diffusers.utils import load_numpy, slow from diffusers.utils.testing_utils import require_torch_gpu, torch_device from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ShapEPipeline A__ = ['''prompt'''] A__ = ['''prompt'''] A__ = [ '''num_images_per_prompt''', '''num_inference_steps''', '''generator''', '''latents''', '''guidance_scale''', '''frame_size''', '''output_type''', '''return_dict''', ] A__ = False @property def A_ ( self : Optional[Any] ) -> str: '''simple docstring''' return 32 @property def A_ ( self : str ) -> Optional[int]: '''simple docstring''' return 32 @property def A_ ( self : Tuple ) -> List[Any]: '''simple docstring''' return self.time_input_dim * 4 @property def A_ ( self : Tuple ) -> Dict: '''simple docstring''' return 8 @property def A_ ( self : Optional[Any] ) -> List[str]: '''simple docstring''' __snake_case : Dict = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) return tokenizer @property def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Optional[int] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) return CLIPTextModelWithProjection(__a ) @property def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Dict = { 'num_attention_heads': 2, 'attention_head_dim': 16, 'embedding_dim': self.time_input_dim, 'num_embeddings': 32, 'embedding_proj_dim': self.text_embedder_hidden_size, 'time_embed_dim': self.time_embed_dim, 'num_layers': 1, 'clip_embed_dim': self.time_input_dim * 2, 'additional_embeddings': 0, 'time_embed_act_fn': 'gelu', 'norm_in_type': 'layer', 'encoder_hid_proj_type': None, 'added_emb_type': None, } __snake_case : Optional[Any] = PriorTransformer(**__a ) return model @property def A_ ( self : Dict ) -> Dict: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Tuple = { 'param_shapes': ( (self.renderer_dim, 93), (self.renderer_dim, 8), (self.renderer_dim, 8), (self.renderer_dim, 8), ), 'd_latent': self.time_input_dim, 'd_hidden': self.renderer_dim, 'n_output': 12, 'background': ( 0.1, 0.1, 0.1, ), } __snake_case : Optional[int] = ShapERenderer(**__a ) return model def A_ ( self : Tuple ) -> Tuple: '''simple docstring''' __snake_case : Tuple = self.dummy_prior __snake_case : Union[str, Any] = self.dummy_text_encoder __snake_case : List[str] = self.dummy_tokenizer __snake_case : Optional[Any] = self.dummy_renderer __snake_case : List[Any] = HeunDiscreteScheduler( beta_schedule='exp' , num_train_timesteps=1024 , prediction_type='sample' , use_karras_sigmas=__a , clip_sample=__a , clip_sample_range=1.0 , ) __snake_case : int = { 'prior': prior, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'renderer': renderer, 'scheduler': scheduler, } return components def A_ ( self : Union[str, Any] , __a : Dict , __a : int=0 ) -> Optional[Any]: '''simple docstring''' if str(__a ).startswith('mps' ): __snake_case : List[str] = torch.manual_seed(__a ) else: __snake_case : Optional[Any] = torch.Generator(device=__a ).manual_seed(__a ) __snake_case : Optional[int] = { 'prompt': 'horse', 'generator': generator, 'num_inference_steps': 1, 'frame_size': 32, 'output_type': 'np', } return inputs def A_ ( self : List[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Dict = 'cpu' __snake_case : Dict = self.get_dummy_components() __snake_case : int = self.pipeline_class(**__a ) __snake_case : str = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[Any] = pipe(**self.get_dummy_inputs(__a ) ) __snake_case : Dict = output.images[0] __snake_case : int = image[0, -3:, -3:, -1] assert image.shape == (20, 32, 32, 3) __snake_case : str = np.array( [ 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, ] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def A_ ( self : Any ) -> List[str]: '''simple docstring''' # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches self._test_inference_batch_consistent(batch_sizes=[1, 2] ) def A_ ( self : int ) -> Tuple: '''simple docstring''' __snake_case : int = torch_device == 'cpu' __snake_case : str = True self._test_inference_batch_single_identical( batch_size=2 , test_max_difference=__a , relax_max_difference=__a , ) def A_ ( self : List[str] ) -> Dict: '''simple docstring''' __snake_case : str = self.get_dummy_components() __snake_case : Tuple = self.pipeline_class(**__a ) __snake_case : Dict = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : int = 1 __snake_case : Tuple = 2 __snake_case : Tuple = self.get_dummy_inputs(__a ) for key in inputs.keys(): if key in self.batch_params: __snake_case : Union[str, Any] = batch_size * [inputs[key]] __snake_case : str = pipe(**__a , num_images_per_prompt=__a )[0] assert images.shape[0] == batch_size * num_images_per_prompt @slow @require_torch_gpu class snake_case__ ( unittest.TestCase ): def A_ ( self : str ) -> Dict: '''simple docstring''' # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Optional[int] = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/test_shap_e_np_out.npy' ) __snake_case : Union[str, Any] = ShapEPipeline.from_pretrained('openai/shap-e' ) __snake_case : Any = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[int] = torch.Generator(device=__a ).manual_seed(0 ) __snake_case : Union[str, Any] = pipe( 'a shark' , generator=__a , guidance_scale=1_5.0 , num_inference_steps=64 , frame_size=64 , output_type='np' , ).images[0] assert images.shape == (20, 64, 64, 3) assert_mean_pixel_difference(__a , __a )

'''simple docstring''' from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING A__ : Optional[int] = logging.get_logger(__name__) @add_end_docstrings(SCREAMING_SNAKE_CASE_ ) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def __init__( self : Dict , **__a : Dict ) -> List[str]: '''simple docstring''' super().__init__(**__a ) if self.framework == "tf": raise ValueError(f'''The {self.__class__} is only available in PyTorch.''' ) requires_backends(self , 'vision' ) self.check_model_type(__a ) def __call__( self : Dict , __a : Union[str, "Image.Image", List[Dict[str, Any]]] , __a : Union[str, List[str]] = None , **__a : Any , ) -> str: '''simple docstring''' if "text_queries" in kwargs: __snake_case : Tuple = kwargs.pop('text_queries' ) if isinstance(__a , (str, Image.Image) ): __snake_case : List[str] = {'image': image, 'candidate_labels': candidate_labels} else: __snake_case : Optional[int] = image __snake_case : Union[str, Any] = super().__call__(__a , **__a ) return results def A_ ( self : List[str] , **__a : int ) -> Optional[int]: '''simple docstring''' __snake_case : str = {} if "threshold" in kwargs: __snake_case : int = kwargs['threshold'] if "top_k" in kwargs: __snake_case : int = kwargs['top_k'] return {}, {}, postprocess_params def A_ ( self : List[str] , __a : Union[str, Any] ) -> Tuple: '''simple docstring''' __snake_case : Tuple = load_image(inputs['image'] ) __snake_case : Optional[int] = inputs['candidate_labels'] if isinstance(__a , __a ): __snake_case : Dict = candidate_labels.split(',' ) __snake_case : Tuple = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(__a ): __snake_case : str = self.tokenizer(__a , return_tensors=self.framework ) __snake_case : Tuple = self.image_processor(__a , return_tensors=self.framework ) yield { "is_last": i == len(__a ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def A_ ( self : Optional[Any] , __a : Optional[int] ) -> Optional[int]: '''simple docstring''' __snake_case : Any = model_inputs.pop('target_size' ) __snake_case : Tuple = model_inputs.pop('candidate_label' ) __snake_case : List[Any] = model_inputs.pop('is_last' ) __snake_case : Any = self.model(**__a ) __snake_case : Optional[int] = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def A_ ( self : Union[str, Any] , __a : Optional[Any] , __a : List[Any]=0.1 , __a : Dict=None ) -> Optional[Any]: '''simple docstring''' __snake_case : str = [] for model_output in model_outputs: __snake_case : Optional[Any] = model_output['candidate_label'] __snake_case : List[str] = BaseModelOutput(__a ) __snake_case : Optional[int] = self.image_processor.post_process_object_detection( outputs=__a , threshold=__a , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): __snake_case : Dict = outputs['scores'][index].item() __snake_case : List[Any] = self._get_bounding_box(outputs['boxes'][index][0] ) __snake_case : Any = {'score': score, 'label': label, 'box': box} results.append(__a ) __snake_case : str = sorted(__a , key=lambda __a : x["score"] , reverse=__a ) if top_k: __snake_case : Any = results[:top_k] return results def A_ ( self : Optional[int] , __a : "torch.Tensor" ) -> Dict[str, int]: '''simple docstring''' if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) __snake_case : Dict = box.int().tolist() __snake_case : str = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox

'''simple docstring''' from __future__ import annotations import time import numpy as np A__ : str = [8, 5, 9, 7] A__ : List[str] = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] A__ : Dict = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class snake_case__ : def __init__( self : Union[str, Any] , __a : list[int] , __a : list[list[int]] , __a : list[list[int]] , ) -> None: '''simple docstring''' __snake_case : int = claim_vector __snake_case : Optional[int] = allocated_resources_table __snake_case : List[str] = maximum_claim_table def A_ ( self : str ) -> list[int]: '''simple docstring''' return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def A_ ( self : int ) -> list[int]: '''simple docstring''' return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def A_ ( self : int ) -> list[list[int]]: '''simple docstring''' return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(__a ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def A_ ( self : str ) -> dict[int, list[int]]: '''simple docstring''' return {self.__need().index(__a ): i for i in self.__need()} def A_ ( self : Union[str, Any] , **__a : int ) -> None: '''simple docstring''' __snake_case : str = self.__need() __snake_case : List[Any] = self.__allocated_resources_table __snake_case : Optional[int] = self.__available_resources() __snake_case : Union[str, Any] = self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('_' * 50 + '\n' ) while need_list: __snake_case : Tuple = False for each_need in need_list: __snake_case : Any = True for index, need in enumerate(__a ): if need > available_resources[index]: __snake_case : List[str] = False break if execution: __snake_case : Union[str, Any] = True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: __snake_case : str = original_need_index print(f'''Process {process_number + 1} is executing.''' ) # remove the process run from stack need_list.remove(__a ) # update available/freed resources stack __snake_case : Union[str, Any] = np.array(__a ) + np.array( alloc_resources_table[process_number] ) print( 'Updated available resource stack for processes: ' + ' '.join([str(__a ) for x in available_resources] ) ) break if safe: print('The process is in a safe state.\n' ) else: print('System in unsafe state. Aborting...\n' ) break def A_ ( self : List[str] ) -> Optional[int]: '''simple docstring''' print(' ' * 9 + 'Allocated Resource Table' ) for item in self.__allocated_resources_table: print( f'''P{self.__allocated_resources_table.index(__a ) + 1}''' + ' '.join(f'''{it:>8}''' for it in item ) + '\n' ) print(' ' * 9 + 'System Resource Table' ) for item in self.__maximum_claim_table: print( f'''P{self.__maximum_claim_table.index(__a ) + 1}''' + ' '.join(f'''{it:>8}''' for it in item ) + '\n' ) print( 'Current Usage by Active Processes: ' + ' '.join(str(__a ) for x in self.__claim_vector ) ) print( 'Initial Available Resources: ' + ' '.join(str(__a ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' import unittest import torch from torch import nn from diffusers.models.activations import get_activation class snake_case__ ( unittest.TestCase ): def A_ ( self : List[str] ) -> int: '''simple docstring''' __snake_case : Dict = get_activation('swish' ) self.assertIsInstance(__a , nn.SiLU ) self.assertEqual(act(torch.tensor(-100 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def A_ ( self : Optional[Any] ) -> Optional[int]: '''simple docstring''' __snake_case : Tuple = get_activation('silu' ) self.assertIsInstance(__a , nn.SiLU ) self.assertEqual(act(torch.tensor(-100 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def A_ ( self : Union[str, Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Optional[Any] = get_activation('mish' ) self.assertIsInstance(__a , nn.Mish ) self.assertEqual(act(torch.tensor(-200 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' __snake_case : Tuple = get_activation('gelu' ) self.assertIsInstance(__a , nn.GELU ) self.assertEqual(act(torch.tensor(-100 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 )

'''simple docstring''' import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from .tokenization_electra import ElectraTokenizer A__ : Union[str, Any] = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''} A__ : List[Any] = { '''vocab_file''': { '''google/electra-small-generator''': ( '''https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt''' ), '''google/electra-base-generator''': '''https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt''', '''google/electra-large-generator''': ( '''https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt''' ), '''google/electra-small-discriminator''': ( '''https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt''' ), '''google/electra-base-discriminator''': ( '''https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt''' ), '''google/electra-large-discriminator''': ( '''https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt''' ), }, '''tokenizer_file''': { '''google/electra-small-generator''': ( '''https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json''' ), '''google/electra-base-generator''': ( '''https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json''' ), '''google/electra-large-generator''': ( '''https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json''' ), '''google/electra-small-discriminator''': ( '''https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json''' ), '''google/electra-base-discriminator''': ( '''https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json''' ), '''google/electra-large-discriminator''': ( '''https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json''' ), }, } A__ : List[Any] = { '''google/electra-small-generator''': 5_1_2, '''google/electra-base-generator''': 5_1_2, '''google/electra-large-generator''': 5_1_2, '''google/electra-small-discriminator''': 5_1_2, '''google/electra-base-discriminator''': 5_1_2, '''google/electra-large-discriminator''': 5_1_2, } A__ : Optional[Any] = { '''google/electra-small-generator''': {'''do_lower_case''': True}, '''google/electra-base-generator''': {'''do_lower_case''': True}, '''google/electra-large-generator''': {'''do_lower_case''': True}, '''google/electra-small-discriminator''': {'''do_lower_case''': True}, '''google/electra-base-discriminator''': {'''do_lower_case''': True}, '''google/electra-large-discriminator''': {'''do_lower_case''': True}, } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = VOCAB_FILES_NAMES A__ = PRETRAINED_VOCAB_FILES_MAP A__ = PRETRAINED_INIT_CONFIGURATION A__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A__ = ElectraTokenizer def __init__( self : int , __a : List[Any]=None , __a : int=None , __a : List[str]=True , __a : Any="[UNK]" , __a : Any="[SEP]" , __a : Union[str, Any]="[PAD]" , __a : Dict="[CLS]" , __a : List[Any]="[MASK]" , __a : str=True , __a : Optional[int]=None , **__a : Optional[int] , ) -> str: '''simple docstring''' super().__init__( __a , tokenizer_file=__a , do_lower_case=__a , unk_token=__a , sep_token=__a , pad_token=__a , cls_token=__a , mask_token=__a , tokenize_chinese_chars=__a , strip_accents=__a , **__a , ) __snake_case : Tuple = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('lowercase' , __a ) != do_lower_case or normalizer_state.get('strip_accents' , __a ) != strip_accents or normalizer_state.get('handle_chinese_chars' , __a ) != tokenize_chinese_chars ): __snake_case : List[Any] = getattr(__a , normalizer_state.pop('type' ) ) __snake_case : str = do_lower_case __snake_case : Optional[int] = strip_accents __snake_case : Any = tokenize_chinese_chars __snake_case : Union[str, Any] = normalizer_class(**__a ) __snake_case : Any = do_lower_case def A_ ( self : Any , __a : List[str] , __a : Optional[Any]=None ) -> Dict: '''simple docstring''' __snake_case : Optional[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 A_ ( self : List[Any] , __a : List[int] , __a : Optional[List[int]] = None ) -> List[int]: '''simple docstring''' __snake_case : int = [self.sep_token_id] __snake_case : 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 ) * [0] + len(token_ids_a + sep ) * [1] def A_ ( self : Optional[int] , __a : str , __a : Optional[str] = None ) -> Tuple[str]: '''simple docstring''' __snake_case : Tuple = self._tokenizer.model.save(__a , name=__a ) return tuple(__a )

'''simple docstring''' import tempfile import torch from diffusers import PNDMScheduler from .test_schedulers import SchedulerCommonTest class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = (PNDMScheduler,) A__ = (('''num_inference_steps''', 50),) def A_ ( self : Any , **__a : Any ) -> List[str]: '''simple docstring''' __snake_case : Optional[Any] = { 'num_train_timesteps': 1000, 'beta_start': 0.0_0_0_1, 'beta_end': 0.0_2, 'beta_schedule': 'linear', } config.update(**__a ) return config def A_ ( self : List[str] , __a : Dict=0 , **__a : str ) -> List[str]: '''simple docstring''' __snake_case : Dict = dict(self.forward_default_kwargs ) __snake_case : List[Any] = kwargs.pop('num_inference_steps' , __a ) __snake_case : Dict = self.dummy_sample __snake_case : Any = 0.1 * sample __snake_case : str = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5] for scheduler_class in self.scheduler_classes: __snake_case : str = self.get_scheduler_config(**__a ) __snake_case : List[str] = scheduler_class(**__a ) scheduler.set_timesteps(__a ) # copy over dummy past residuals __snake_case : Dict = dummy_past_residuals[:] with tempfile.TemporaryDirectory() as tmpdirname: scheduler.save_config(__a ) __snake_case : Optional[int] = scheduler_class.from_pretrained(__a ) new_scheduler.set_timesteps(__a ) # copy over dummy past residuals __snake_case : Optional[int] = dummy_past_residuals[:] __snake_case : Optional[int] = scheduler.step_prk(__a , __a , __a , **__a ).prev_sample __snake_case : Optional[Any] = new_scheduler.step_prk(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" __snake_case : Dict = scheduler.step_plms(__a , __a , __a , **__a ).prev_sample __snake_case : Dict = new_scheduler.step_plms(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' pass def A_ ( self : Any , __a : int=0 , **__a : List[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Any = dict(self.forward_default_kwargs ) __snake_case : Any = kwargs.pop('num_inference_steps' , __a ) __snake_case : Union[str, Any] = self.dummy_sample __snake_case : Union[str, Any] = 0.1 * sample __snake_case : Any = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5] for scheduler_class in self.scheduler_classes: __snake_case : Optional[Any] = self.get_scheduler_config() __snake_case : int = scheduler_class(**__a ) scheduler.set_timesteps(__a ) # copy over dummy past residuals (must be after setting timesteps) __snake_case : Tuple = dummy_past_residuals[:] with tempfile.TemporaryDirectory() as tmpdirname: scheduler.save_config(__a ) __snake_case : int = scheduler_class.from_pretrained(__a ) # copy over dummy past residuals new_scheduler.set_timesteps(__a ) # copy over dummy past residual (must be after setting timesteps) __snake_case : str = dummy_past_residuals[:] __snake_case : Dict = scheduler.step_prk(__a , __a , __a , **__a ).prev_sample __snake_case : List[str] = new_scheduler.step_prk(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" __snake_case : List[Any] = scheduler.step_plms(__a , __a , __a , **__a ).prev_sample __snake_case : List[str] = new_scheduler.step_plms(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" def A_ ( self : Tuple , **__a : int ) -> Dict: '''simple docstring''' __snake_case : List[Any] = self.scheduler_classes[0] __snake_case : Tuple = self.get_scheduler_config(**__a ) __snake_case : Any = scheduler_class(**__a ) __snake_case : int = 10 __snake_case : List[str] = self.dummy_model() __snake_case : Any = self.dummy_sample_deter scheduler.set_timesteps(__a ) for i, t in enumerate(scheduler.prk_timesteps ): __snake_case : List[str] = model(__a , __a ) __snake_case : Optional[Any] = scheduler.step_prk(__a , __a , __a ).prev_sample for i, t in enumerate(scheduler.plms_timesteps ): __snake_case : Dict = model(__a , __a ) __snake_case : List[Any] = scheduler.step_plms(__a , __a , __a ).prev_sample return sample def A_ ( self : int ) -> str: '''simple docstring''' __snake_case : int = dict(self.forward_default_kwargs ) __snake_case : Any = kwargs.pop('num_inference_steps' , __a ) for scheduler_class in self.scheduler_classes: __snake_case : List[Any] = self.get_scheduler_config() __snake_case : Tuple = scheduler_class(**__a ) __snake_case : List[Any] = self.dummy_sample __snake_case : Union[str, Any] = 0.1 * sample if num_inference_steps is not None and hasattr(__a , 'set_timesteps' ): scheduler.set_timesteps(__a ) elif num_inference_steps is not None and not hasattr(__a , 'set_timesteps' ): __snake_case : Dict = num_inference_steps # copy over dummy past residuals (must be done after set_timesteps) __snake_case : str = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5] __snake_case : Optional[Any] = dummy_past_residuals[:] __snake_case : Optional[int] = scheduler.step_prk(__a , 0 , __a , **__a ).prev_sample __snake_case : Union[str, Any] = scheduler.step_prk(__a , 1 , __a , **__a ).prev_sample self.assertEqual(output_a.shape , sample.shape ) self.assertEqual(output_a.shape , output_a.shape ) __snake_case : List[Any] = scheduler.step_plms(__a , 0 , __a , **__a ).prev_sample __snake_case : List[str] = scheduler.step_plms(__a , 1 , __a , **__a ).prev_sample self.assertEqual(output_a.shape , sample.shape ) self.assertEqual(output_a.shape , output_a.shape ) def A_ ( self : str ) -> Optional[Any]: '''simple docstring''' for timesteps in [100, 1000]: self.check_over_configs(num_train_timesteps=__a ) def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' for steps_offset in [0, 1]: self.check_over_configs(steps_offset=__a ) __snake_case : str = self.scheduler_classes[0] __snake_case : List[Any] = self.get_scheduler_config(steps_offset=1 ) __snake_case : int = scheduler_class(**__a ) scheduler.set_timesteps(10 ) assert torch.equal( scheduler.timesteps , torch.LongTensor( [901, 851, 851, 801, 801, 751, 751, 701, 701, 651, 651, 601, 601, 501, 401, 301, 201, 101, 1] ) , ) def A_ ( self : int ) -> List[str]: '''simple docstring''' for beta_start, beta_end in zip([0.0_0_0_1, 0.0_0_1] , [0.0_0_2, 0.0_2] ): self.check_over_configs(beta_start=__a , beta_end=__a ) def A_ ( self : Dict ) -> Any: '''simple docstring''' for schedule in ["linear", "squaredcos_cap_v2"]: self.check_over_configs(beta_schedule=__a ) def A_ ( self : Optional[int] ) -> int: '''simple docstring''' for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=__a ) def A_ ( self : Tuple ) -> int: '''simple docstring''' for t in [1, 5, 10]: self.check_over_forward(time_step=__a ) def A_ ( self : List[str] ) -> Any: '''simple docstring''' for t, num_inference_steps in zip([1, 5, 10] , [10, 50, 100] ): self.check_over_forward(num_inference_steps=__a ) def A_ ( self : Union[str, Any] ) -> Tuple: '''simple docstring''' __snake_case : Dict = 27 for scheduler_class in self.scheduler_classes: __snake_case : int = self.dummy_sample __snake_case : str = 0.1 * sample __snake_case : Optional[Any] = self.get_scheduler_config() __snake_case : Union[str, Any] = scheduler_class(**__a ) scheduler.set_timesteps(__a ) # before power of 3 fix, would error on first step, so we only need to do two for i, t in enumerate(scheduler.prk_timesteps[:2] ): __snake_case : int = scheduler.step_prk(__a , __a , __a ).prev_sample def A_ ( self : Tuple ) -> str: '''simple docstring''' with self.assertRaises(__a ): __snake_case : int = self.scheduler_classes[0] __snake_case : int = self.get_scheduler_config() __snake_case : List[Any] = scheduler_class(**__a ) scheduler.step_plms(self.dummy_sample , 1 , self.dummy_sample ).prev_sample def A_ ( self : Dict ) -> int: '''simple docstring''' __snake_case : Tuple = self.full_loop() __snake_case : int = torch.sum(torch.abs(__a ) ) __snake_case : List[str] = torch.mean(torch.abs(__a ) ) assert abs(result_sum.item() - 198.1318 ) < 1e-2 assert abs(result_mean.item() - 0.2_5_8_0 ) < 1e-3 def A_ ( self : List[str] ) -> int: '''simple docstring''' __snake_case : List[str] = self.full_loop(prediction_type='v_prediction' ) __snake_case : int = torch.sum(torch.abs(__a ) ) __snake_case : Union[str, Any] = torch.mean(torch.abs(__a ) ) assert abs(result_sum.item() - 67.3986 ) < 1e-2 assert abs(result_mean.item() - 0.0_8_7_8 ) < 1e-3 def A_ ( self : Dict ) -> str: '''simple docstring''' __snake_case : Any = self.full_loop(set_alpha_to_one=__a , beta_start=0.0_1 ) __snake_case : int = torch.sum(torch.abs(__a ) ) __snake_case : Optional[Any] = torch.mean(torch.abs(__a ) ) assert abs(result_sum.item() - 230.0399 ) < 1e-2 assert abs(result_mean.item() - 0.2_9_9_5 ) < 1e-3 def A_ ( self : int ) -> Tuple: '''simple docstring''' __snake_case : str = self.full_loop(set_alpha_to_one=__a , beta_start=0.0_1 ) __snake_case : List[Any] = torch.sum(torch.abs(__a ) ) __snake_case : Any = torch.mean(torch.abs(__a ) ) assert abs(result_sum.item() - 186.9482 ) < 1e-2 assert abs(result_mean.item() - 0.2_4_3_4 ) < 1e-3

'''simple docstring''' def a_ ( _UpperCAmelCase : int ) -> bool: __snake_case : Union[str, Any] = n ** (1 / 3) return (val * val * val) == n if __name__ == "__main__": print(perfect_cube(2_7)) print(perfect_cube(4))

'''simple docstring''' from __future__ import annotations import math import random from typing import Any class snake_case__ : def __init__( self : List[str] ) -> None: '''simple docstring''' __snake_case : list[Any] = [] __snake_case : int = 0 __snake_case : int = 0 def A_ ( self : Tuple ) -> bool: '''simple docstring''' return self.head == self.tail def A_ ( self : int , __a : Any ) -> None: '''simple docstring''' self.data.append(__a ) __snake_case : Optional[int] = self.tail + 1 def A_ ( self : Dict ) -> Any: '''simple docstring''' __snake_case : Any = self.data[self.head] __snake_case : Dict = self.head + 1 return ret def A_ ( self : List[str] ) -> int: '''simple docstring''' return self.tail - self.head def A_ ( self : Union[str, Any] ) -> None: '''simple docstring''' print(self.data ) print('**************' ) print(self.data[self.head : self.tail] ) class snake_case__ : def __init__( self : List[Any] , __a : Any ) -> None: '''simple docstring''' __snake_case : List[str] = data __snake_case : MyNode | None = None __snake_case : MyNode | None = None __snake_case : int = 1 def A_ ( self : Dict ) -> Any: '''simple docstring''' return self.data def A_ ( self : List[str] ) -> MyNode | None: '''simple docstring''' return self.left def A_ ( self : Optional[Any] ) -> MyNode | None: '''simple docstring''' return self.right def A_ ( self : Optional[Any] ) -> int: '''simple docstring''' return self.height def A_ ( self : Tuple , __a : Any ) -> None: '''simple docstring''' __snake_case : Dict = data def A_ ( self : List[str] , __a : MyNode | None ) -> None: '''simple docstring''' __snake_case : List[str] = node def A_ ( self : str , __a : MyNode | None ) -> None: '''simple docstring''' __snake_case : int = node def A_ ( self : Tuple , __a : int ) -> None: '''simple docstring''' __snake_case : Tuple = height def a_ ( _UpperCAmelCase : MyNode | None ) -> int: if node is None: return 0 return node.get_height() def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : int ) -> int: if a > b: return a return b def a_ ( _UpperCAmelCase : MyNode ) -> MyNode: print('left rotation node:' ,node.get_data() ) __snake_case : Any = node.get_left() assert ret is not None node.set_left(ret.get_right() ) ret.set_right(_UpperCAmelCase ) __snake_case : Optional[int] = my_max(get_height(node.get_right() ) ,get_height(node.get_left() ) ) + 1 node.set_height(_UpperCAmelCase ) __snake_case : Optional[Any] = my_max(get_height(ret.get_right() ) ,get_height(ret.get_left() ) ) + 1 ret.set_height(_UpperCAmelCase ) return ret def a_ ( _UpperCAmelCase : MyNode ) -> MyNode: print('right rotation node:' ,node.get_data() ) __snake_case : Dict = node.get_right() assert ret is not None node.set_right(ret.get_left() ) ret.set_left(_UpperCAmelCase ) __snake_case : Union[str, Any] = my_max(get_height(node.get_right() ) ,get_height(node.get_left() ) ) + 1 node.set_height(_UpperCAmelCase ) __snake_case : List[str] = my_max(get_height(ret.get_right() ) ,get_height(ret.get_left() ) ) + 1 ret.set_height(_UpperCAmelCase ) return ret def a_ ( _UpperCAmelCase : MyNode ) -> MyNode: __snake_case : str = node.get_left() assert left_child is not None node.set_left(left_rotation(_UpperCAmelCase ) ) return right_rotation(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : MyNode ) -> MyNode: __snake_case : int = node.get_right() assert right_child is not None node.set_right(right_rotation(_UpperCAmelCase ) ) return left_rotation(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : MyNode | None ,_UpperCAmelCase : Any ) -> MyNode | None: if node is None: return MyNode(_UpperCAmelCase ) if data < node.get_data(): node.set_left(insert_node(node.get_left() ,_UpperCAmelCase ) ) if ( get_height(node.get_left() ) - get_height(node.get_right() ) == 2 ): # an unbalance detected __snake_case : List[str] = node.get_left() assert left_child is not None if ( data < left_child.get_data() ): # new node is the left child of the left child __snake_case : Any = right_rotation(_UpperCAmelCase ) else: __snake_case : List[Any] = lr_rotation(_UpperCAmelCase ) else: node.set_right(insert_node(node.get_right() ,_UpperCAmelCase ) ) if get_height(node.get_right() ) - get_height(node.get_left() ) == 2: __snake_case : Dict = node.get_right() assert right_child is not None if data < right_child.get_data(): __snake_case : Tuple = rl_rotation(_UpperCAmelCase ) else: __snake_case : int = left_rotation(_UpperCAmelCase ) __snake_case : Optional[Any] = my_max(get_height(node.get_right() ) ,get_height(node.get_left() ) ) + 1 node.set_height(_UpperCAmelCase ) return node def a_ ( _UpperCAmelCase : MyNode ) -> Any: while True: __snake_case : int = root.get_right() if right_child is None: break __snake_case : int = right_child return root.get_data() def a_ ( _UpperCAmelCase : MyNode ) -> Any: while True: __snake_case : List[Any] = root.get_left() if left_child is None: break __snake_case : List[str] = left_child return root.get_data() def a_ ( _UpperCAmelCase : MyNode ,_UpperCAmelCase : Any ) -> MyNode | None: __snake_case : Tuple = root.get_left() __snake_case : int = root.get_right() if root.get_data() == data: if left_child is not None and right_child is not None: __snake_case : Any = get_left_most(_UpperCAmelCase ) root.set_data(_UpperCAmelCase ) root.set_right(del_node(_UpperCAmelCase ,_UpperCAmelCase ) ) elif left_child is not None: __snake_case : Tuple = left_child elif right_child is not None: __snake_case : str = right_child else: return None elif root.get_data() > data: if left_child is None: print('No such data' ) return root else: root.set_left(del_node(_UpperCAmelCase ,_UpperCAmelCase ) ) else: # root.get_data() < data if right_child is None: return root else: root.set_right(del_node(_UpperCAmelCase ,_UpperCAmelCase ) ) if get_height(_UpperCAmelCase ) - get_height(_UpperCAmelCase ) == 2: assert right_child is not None if get_height(right_child.get_right() ) > get_height(right_child.get_left() ): __snake_case : List[Any] = left_rotation(_UpperCAmelCase ) else: __snake_case : Tuple = rl_rotation(_UpperCAmelCase ) elif get_height(_UpperCAmelCase ) - get_height(_UpperCAmelCase ) == -2: assert left_child is not None if get_height(left_child.get_left() ) > get_height(left_child.get_right() ): __snake_case : List[Any] = right_rotation(_UpperCAmelCase ) else: __snake_case : Any = lr_rotation(_UpperCAmelCase ) __snake_case : List[str] = my_max(get_height(root.get_right() ) ,get_height(root.get_left() ) ) + 1 root.set_height(_UpperCAmelCase ) return root class snake_case__ : def __init__( self : Dict ) -> None: '''simple docstring''' __snake_case : MyNode | None = None def A_ ( self : str ) -> int: '''simple docstring''' return get_height(self.root ) def A_ ( self : List[str] , __a : Any ) -> None: '''simple docstring''' print('insert:' + str(__a ) ) __snake_case : Optional[Any] = insert_node(self.root , __a ) def A_ ( self : Union[str, Any] , __a : Any ) -> None: '''simple docstring''' print('delete:' + str(__a ) ) if self.root is None: print('Tree is empty!' ) return __snake_case : Optional[Any] = del_node(self.root , __a ) def __str__( self : Optional[Any] , ) -> str: # a level traversale, gives a more intuitive look on the tree '''simple docstring''' __snake_case : Union[str, Any] = '' __snake_case : List[Any] = MyQueue() q.push(self.root ) __snake_case : Dict = self.get_height() if layer == 0: return output __snake_case : Any = 0 while not q.is_empty(): __snake_case : List[str] = q.pop() __snake_case : List[Any] = ' ' * int(math.pow(2 , layer - 1 ) ) output += space if node is None: output += "*" q.push(__a ) q.push(__a ) else: output += str(node.get_data() ) q.push(node.get_left() ) q.push(node.get_right() ) output += space __snake_case : Dict = cnt + 1 for i in range(100 ): if cnt == math.pow(2 , __a ) - 1: __snake_case : Union[str, Any] = layer - 1 if layer == 0: output += "\n*************************************" return output output += "\n" break output += "\n*************************************" return output def a_ ( ) -> None: import doctest doctest.testmod() if __name__ == "__main__": _test() A__ = AVLtree() A__ = list(range(1_0)) random.shuffle(lst) for i in lst: t.insert(i) print(str(t)) random.shuffle(lst) for i in lst: t.del_node(i) print(str(t))

'''simple docstring''' import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss A__ : Tuple = pytest.mark.integration @require_faiss class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : Any ) -> Tuple: '''simple docstring''' __snake_case : Dict = Dataset.from_dict({'filename': ['my_name-train' + '_' + str(__a ) for x in np.arange(30 ).tolist()]} ) return dset def A_ ( self : Union[str, Any] ) -> List[Any]: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() __snake_case : Dict = dset.map( lambda __a , __a : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=__a , keep_in_memory=__a ) __snake_case : List[Any] = dset.add_faiss_index('vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) __snake_case , __snake_case : Any = dset.get_nearest_examples('vecs' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) dset.drop_index('vecs' ) def A_ ( self : Tuple ) -> Any: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) __snake_case , __snake_case : Any = dset.get_nearest_examples('vecs' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self : List[Any] ) -> Dict: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__a ) as tmp_file: dset.save_faiss_index('vecs' , tmp_file.name ) dset.load_faiss_index('vecs2' , tmp_file.name ) os.unlink(tmp_file.name ) __snake_case , __snake_case : str = dset.get_nearest_examples('vecs2' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self : Union[str, Any] ) -> Dict: '''simple docstring''' __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' ) dset.drop_index('vecs' ) self.assertRaises(__a , partial(dset.get_nearest_examples , 'vecs2' , np.ones(5 , dtype=np.floataa ) ) ) def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' from elasticsearch import Elasticsearch __snake_case : Dataset = self._create_dummy_dataset() with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch( 'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk: __snake_case : Any = {'acknowledged': True} mocked_bulk.return_value([(True, None)] * 30 ) __snake_case : Dict = {'hits': {'hits': [{'_score': 1, '_id': 29}]}} __snake_case : Union[str, Any] = Elasticsearch() dset.add_elasticsearch_index('filename' , es_client=__a ) __snake_case , __snake_case : str = dset.get_nearest_examples('filename' , 'my_name-train_29' ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) @require_faiss class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : str ) -> int: '''simple docstring''' import faiss __snake_case : int = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query __snake_case : Dict = np.zeros(5 , dtype=np.floataa ) __snake_case : List[str] = 1 __snake_case , __snake_case : List[Any] = index.search(__a ) self.assertRaises(__a , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries __snake_case : List[str] = np.eye(5 , dtype=np.floataa )[::-1] __snake_case , __snake_case : Dict = index.search_batch(__a ) self.assertRaises(__a , index.search_batch , queries[0] ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : List[Any] = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , __a ) def A_ ( self : int ) -> int: '''simple docstring''' import faiss __snake_case : int = FaissIndex(string_factory='Flat' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) __snake_case : List[str] = FaissIndex(string_factory='LSH' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(__a ): __snake_case : Dict = FaissIndex(string_factory='Flat' , custom_index=faiss.IndexFlat(5 ) ) def A_ ( self : str ) -> Dict: '''simple docstring''' import faiss __snake_case : Tuple = faiss.IndexFlat(5 ) __snake_case : List[Any] = FaissIndex(custom_index=__a ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def A_ ( self : List[Any] ) -> int: '''simple docstring''' import faiss __snake_case : Optional[Any] = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__a ) as tmp_file: index.save(tmp_file.name ) __snake_case : List[Any] = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) __snake_case : List[Any] = np.zeros(5 , dtype=np.floataa ) __snake_case : Any = 1 __snake_case , __snake_case : int = index.search(__a ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def a_ ( _UpperCAmelCase : str ) -> Optional[int]: import faiss __snake_case : int = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 ,dtype=np.floataa ) ) __snake_case : Dict = 'index.faiss' __snake_case : Any = f'''mock://{index_name}''' index.save(_UpperCAmelCase ,storage_options=mockfs.storage_options ) __snake_case : Any = FaissIndex.load(_UpperCAmelCase ,storage_options=mockfs.storage_options ) __snake_case : Any = np.zeros(5 ,dtype=np.floataa ) __snake_case : Any = 1 __snake_case , __snake_case : Tuple = index.search(_UpperCAmelCase ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' from elasticsearch import Elasticsearch with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch( 'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk: __snake_case : int = Elasticsearch() __snake_case : Dict = {'acknowledged': True} __snake_case : List[Any] = ElasticSearchIndex(es_client=__a ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(['foo', 'bar', 'foobar'] ) # single query __snake_case : Optional[Any] = 'foo' __snake_case : int = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} __snake_case , __snake_case : List[Any] = index.search(__a ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout __snake_case : Dict = 'foo' __snake_case : Dict = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} __snake_case , __snake_case : Optional[Any] = index.search(__a , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries __snake_case : List[Any] = ['foo', 'bar', 'foobar'] __snake_case : str = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} __snake_case , __snake_case : Any = index.search_batch(__a ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : Tuple = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([1, 1, 1] , __a ) # batched queries with timeout __snake_case : Tuple = ['foo', 'bar', 'foobar'] __snake_case : List[Any] = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} __snake_case , __snake_case : int = index.search_batch(__a , request_timeout=30 ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : Dict = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([1, 1, 1] , __a )

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging A__ : List[Any] = logging.get_logger(__name__) A__ : int = { '''caidas/swin2sr-classicalsr-x2-64''': ( '''https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json''' ), } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''swin2sr''' A__ = { '''hidden_size''': '''embed_dim''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers''', } def __init__( self : Optional[Any] , __a : List[Any]=64 , __a : Dict=1 , __a : Dict=3 , __a : List[str]=180 , __a : Union[str, Any]=[6, 6, 6, 6, 6, 6] , __a : Any=[6, 6, 6, 6, 6, 6] , __a : int=8 , __a : int=2.0 , __a : List[str]=True , __a : str=0.0 , __a : Any=0.0 , __a : str=0.1 , __a : List[str]="gelu" , __a : str=False , __a : str=0.0_2 , __a : List[Any]=1e-5 , __a : Union[str, Any]=2 , __a : List[str]=1.0 , __a : Tuple="1conv" , __a : Dict="pixelshuffle" , **__a : Dict , ): '''simple docstring''' super().__init__(**__a ) __snake_case : Any = image_size __snake_case : Union[str, Any] = patch_size __snake_case : Tuple = num_channels __snake_case : int = embed_dim __snake_case : Dict = depths __snake_case : Tuple = len(__a ) __snake_case : Union[str, Any] = num_heads __snake_case : Optional[Any] = window_size __snake_case : List[str] = mlp_ratio __snake_case : int = qkv_bias __snake_case : str = hidden_dropout_prob __snake_case : Union[str, Any] = attention_probs_dropout_prob __snake_case : Optional[Any] = drop_path_rate __snake_case : str = hidden_act __snake_case : str = use_absolute_embeddings __snake_case : int = layer_norm_eps __snake_case : List[Any] = initializer_range __snake_case : int = upscale __snake_case : int = img_range __snake_case : Dict = resi_connection __snake_case : Dict = upsampler

'''simple docstring''' from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxSeqaSeqConfigWithPast from ...utils import logging A__ : List[Any] = logging.get_logger(__name__) A__ : Tuple = { '''t5-small''': '''https://huggingface.co/t5-small/resolve/main/config.json''', '''t5-base''': '''https://huggingface.co/t5-base/resolve/main/config.json''', '''t5-large''': '''https://huggingface.co/t5-large/resolve/main/config.json''', '''t5-3b''': '''https://huggingface.co/t5-3b/resolve/main/config.json''', '''t5-11b''': '''https://huggingface.co/t5-11b/resolve/main/config.json''', } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''t5''' A__ = ['''past_key_values'''] A__ = {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : str , __a : Dict=32128 , __a : Dict=512 , __a : Union[str, Any]=64 , __a : str=2048 , __a : Union[str, Any]=6 , __a : Any=None , __a : Any=8 , __a : List[Any]=32 , __a : Any=128 , __a : Tuple=0.1 , __a : str=1e-6 , __a : Dict=1.0 , __a : Tuple="relu" , __a : Dict=True , __a : Union[str, Any]=True , __a : Any=0 , __a : Dict=1 , **__a : Union[str, Any] , ) -> Union[str, Any]: '''simple docstring''' __snake_case : int = vocab_size __snake_case : str = d_model __snake_case : str = d_kv __snake_case : List[Any] = d_ff __snake_case : List[str] = num_layers __snake_case : Tuple = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry __snake_case : Union[str, Any] = num_heads __snake_case : Tuple = relative_attention_num_buckets __snake_case : Optional[int] = relative_attention_max_distance __snake_case : Optional[Any] = dropout_rate __snake_case : str = layer_norm_epsilon __snake_case : List[str] = initializer_factor __snake_case : int = feed_forward_proj __snake_case : Optional[Any] = use_cache __snake_case : Optional[Any] = self.feed_forward_proj.split('-' ) __snake_case : Dict = act_info[-1] __snake_case : List[str] = act_info[0] == 'gated' if len(__a ) > 1 and act_info[0] != "gated" or len(__a ) > 2: raise ValueError( f'''`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.''' 'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. ' '\'gated-gelu\' or \'relu\'' ) # for backwards compatibility if feed_forward_proj == "gated-gelu": __snake_case : Dict = 'gelu_new' super().__init__( pad_token_id=__a , eos_token_id=__a , is_encoder_decoder=__a , **__a , ) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): @property def A_ ( self : str ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' __snake_case : Union[str, Any] = { 'input_ids': {0: 'batch', 1: 'encoder_sequence'}, 'attention_mask': {0: 'batch', 1: 'encoder_sequence'}, } if self.use_past: __snake_case : Tuple = 'past_encoder_sequence + sequence' __snake_case : Dict = {0: 'batch'} __snake_case : Dict = {0: 'batch', 1: 'past_decoder_sequence + sequence'} else: __snake_case : Tuple = {0: 'batch', 1: 'decoder_sequence'} __snake_case : int = {0: 'batch', 1: 'decoder_sequence'} if self.use_past: self.fill_with_past_key_values_(__a , direction='inputs' ) return common_inputs @property def A_ ( self : List[Any] ) -> int: '''simple docstring''' return 13

'''simple docstring''' import tempfile import torch from diffusers import ( DEISMultistepScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, UniPCMultistepScheduler, ) from .test_schedulers import SchedulerCommonTest class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = (DEISMultistepScheduler,) A__ = (('''num_inference_steps''', 25),) def A_ ( self : Tuple , **__a : Dict ) -> List[Any]: '''simple docstring''' __snake_case : int = { 'num_train_timesteps': 1000, 'beta_start': 0.0_0_0_1, 'beta_end': 0.0_2, 'beta_schedule': 'linear', 'solver_order': 2, } config.update(**__a ) return config def A_ ( self : List[str] , __a : List[str]=0 , **__a : List[str] ) -> List[Any]: '''simple docstring''' __snake_case : Any = dict(self.forward_default_kwargs ) __snake_case : int = kwargs.pop('num_inference_steps' , __a ) __snake_case : List[Any] = self.dummy_sample __snake_case : int = 0.1 * sample __snake_case : Any = [residual + 0.2, residual + 0.1_5, residual + 0.1_0] for scheduler_class in self.scheduler_classes: __snake_case : Optional[Any] = self.get_scheduler_config(**__a ) __snake_case : Optional[Any] = scheduler_class(**__a ) scheduler.set_timesteps(__a ) # copy over dummy past residuals __snake_case : int = dummy_past_residuals[: scheduler.config.solver_order] with tempfile.TemporaryDirectory() as tmpdirname: scheduler.save_config(__a ) __snake_case : Dict = scheduler_class.from_pretrained(__a ) new_scheduler.set_timesteps(__a ) # copy over dummy past residuals __snake_case : str = dummy_past_residuals[: new_scheduler.config.solver_order] __snake_case : Any = sample, sample for t in range(__a , time_step + scheduler.config.solver_order + 1 ): __snake_case : List[str] = scheduler.step(__a , __a , __a , **__a ).prev_sample __snake_case : Optional[Any] = new_scheduler.step(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" def A_ ( self : Union[str, Any] ) -> str: '''simple docstring''' pass def A_ ( self : Tuple , __a : List[str]=0 , **__a : List[str] ) -> str: '''simple docstring''' __snake_case : List[str] = dict(self.forward_default_kwargs ) __snake_case : int = kwargs.pop('num_inference_steps' , __a ) __snake_case : Tuple = self.dummy_sample __snake_case : List[Any] = 0.1 * sample __snake_case : Dict = [residual + 0.2, residual + 0.1_5, residual + 0.1_0] for scheduler_class in self.scheduler_classes: __snake_case : Optional[Any] = self.get_scheduler_config() __snake_case : Optional[Any] = scheduler_class(**__a ) scheduler.set_timesteps(__a ) # copy over dummy past residuals (must be after setting timesteps) __snake_case : List[Any] = dummy_past_residuals[: scheduler.config.solver_order] with tempfile.TemporaryDirectory() as tmpdirname: scheduler.save_config(__a ) __snake_case : Optional[int] = scheduler_class.from_pretrained(__a ) # copy over dummy past residuals new_scheduler.set_timesteps(__a ) # copy over dummy past residual (must be after setting timesteps) __snake_case : Optional[Any] = dummy_past_residuals[: new_scheduler.config.solver_order] __snake_case : Any = scheduler.step(__a , __a , __a , **__a ).prev_sample __snake_case : str = new_scheduler.step(__a , __a , __a , **__a ).prev_sample assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical" def A_ ( self : List[str] , __a : List[Any]=None , **__a : List[str] ) -> Any: '''simple docstring''' if scheduler is None: __snake_case : Any = self.scheduler_classes[0] __snake_case : Optional[int] = self.get_scheduler_config(**__a ) __snake_case : List[Any] = scheduler_class(**__a ) __snake_case : int = self.scheduler_classes[0] __snake_case : int = self.get_scheduler_config(**__a ) __snake_case : List[Any] = scheduler_class(**__a ) __snake_case : Any = 10 __snake_case : List[str] = self.dummy_model() __snake_case : List[Any] = self.dummy_sample_deter scheduler.set_timesteps(__a ) for i, t in enumerate(scheduler.timesteps ): __snake_case : str = model(__a , __a ) __snake_case : Optional[Any] = scheduler.step(__a , __a , __a ).prev_sample return sample def A_ ( self : Any ) -> Optional[Any]: '''simple docstring''' __snake_case : Tuple = dict(self.forward_default_kwargs ) __snake_case : List[Any] = kwargs.pop('num_inference_steps' , __a ) for scheduler_class in self.scheduler_classes: __snake_case : Any = self.get_scheduler_config() __snake_case : Tuple = scheduler_class(**__a ) __snake_case : Tuple = self.dummy_sample __snake_case : Tuple = 0.1 * sample if num_inference_steps is not None and hasattr(__a , 'set_timesteps' ): scheduler.set_timesteps(__a ) elif num_inference_steps is not None and not hasattr(__a , 'set_timesteps' ): __snake_case : Dict = num_inference_steps # copy over dummy past residuals (must be done after set_timesteps) __snake_case : int = [residual + 0.2, residual + 0.1_5, residual + 0.1_0] __snake_case : Optional[int] = dummy_past_residuals[: scheduler.config.solver_order] __snake_case : Union[str, Any] = scheduler.timesteps[5] __snake_case : int = scheduler.timesteps[6] __snake_case : List[Any] = scheduler.step(__a , __a , __a , **__a ).prev_sample __snake_case : Tuple = scheduler.step(__a , __a , __a , **__a ).prev_sample self.assertEqual(output_a.shape , sample.shape ) self.assertEqual(output_a.shape , output_a.shape ) def A_ ( self : Optional[int] ) -> List[str]: '''simple docstring''' __snake_case : List[str] = DEISMultistepScheduler(**self.get_scheduler_config() ) __snake_case : List[str] = self.full_loop(scheduler=__a ) __snake_case : Optional[int] = torch.mean(torch.abs(__a ) ) assert abs(result_mean.item() - 0.2_3_9_1_6 ) < 1e-3 __snake_case : str = DPMSolverSinglestepScheduler.from_config(scheduler.config ) __snake_case : Union[str, Any] = DPMSolverMultistepScheduler.from_config(scheduler.config ) __snake_case : Union[str, Any] = UniPCMultistepScheduler.from_config(scheduler.config ) __snake_case : Optional[Any] = DEISMultistepScheduler.from_config(scheduler.config ) __snake_case : List[Any] = self.full_loop(scheduler=__a ) __snake_case : int = torch.mean(torch.abs(__a ) ) assert abs(result_mean.item() - 0.2_3_9_1_6 ) < 1e-3 def A_ ( self : Union[str, Any] ) -> List[Any]: '''simple docstring''' for timesteps in [25, 50, 100, 999, 1000]: self.check_over_configs(num_train_timesteps=__a ) def A_ ( self : Union[str, Any] ) -> Dict: '''simple docstring''' self.check_over_configs(thresholding=__a ) for order in [1, 2, 3]: for solver_type in ["logrho"]: for threshold in [0.5, 1.0, 2.0]: for prediction_type in ["epsilon", "sample"]: self.check_over_configs( thresholding=__a , prediction_type=__a , sample_max_value=__a , algorithm_type='deis' , solver_order=__a , solver_type=__a , ) def A_ ( self : List[str] ) -> Any: '''simple docstring''' for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=__a ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' for algorithm_type in ["deis"]: for solver_type in ["logrho"]: for order in [1, 2, 3]: for prediction_type in ["epsilon", "sample"]: self.check_over_configs( solver_order=__a , solver_type=__a , prediction_type=__a , algorithm_type=__a , ) __snake_case : Union[str, Any] = self.full_loop( solver_order=__a , solver_type=__a , prediction_type=__a , algorithm_type=__a , ) assert not torch.isnan(__a ).any(), "Samples have nan numbers" def A_ ( self : Optional[Any] ) -> List[Any]: '''simple docstring''' self.check_over_configs(lower_order_final=__a ) self.check_over_configs(lower_order_final=__a ) def A_ ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]: self.check_over_forward(num_inference_steps=__a , time_step=0 ) def A_ ( self : List[Any] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Any = self.full_loop() __snake_case : List[Any] = torch.mean(torch.abs(__a ) ) assert abs(result_mean.item() - 0.2_3_9_1_6 ) < 1e-3 def A_ ( self : Optional[Any] ) -> Optional[int]: '''simple docstring''' __snake_case : int = self.full_loop(prediction_type='v_prediction' ) __snake_case : Any = torch.mean(torch.abs(__a ) ) assert abs(result_mean.item() - 0.0_9_1 ) < 1e-3 def A_ ( self : Tuple ) -> int: '''simple docstring''' __snake_case : int = self.scheduler_classes[0] __snake_case : Dict = self.get_scheduler_config(thresholding=__a , dynamic_thresholding_ratio=0 ) __snake_case : List[str] = scheduler_class(**__a ) __snake_case : Dict = 10 __snake_case : Optional[int] = self.dummy_model() __snake_case : Dict = self.dummy_sample_deter.half() scheduler.set_timesteps(__a ) for i, t in enumerate(scheduler.timesteps ): __snake_case : List[Any] = model(__a , __a ) __snake_case : List[str] = scheduler.step(__a , __a , __a ).prev_sample assert sample.dtype == torch.floataa

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging A__ : Tuple = logging.get_logger(__name__) A__ : Optional[int] = {} class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''llama''' A__ = ['''past_key_values'''] def __init__( self : Any , __a : List[str]=32000 , __a : Union[str, Any]=4096 , __a : Optional[Any]=11008 , __a : Any=32 , __a : str=32 , __a : Optional[int]=None , __a : Dict="silu" , __a : Dict=2048 , __a : List[str]=0.0_2 , __a : Union[str, Any]=1e-6 , __a : Dict=True , __a : List[str]=0 , __a : Tuple=1 , __a : Tuple=2 , __a : Optional[Any]=1 , __a : Any=False , __a : Tuple=None , **__a : List[Any] , ) -> Optional[int]: '''simple docstring''' __snake_case : str = vocab_size __snake_case : List[str] = max_position_embeddings __snake_case : List[Any] = hidden_size __snake_case : Union[str, Any] = intermediate_size __snake_case : Optional[int] = num_hidden_layers __snake_case : List[Any] = num_attention_heads # for backward compatibility if num_key_value_heads is None: __snake_case : Optional[int] = num_attention_heads __snake_case : Optional[Any] = num_key_value_heads __snake_case : int = hidden_act __snake_case : Any = initializer_range __snake_case : Any = rms_norm_eps __snake_case : Union[str, Any] = pretraining_tp __snake_case : Optional[int] = use_cache __snake_case : Any = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=__a , bos_token_id=__a , eos_token_id=__a , tie_word_embeddings=__a , **__a , ) def A_ ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' if self.rope_scaling is None: return if not isinstance(self.rope_scaling , __a ) or len(self.rope_scaling ) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' f'''got {self.rope_scaling}''' ) __snake_case : Optional[Any] = self.rope_scaling.get('type' , __a ) __snake_case : Tuple = self.rope_scaling.get('factor' , __a ) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( f'''`rope_scaling`\'s name field must be one of [\'linear\', \'dynamic\'], got {rope_scaling_type}''' ) if rope_scaling_factor is None or not isinstance(__a , __a ) or rope_scaling_factor <= 1.0: raise ValueError(f'''`rope_scaling`\'s factor field must be an float > 1, got {rope_scaling_factor}''' )

'''simple docstring''' from ...configuration_utils import PretrainedConfig A__ : Tuple = { '''google/tapas-base-finetuned-sqa''': ( '''https://huggingface.co/google/tapas-base-finetuned-sqa/resolve/main/config.json''' ), '''google/tapas-base-finetuned-wtq''': ( '''https://huggingface.co/google/tapas-base-finetuned-wtq/resolve/main/config.json''' ), '''google/tapas-base-finetuned-wikisql-supervised''': ( '''https://huggingface.co/google/tapas-base-finetuned-wikisql-supervised/resolve/main/config.json''' ), '''google/tapas-base-finetuned-tabfact''': ( '''https://huggingface.co/google/tapas-base-finetuned-tabfact/resolve/main/config.json''' ), } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): """simple docstring""" A__ = '''tapas''' def __init__( self : Optional[int] , __a : List[Any]=30522 , __a : int=768 , __a : int=12 , __a : Tuple=12 , __a : List[Any]=3072 , __a : str="gelu" , __a : Union[str, Any]=0.1 , __a : Union[str, Any]=0.1 , __a : Union[str, Any]=1024 , __a : int=[3, 256, 256, 2, 256, 256, 10] , __a : Dict=0.0_2 , __a : int=1e-12 , __a : str=0 , __a : Dict=10.0 , __a : Tuple=0 , __a : Dict=1.0 , __a : str=None , __a : List[Any]=1.0 , __a : Union[str, Any]=False , __a : Any=None , __a : Optional[Any]=1.0 , __a : Dict=1.0 , __a : Dict=False , __a : List[str]=False , __a : List[Any]="ratio" , __a : Tuple=None , __a : str=None , __a : Dict=64 , __a : str=32 , __a : List[Any]=False , __a : int=True , __a : List[str]=False , __a : Any=False , __a : Dict=True , __a : Dict=False , __a : int=None , __a : Optional[int]=None , **__a : List[Any] , ) -> Dict: '''simple docstring''' super().__init__(pad_token_id=__a , **__a ) # BERT hyperparameters (with updated max_position_embeddings and type_vocab_sizes) __snake_case : Optional[int] = vocab_size __snake_case : str = hidden_size __snake_case : Optional[int] = num_hidden_layers __snake_case : Union[str, Any] = num_attention_heads __snake_case : Any = hidden_act __snake_case : str = intermediate_size __snake_case : Tuple = hidden_dropout_prob __snake_case : List[str] = attention_probs_dropout_prob __snake_case : Dict = max_position_embeddings __snake_case : List[str] = type_vocab_sizes __snake_case : str = initializer_range __snake_case : Tuple = layer_norm_eps # Fine-tuning task hyperparameters __snake_case : Optional[Any] = positive_label_weight __snake_case : Dict = num_aggregation_labels __snake_case : Optional[int] = aggregation_loss_weight __snake_case : List[str] = use_answer_as_supervision __snake_case : int = answer_loss_importance __snake_case : List[Any] = use_normalized_answer_loss __snake_case : Tuple = huber_loss_delta __snake_case : Union[str, Any] = temperature __snake_case : Optional[Any] = aggregation_temperature __snake_case : Tuple = use_gumbel_for_cells __snake_case : List[str] = use_gumbel_for_aggregation __snake_case : str = average_approximation_function __snake_case : Optional[int] = cell_selection_preference __snake_case : Union[str, Any] = answer_loss_cutoff __snake_case : Dict = max_num_rows __snake_case : int = max_num_columns __snake_case : Optional[Any] = average_logits_per_cell __snake_case : Any = select_one_column __snake_case : Any = allow_empty_column_selection __snake_case : str = init_cell_selection_weights_to_zero __snake_case : Union[str, Any] = reset_position_index_per_cell __snake_case : Optional[Any] = disable_per_token_loss # Aggregation hyperparameters __snake_case : Any = aggregation_labels __snake_case : int = no_aggregation_label_index if isinstance(self.aggregation_labels , __a ): __snake_case : int = {int(__a ): v for k, v in aggregation_labels.items()}

'''simple docstring''' from __future__ import annotations A__ : str = '''Muhammad Umer Farooq''' A__ : int = '''MIT''' A__ : Optional[int] = '''1.0.0''' A__ : List[Any] = '''Muhammad Umer Farooq''' A__ : Optional[Any] = '''[email protected]''' A__ : Optional[Any] = '''Alpha''' import re from html.parser import HTMLParser from urllib import parse import requests class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def __init__( self : Union[str, Any] , __a : str ) -> None: '''simple docstring''' super().__init__() __snake_case : list[str] = [] __snake_case : Dict = domain def A_ ( self : Dict , __a : str , __a : list[tuple[str, str | None]] ) -> None: '''simple docstring''' # Only parse the 'anchor' tag. if tag == "a": # Check the list of defined attributes. for name, value in attrs: # If href is defined, and not empty nor # print it. if name == "href" and value != "#" and value != "": # If not already in urls. if value not in self.urls: __snake_case : Optional[Any] = parse.urljoin(self.domain , __a ) self.urls.append(__a ) def a_ ( _UpperCAmelCase : str ) -> str: return ".".join(get_sub_domain_name(_UpperCAmelCase ).split('.' )[-2:] ) def a_ ( _UpperCAmelCase : str ) -> str: return parse.urlparse(_UpperCAmelCase ).netloc def a_ ( _UpperCAmelCase : str = "https://github.com" ) -> list[str]: __snake_case : List[Any] = get_domain_name(_UpperCAmelCase ) # Initialize the parser __snake_case : Tuple = Parser(_UpperCAmelCase ) try: # Open URL __snake_case : Any = requests.get(_UpperCAmelCase ) # pass the raw HTML to the parser to get links parser.feed(r.text ) # Get links and loop through __snake_case : Dict = set() for link in parser.urls: # open URL. # read = requests.get(link) try: __snake_case : List[Any] = requests.get(_UpperCAmelCase ) # Get the valid email. __snake_case : Optional[Any] = re.findall('[a-zA-Z0-9]+@' + domain ,read.text ) # If not in list then append it. for email in emails: valid_emails.add(_UpperCAmelCase ) except ValueError: pass except ValueError: raise SystemExit(1 ) # Finally return a sorted list of email addresses with no duplicates. return sorted(_UpperCAmelCase ) if __name__ == "__main__": A__ : Tuple = emails_from_url('''https://github.com''') print(F"""{len(emails)} emails found:""") print('''\n'''.join(sorted(emails)))

'''simple docstring''' 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 a_ ( ) -> str: __snake_case : str = 10 __snake_case : 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' ), } ) __snake_case : str = datasets.Dataset.from_dict( { 'tokens': [['foo'] * 5] * n, 'labels': [[1] * 5] * n, 'answers': [{'answer_start': [97], 'text': ['1976']}] * 10, 'id': list(range(_UpperCAmelCase ) ), } ,features=_UpperCAmelCase ,) return dataset @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Dict ,_UpperCAmelCase : Optional[int] ) -> List[Any]: __snake_case : Any = str(tmp_path_factory.mktemp('data' ) / 'file.arrow' ) dataset.map(cache_file_name=_UpperCAmelCase ) return filename # FILE_CONTENT + files A__ : Optional[int] = '''\ Text data. Second line of data.''' @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ) -> Union[str, Any]: __snake_case : int = tmp_path_factory.mktemp('data' ) / 'file.txt' __snake_case : Union[str, Any] = FILE_CONTENT with open(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ) return filename @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Dict ) -> Tuple: import bza __snake_case : Dict = tmp_path_factory.mktemp('data' ) / 'file.txt.bz2' __snake_case : Any = bytes(_UpperCAmelCase ,'utf-8' ) with bza.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : int ) -> str: import gzip __snake_case : Optional[int] = str(tmp_path_factory.mktemp('data' ) / 'file.txt.gz' ) __snake_case : Tuple = bytes(_UpperCAmelCase ,'utf-8' ) with gzip.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ) -> str: if datasets.config.LZ4_AVAILABLE: import lza.frame __snake_case : int = tmp_path_factory.mktemp('data' ) / 'file.txt.lz4' __snake_case : int = bytes(_UpperCAmelCase ,'utf-8' ) with lza.frame.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ,_UpperCAmelCase : List[Any] ) -> Optional[Any]: if datasets.config.PY7ZR_AVAILABLE: import pyazr __snake_case : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'file.txt.7z' with pyazr.SevenZipFile(_UpperCAmelCase ,'w' ) as archive: archive.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : Dict ) -> str: import tarfile __snake_case : int = tmp_path_factory.mktemp('data' ) / 'file.txt.tar' with tarfile.TarFile(_UpperCAmelCase ,'w' ) as f: f.add(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ) -> str: import lzma __snake_case : List[str] = tmp_path_factory.mktemp('data' ) / 'file.txt.xz' __snake_case : Tuple = bytes(_UpperCAmelCase ,'utf-8' ) with lzma.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[Any] ,_UpperCAmelCase : Tuple ) -> Dict: import zipfile __snake_case : int = tmp_path_factory.mktemp('data' ) / 'file.txt.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ) -> Any: if datasets.config.ZSTANDARD_AVAILABLE: import zstandard as zstd __snake_case : int = tmp_path_factory.mktemp('data' ) / 'file.txt.zst' __snake_case : int = bytes(_UpperCAmelCase ,'utf-8' ) with zstd.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[Any] ) -> Optional[int]: __snake_case : Tuple = tmp_path_factory.mktemp('data' ) / 'file.xml' __snake_case : str = 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(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ) return filename A__ : List[Any] = [ {'''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}, ] A__ : Any = [ {'''col_1''': '''4''', '''col_2''': 4, '''col_3''': 4.0}, {'''col_1''': '''5''', '''col_2''': 5, '''col_3''': 5.0}, ] A__ : Union[str, Any] = { '''col_1''': ['''0''', '''1''', '''2''', '''3'''], '''col_2''': [0, 1, 2, 3], '''col_3''': [0.0, 1.0, 2.0, 3.0], } A__ : int = [ {'''col_3''': 0.0, '''col_1''': '''0''', '''col_2''': 0}, {'''col_3''': 1.0, '''col_1''': '''1''', '''col_2''': 1}, ] A__ : Optional[Any] = [ {'''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 a_ ( ) -> List[Any]: return DATA_DICT_OF_LISTS @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[str] ) -> Any: __snake_case : Any = datasets.Dataset.from_dict(_UpperCAmelCase ) __snake_case : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset.arrow' ) dataset.map(cache_file_name=_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[Any] ) -> Optional[Any]: __snake_case : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.sqlite' ) with contextlib.closing(sqlitea.connect(_UpperCAmelCase ) ) as con: __snake_case : str = 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 a_ ( _UpperCAmelCase : Optional[int] ) -> Optional[int]: __snake_case : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.csv' ) with open(_UpperCAmelCase ,'w' ,newline='' ) as f: __snake_case : Optional[int] = csv.DictWriter(_UpperCAmelCase ,fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ) -> Tuple: __snake_case : List[str] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.csv' ) with open(_UpperCAmelCase ,'w' ,newline='' ) as f: __snake_case : Optional[int] = csv.DictWriter(_UpperCAmelCase ,fieldnames=['col_1', 'col_2', 'col_3'] ) writer.writeheader() for item in DATA: writer.writerow(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : str ) -> Optional[int]: import bza __snake_case : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.bz2' with open(_UpperCAmelCase ,'rb' ) as f: __snake_case : List[Any] = f.read() # data = bytes(FILE_CONTENT, "utf-8") with bza.open(_UpperCAmelCase ,'wb' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : Dict ) -> Any: __snake_case : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ,_UpperCAmelCase : Any ,_UpperCAmelCase : Optional[Any] ) -> Optional[int]: __snake_case : Dict = tmp_path_factory.mktemp('data' ) / 'dataset.csv.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(csv_path.replace('.csv' ,'.CSV' ) ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename(csva_path.replace('.csv' ,'.CSV' ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[str] ,_UpperCAmelCase : str ,_UpperCAmelCase : Tuple ) -> List[str]: __snake_case : Optional[int] = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.csv.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : str ) -> Union[str, Any]: __snake_case : List[str] = str(tmp_path_factory.mktemp('data' ) / 'dataset.parquet' ) __snake_case : Union[str, Any] = pa.schema( { 'col_1': pa.string(), 'col_2': pa.intaa(), 'col_3': pa.floataa(), } ) with open(_UpperCAmelCase ,'wb' ) as f: __snake_case : Union[str, Any] = pq.ParquetWriter(_UpperCAmelCase ,schema=_UpperCAmelCase ) __snake_case : Dict = pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(_UpperCAmelCase ) )] for k in DATA[0]} ,schema=_UpperCAmelCase ) writer.write_table(_UpperCAmelCase ) writer.close() return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Union[str, Any] ) -> str: __snake_case : int = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) __snake_case : Optional[int] = {'data': DATA} with open(_UpperCAmelCase ,'w' ) as f: json.dump(_UpperCAmelCase ,_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ) -> Optional[Any]: __snake_case : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.json' ) __snake_case : str = {'data': DATA_DICT_OF_LISTS} with open(_UpperCAmelCase ,'w' ) as f: json.dump(_UpperCAmelCase ,_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ) -> Dict: __snake_case : Tuple = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl' ) with open(_UpperCAmelCase ,'w' ) as f: for item in DATA: f.write(json.dumps(_UpperCAmelCase ) + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ) -> Tuple: __snake_case : Union[str, Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.jsonl' ) with open(_UpperCAmelCase ,'w' ) as f: for item in DATA: f.write(json.dumps(_UpperCAmelCase ) + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ) -> Optional[int]: __snake_case : int = str(tmp_path_factory.mktemp('data' ) / 'dataset_312.jsonl' ) with open(_UpperCAmelCase ,'w' ) as f: for item in DATA_312: f.write(json.dumps(_UpperCAmelCase ) + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ) -> List[str]: __snake_case : List[str] = str(tmp_path_factory.mktemp('data' ) / 'dataset-str.jsonl' ) with open(_UpperCAmelCase ,'w' ) as f: for item in DATA_STR: f.write(json.dumps(_UpperCAmelCase ) + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Tuple ) -> str: import gzip __snake_case : List[str] = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt.gz' ) with open(_UpperCAmelCase ,'rb' ) as orig_file: with gzip.open(_UpperCAmelCase ,'wb' ) as zipped_file: zipped_file.writelines(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ,_UpperCAmelCase : List[Any] ) -> Optional[int]: import gzip __snake_case : str = str(tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.gz' ) with open(_UpperCAmelCase ,'rb' ) as orig_file: with gzip.open(_UpperCAmelCase ,'wb' ) as zipped_file: zipped_file.writelines(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ,_UpperCAmelCase : str ,_UpperCAmelCase : int ) -> Union[str, Any]: __snake_case : Any = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : int ) -> Tuple: __snake_case : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.join('nested' ,os.path.basename(_UpperCAmelCase ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[str] ,_UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : Optional[Any] ) -> Union[str, Any]: __snake_case : Tuple = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.jsonl.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Any ) -> int: __snake_case : Optional[Any] = tmp_path_factory.mktemp('data' ) / 'dataset.jsonl.tar' with tarfile.TarFile(_UpperCAmelCase ,'w' ) as f: f.add(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) f.add(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[Any] ,_UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : Any ,_UpperCAmelCase : Optional[Any] ) -> Dict: __snake_case : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset_nested.jsonl.tar' with tarfile.TarFile(_UpperCAmelCase ,'w' ) as f: f.add(_UpperCAmelCase ,arcname=os.path.join('nested' ,os.path.basename(_UpperCAmelCase ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Union[str, Any] ) -> int: __snake_case : int = ['0', '1', '2', '3'] __snake_case : Dict = str(tmp_path_factory.mktemp('data' ) / 'dataset.txt' ) with open(_UpperCAmelCase ,'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[str] ) -> Dict: __snake_case : Optional[int] = ['0', '1', '2', '3'] __snake_case : List[Any] = str(tmp_path_factory.mktemp('data' ) / 'dataset2.txt' ) with open(_UpperCAmelCase ,'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[Any] ) -> Optional[int]: __snake_case : Dict = ['0', '1', '2', '3'] __snake_case : str = tmp_path_factory.mktemp('data' ) / 'dataset.abc' with open(_UpperCAmelCase ,'w' ) as f: for item in data: f.write(item + '\n' ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : List[Any] ,_UpperCAmelCase : Any ,_UpperCAmelCase : Optional[int] ) -> Tuple: __snake_case : Optional[int] = tmp_path_factory.mktemp('data' ) / 'dataset.text.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Tuple ,_UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : Any ) -> Optional[int]: __snake_case : str = tmp_path_factory.mktemp('data' ) / 'dataset_with_dir.text.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) f.write(_UpperCAmelCase ,arcname=os.path.join('main_dir' ,os.path.basename(_UpperCAmelCase ) ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Dict ,_UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : int ) -> List[str]: __snake_case : str = tmp_path_factory.mktemp('data' ) / 'dataset.ext.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename('unsupported.ext' ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename('unsupported_2.ext' ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Optional[int] ) -> int: __snake_case : List[Any] = '\n'.join(['First', 'Second\u2029with Unicode new line', 'Third'] ) __snake_case : List[str] = str(tmp_path_factory.mktemp('data' ) / 'dataset_with_unicode_new_lines.txt' ) with open(_UpperCAmelCase ,'w' ,encoding='utf-8' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture(scope='session' ) def a_ ( ) -> List[str]: return os.path.join('tests' ,'features' ,'data' ,'test_image_rgb.jpg' ) @pytest.fixture(scope='session' ) def a_ ( ) -> int: return os.path.join('tests' ,'features' ,'data' ,'test_audio_44100.wav' ) @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : Any ,_UpperCAmelCase : Optional[Any] ) -> Dict: __snake_case : List[str] = tmp_path_factory.mktemp('data' ) / 'dataset.img.zip' with zipfile.ZipFile(_UpperCAmelCase ,'w' ) as f: f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ) ) f.write(_UpperCAmelCase ,arcname=os.path.basename(_UpperCAmelCase ).replace('.jpg' ,'2.jpg' ) ) return path @pytest.fixture(scope='session' ) def a_ ( _UpperCAmelCase : int ) -> Optional[Any]: __snake_case : Tuple = 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

'''simple docstring''' import argparse import json import logging import os import shutil import sys import tempfile import unittest from unittest import mock import torch from accelerate.utils import write_basic_config from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device from transformers.utils import is_apex_available logging.basicConfig(level=logging.DEBUG) A__ : Dict = logging.getLogger() def a_ ( ) -> Tuple: __snake_case : List[Any] = argparse.ArgumentParser() parser.add_argument('-f' ) __snake_case : Any = parser.parse_args() return args.f def a_ ( _UpperCAmelCase : Optional[int] ) -> List[Any]: __snake_case : Tuple = {} __snake_case : Union[str, Any] = os.path.join(_UpperCAmelCase ,'all_results.json' ) if os.path.exists(_UpperCAmelCase ): with open(_UpperCAmelCase ,'r' ) as f: __snake_case : List[str] = json.load(_UpperCAmelCase ) else: raise ValueError(f'''can\'t find {path}''' ) return results def a_ ( ) -> Union[str, Any]: __snake_case : Union[str, Any] = torch.cuda.is_available() and torch_device == 'cuda' return is_using_cuda and is_apex_available() A__ : str = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): @classmethod def A_ ( cls : Any ) -> List[str]: '''simple docstring''' # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU __snake_case : Optional[int] = tempfile.mkdtemp() __snake_case : Dict = os.path.join(cls.tmpdir , 'default_config.yml' ) write_basic_config(save_location=cls.configPath ) __snake_case : List[Any] = ['accelerate', 'launch', '--config_file', cls.configPath] @classmethod def A_ ( cls : List[str] ) -> List[str]: '''simple docstring''' shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> Optional[Any]: '''simple docstring''' __snake_case : List[Any] = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py --model_name_or_path distilbert-base-uncased --output_dir {tmp_dir} --train_file ./tests/fixtures/tests_samples/MRPC/train.csv --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --learning_rate=1e-4 --seed=42 --checkpointing_steps epoch --with_tracking '''.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) __snake_case : List[Any] = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.7_5 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'glue_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : List[Any] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : str = f''' {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py --model_name_or_path distilgpt2 --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --block_size 128 --per_device_train_batch_size 5 --per_device_eval_batch_size 5 --num_train_epochs 2 --output_dir {tmp_dir} --checkpointing_steps epoch --with_tracking '''.split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) self.assertLess(result['perplexity'] , 100 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'clm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : str ) -> List[str]: '''simple docstring''' __snake_case : int = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py --model_name_or_path distilroberta-base --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --output_dir {tmp_dir} --num_train_epochs=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(__a ) self.assertLess(result['perplexity'] , 42 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'mlm_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu __snake_case : Any = 7 if get_gpu_count() > 1 else 2 __snake_case : Any = self.get_auto_remove_tmp_dir() __snake_case : int = f''' {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/conll/sample.json --validation_file tests/fixtures/tests_samples/conll/sample.json --output_dir {tmp_dir} --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=2 --num_train_epochs={epochs} --seed 7 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.7_5 ) self.assertLess(result['train_loss'] , 0.5 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'ner_no_trainer' ) ) ) @unittest.skip(reason='Fix me @muellerzr' ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> List[Any]: '''simple docstring''' __snake_case : Any = self.get_auto_remove_tmp_dir() __snake_case : Tuple = f''' {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py --model_name_or_path bert-base-uncased --version_2_with_negative --train_file tests/fixtures/tests_samples/SQUAD/sample.json --validation_file tests/fixtures/tests_samples/SQUAD/sample.json --output_dir {tmp_dir} --seed=42 --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics. self.assertGreaterEqual(result['eval_f1'] , 28 ) self.assertGreaterEqual(result['eval_exact'] , 28 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'qa_no_trainer' ) ) ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Dict ) -> List[Any]: '''simple docstring''' __snake_case : str = self.get_auto_remove_tmp_dir() __snake_case : Any = f''' {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/swag/sample.json --validation_file tests/fixtures/tests_samples/swag/sample.json --output_dir {tmp_dir} --max_train_steps=20 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : str = get_results(__a ) self.assertGreaterEqual(result['eval_accuracy'] , 0.8 ) self.assertTrue(os.path.exists(os.path.join(__a , 'swag_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Any ) -> Union[str, Any]: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py --model_name_or_path t5-small --train_file tests/fixtures/tests_samples/xsum/sample.json --validation_file tests/fixtures/tests_samples/xsum/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : int = get_results(__a ) self.assertGreaterEqual(result['eval_rouge1'] , 10 ) self.assertGreaterEqual(result['eval_rouge2'] , 2 ) self.assertGreaterEqual(result['eval_rougeL'] , 7 ) self.assertGreaterEqual(result['eval_rougeLsum'] , 7 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'summarization_no_trainer' ) ) ) @slow @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : str = f''' {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py --model_name_or_path sshleifer/student_marian_en_ro_6_1 --source_lang en --target_lang ro --train_file tests/fixtures/tests_samples/wmt16/sample.json --validation_file tests/fixtures/tests_samples/wmt16/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --num_beams=6 --learning_rate=3e-3 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --source_lang en_XX --target_lang ro_RO --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(__a ) self.assertGreaterEqual(result['eval_bleu'] , 30 ) self.assertTrue(os.path.exists(os.path.join(__a , 'epoch_0' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'translation_no_trainer' ) ) ) @slow def A_ ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Union[str, Any] = logging.StreamHandler(sys.stdout ) logger.addHandler(__a ) __snake_case : List[str] = self.get_auto_remove_tmp_dir() __snake_case : int = f''' {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py --dataset_name huggingface/semantic-segmentation-test-sample --output_dir {tmp_dir} --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch '''.split() run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(__a ) self.assertGreaterEqual(result['eval_overall_accuracy'] , 0.1_0 ) @mock.patch.dict(os.environ , {'WANDB_MODE': 'offline'} ) def A_ ( self : Tuple ) -> Any: '''simple docstring''' __snake_case : Dict = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py --model_name_or_path google/vit-base-patch16-224-in21k --dataset_name hf-internal-testing/cats_vs_dogs_sample --learning_rate 1e-4 --per_device_train_batch_size 2 --per_device_eval_batch_size 1 --max_train_steps 2 --train_val_split 0.1 --seed 42 --output_dir {tmp_dir} --with_tracking --checkpointing_steps 1 '''.split() if is_cuda_and_apex_available(): testargs.append('--fp16' ) run_command(self._launch_args + testargs ) __snake_case : Optional[int] = get_results(__a ) # The base model scores a 25% self.assertGreaterEqual(result['eval_accuracy'] , 0.6 ) self.assertTrue(os.path.exists(os.path.join(__a , 'step_1' ) ) ) self.assertTrue(os.path.exists(os.path.join(__a , 'image_classification_no_trainer' ) ) )

'''simple docstring''' import unittest import numpy as np from transformers import DistilBertConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.distilbert.modeling_flax_distilbert import ( FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertModel, ) class snake_case__ ( unittest.TestCase ): def __init__( self : Union[str, Any] , __a : Any , __a : int=13 , __a : Dict=7 , __a : Union[str, Any]=True , __a : Optional[Any]=True , __a : List[Any]=True , __a : Tuple=True , __a : Union[str, Any]=99 , __a : Dict=32 , __a : Dict=5 , __a : str=4 , __a : Optional[int]=37 , __a : str="gelu" , __a : Any=0.1 , __a : Optional[int]=0.1 , __a : List[Any]=512 , __a : Any=16 , __a : Optional[int]=2 , __a : str=0.0_2 , __a : Union[str, Any]=4 , ) -> List[str]: '''simple docstring''' __snake_case : List[Any] = parent __snake_case : Optional[int] = batch_size __snake_case : List[Any] = seq_length __snake_case : int = is_training __snake_case : int = use_attention_mask __snake_case : List[Any] = use_token_type_ids __snake_case : Tuple = use_labels __snake_case : Dict = vocab_size __snake_case : Tuple = hidden_size __snake_case : List[str] = num_hidden_layers __snake_case : int = num_attention_heads __snake_case : Union[str, Any] = intermediate_size __snake_case : str = hidden_act __snake_case : Optional[int] = hidden_dropout_prob __snake_case : Optional[int] = attention_probs_dropout_prob __snake_case : List[Any] = max_position_embeddings __snake_case : Union[str, Any] = type_vocab_size __snake_case : str = type_sequence_label_size __snake_case : Tuple = initializer_range __snake_case : Optional[Any] = num_choices def A_ ( self : Dict ) -> Optional[Any]: '''simple docstring''' __snake_case : int = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __snake_case : Optional[int] = None if self.use_attention_mask: __snake_case : Dict = random_attention_mask([self.batch_size, self.seq_length] ) __snake_case : Optional[int] = DistilBertConfig( vocab_size=self.vocab_size , dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , hidden_dim=self.intermediate_size , hidden_act=self.hidden_act , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , tie_weights_=__a , ) return config, input_ids, attention_mask def A_ ( self : Any ) -> Tuple: '''simple docstring''' __snake_case : Tuple = self.prepare_config_and_inputs() __snake_case : Optional[int] = config_and_inputs __snake_case : List[str] = {'input_ids': input_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def A_ ( self : Dict ) -> List[Any]: '''simple docstring''' __snake_case : Optional[int] = FlaxDistilBertModelTester(self ) @slow def A_ ( self : Tuple ) -> Union[str, Any]: '''simple docstring''' for model_class_name in self.all_model_classes: __snake_case : Optional[int] = model_class_name.from_pretrained('distilbert-base-uncased' ) __snake_case : List[Any] = model(np.ones((1, 1) ) ) self.assertIsNotNone(__a ) @require_flax class snake_case__ ( unittest.TestCase ): @slow def A_ ( self : Any ) -> Dict: '''simple docstring''' __snake_case : Optional[int] = FlaxDistilBertModel.from_pretrained('distilbert-base-uncased' ) __snake_case : Tuple = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] ) __snake_case : Tuple = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) __snake_case : str = model(__a , attention_mask=__a )[0] __snake_case : List[str] = (1, 11, 768) self.assertEqual(output.shape , __a ) __snake_case : Dict = np.array([[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , __a , atol=1e-4 ) )

'''simple docstring''' import math def a_ ( _UpperCAmelCase : int ) -> list: __snake_case : Optional[Any] = [True] * n __snake_case : Optional[int] = False __snake_case : Dict = False __snake_case : List[Any] = True for i in range(3 ,int(n**0.5 + 1 ) ,2 ): __snake_case : Optional[int] = i * 2 while index < n: __snake_case : Union[str, Any] = False __snake_case : int = index + i __snake_case : Dict = [2] for i in range(3 ,_UpperCAmelCase ,2 ): if is_prime[i]: primes.append(_UpperCAmelCase ) return primes def a_ ( _UpperCAmelCase : int = 99_99_66_66_33_33 ) -> int: __snake_case : List[Any] = math.floor(math.sqrt(_UpperCAmelCase ) ) + 1_00 __snake_case : Tuple = prime_sieve(_UpperCAmelCase ) __snake_case : List[Any] = 0 __snake_case : List[Any] = 0 __snake_case : Optional[int] = primes[prime_index] while (last_prime**2) <= limit: __snake_case : Optional[int] = primes[prime_index + 1] __snake_case : Union[str, Any] = last_prime**2 __snake_case : Dict = next_prime**2 # Get numbers divisible by lps(current) __snake_case : Optional[Any] = lower_bound + last_prime while upper_bound > current <= limit: matches_sum += current current += last_prime # Reset the upper_bound while (upper_bound - next_prime) > limit: upper_bound -= next_prime # Add the numbers divisible by ups(current) __snake_case : Optional[Any] = upper_bound - next_prime while current > lower_bound: matches_sum += current current -= next_prime # Remove the numbers divisible by both ups and lps __snake_case : List[str] = 0 while upper_bound > current <= limit: if current <= lower_bound: # Increment the current number current += last_prime * next_prime continue if current > limit: break # Remove twice since it was added by both ups and lps matches_sum -= current * 2 # Increment the current number current += last_prime * next_prime # Setup for next pair __snake_case : Dict = next_prime prime_index += 1 return matches_sum if __name__ == "__main__": print(solution())

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) A__ : Tuple = {'''configuration_plbart''': ['''PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PLBartConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : List[Any] = ['''PLBartTokenizer'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ '''PLBART_PRETRAINED_MODEL_ARCHIVE_LIST''', '''PLBartForCausalLM''', '''PLBartForConditionalGeneration''', '''PLBartForSequenceClassification''', '''PLBartModel''', '''PLBartPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_plbart import PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP, PLBartConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_plbart import PLBartTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_plbart import ( PLBART_PRETRAINED_MODEL_ARCHIVE_LIST, PLBartForCausalLM, PLBartForConditionalGeneration, PLBartForSequenceClassification, PLBartModel, PLBartPreTrainedModel, ) else: import sys A__ : Optional[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure)

'''simple docstring''' def a_ ( _UpperCAmelCase : float ,_UpperCAmelCase : float ) -> float: return price * (1 + tax_rate) if __name__ == "__main__": print(F"""{price_plus_tax(1_0_0, 0.25) = }""") print(F"""{price_plus_tax(1_25.50, 0.05) = }""")

'''simple docstring''' from __future__ import annotations import unittest from transformers import XGLMConfig, XGLMTokenizer, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers.models.xglm.modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, ) @require_tf class snake_case__ : A__ = XGLMConfig A__ = {} A__ = '''gelu''' def __init__( self : Optional[Any] , __a : Optional[Any] , __a : int=14 , __a : Dict=7 , __a : Optional[Any]=True , __a : Optional[int]=True , __a : List[Any]=True , __a : Optional[int]=99 , __a : Union[str, Any]=32 , __a : Union[str, Any]=2 , __a : List[str]=4 , __a : Optional[int]=37 , __a : List[Any]="gelu" , __a : Tuple=0.1 , __a : str=0.1 , __a : int=512 , __a : Tuple=0.0_2 , ) -> Union[str, Any]: '''simple docstring''' __snake_case : Any = parent __snake_case : List[Any] = batch_size __snake_case : List[Any] = seq_length __snake_case : str = is_training __snake_case : str = use_input_mask __snake_case : Tuple = use_labels __snake_case : Optional[int] = vocab_size __snake_case : Dict = d_model __snake_case : str = num_hidden_layers __snake_case : Dict = num_attention_heads __snake_case : Optional[int] = ffn_dim __snake_case : Tuple = activation_function __snake_case : List[Any] = activation_dropout __snake_case : str = attention_dropout __snake_case : Union[str, Any] = max_position_embeddings __snake_case : Optional[int] = initializer_range __snake_case : Any = None __snake_case : Any = 0 __snake_case : Dict = 2 __snake_case : Union[str, Any] = 1 def A_ ( self : Tuple ) -> Any: '''simple docstring''' return XGLMConfig.from_pretrained('facebook/xglm-564M' ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Optional[int] = tf.clip_by_value( ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) , clip_value_min=0 , clip_value_max=3 ) __snake_case : List[str] = None if self.use_input_mask: __snake_case : Optional[int] = random_attention_mask([self.batch_size, self.seq_length] ) __snake_case : int = self.get_config() __snake_case : List[str] = floats_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, input_mask, head_mask, ) def A_ ( self : Dict ) -> Union[str, Any]: '''simple docstring''' return XGLMConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , num_layers=self.num_hidden_layers , attention_heads=self.num_attention_heads , ffn_dim=self.ffn_dim , activation_function=self.activation_function , activation_dropout=self.activation_dropout , attention_dropout=self.attention_dropout , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , use_cache=__a , bos_token_id=self.bos_token_id , eos_token_id=self.eos_token_id , pad_token_id=self.pad_token_id , return_dict=__a , ) def A_ ( self : List[Any] ) -> Dict: '''simple docstring''' __snake_case : List[str] = self.prepare_config_and_inputs() ( __snake_case ) : List[Any] = config_and_inputs __snake_case : Union[str, Any] = { 'input_ids': input_ids, 'head_mask': head_mask, } return config, inputs_dict @require_tf class snake_case__ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = (TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else () A__ = (TFXGLMForCausalLM,) if is_tf_available() else () A__ = ( {'''feature-extraction''': TFXGLMModel, '''text-generation''': TFXGLMForCausalLM} if is_tf_available() else {} ) A__ = False A__ = False A__ = False def A_ ( self : Any ) -> Optional[Any]: '''simple docstring''' __snake_case : List[str] = TFXGLMModelTester(self ) __snake_case : str = ConfigTester(self , config_class=__a , n_embd=37 ) def A_ ( self : Optional[Any] ) -> List[str]: '''simple docstring''' self.config_tester.run_common_tests() @slow def A_ ( self : Dict ) -> int: '''simple docstring''' for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __snake_case : str = TFXGLMModel.from_pretrained(__a ) self.assertIsNotNone(__a ) @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.' ) def A_ ( self : Any ) -> str: '''simple docstring''' super().test_resize_token_embeddings() @require_tf class snake_case__ ( unittest.TestCase ): @slow def A_ ( self : Optional[Any] , __a : Optional[Any]=True ) -> Any: '''simple docstring''' __snake_case : Optional[Any] = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' ) __snake_case : Union[str, Any] = tf.convert_to_tensor([[2, 268, 9865]] , dtype=tf.intaa ) # The dog # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other # fmt: off __snake_case : str = [2, 268, 9865, 67, 11, 1988, 57252, 9865, 5, 984, 67, 1988, 213838, 1658, 53, 70446, 33, 6657, 278, 1581] # fmt: on __snake_case : int = model.generate(__a , do_sample=__a , num_beams=1 ) if verify_outputs: self.assertListEqual(output_ids[0].numpy().tolist() , __a ) @slow def A_ ( self : Any ) -> int: '''simple docstring''' __snake_case : Union[str, Any] = XGLMTokenizer.from_pretrained('facebook/xglm-564M' ) __snake_case : int = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' ) tf.random.set_seed(0 ) __snake_case : int = tokenizer('Today is a nice day and' , return_tensors='tf' ) __snake_case : Any = tokenized.input_ids # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices) with tf.device(':/CPU:0' ): __snake_case : Dict = model.generate(__a , do_sample=__a , seed=[7, 0] ) __snake_case : Any = tokenizer.decode(output_ids[0] , skip_special_tokens=__a ) __snake_case : str = ( 'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due' ) self.assertEqual(__a , __a ) @slow def A_ ( self : Tuple ) -> List[Any]: '''simple docstring''' __snake_case : Optional[int] = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' ) __snake_case : Dict = XGLMTokenizer.from_pretrained('facebook/xglm-564M' ) __snake_case : int = 'left' # use different length sentences to test batching __snake_case : Optional[Any] = [ 'This is an extremelly long sentence that only exists to test the ability of the model to cope with ' 'left-padding, such as in batched generation. The output for the sequence below should be the same ' 'regardless of whether left padding is applied or not. When', 'Hello, my dog is a little', ] __snake_case : int = tokenizer(__a , return_tensors='tf' , padding=__a ) __snake_case : List[Any] = inputs['input_ids'] __snake_case : Tuple = model.generate(input_ids=__a , attention_mask=inputs['attention_mask'] , max_new_tokens=12 ) __snake_case : List[str] = tokenizer(sentences[0] , return_tensors='tf' ).input_ids __snake_case : List[Any] = model.generate(input_ids=__a , max_new_tokens=12 ) __snake_case : List[str] = tokenizer(sentences[1] , return_tensors='tf' ).input_ids __snake_case : List[str] = model.generate(input_ids=__a , max_new_tokens=12 ) __snake_case : Optional[int] = tokenizer.batch_decode(__a , skip_special_tokens=__a ) __snake_case : Union[str, Any] = tokenizer.decode(output_non_padded[0] , skip_special_tokens=__a ) __snake_case : List[Any] = tokenizer.decode(output_padded[0] , skip_special_tokens=__a ) __snake_case : int = [ 'This is an extremelly long sentence that only exists to test the ability of the model to cope with ' 'left-padding, such as in batched generation. The output for the sequence below should be the same ' 'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be ' 'a single', 'Hello, my dog is a little bit of a shy one, but he is very friendly', ] self.assertListEqual(__a , __a ) self.assertListEqual(__a , [non_padded_sentence, padded_sentence] )

'''simple docstring''' from tempfile import TemporaryDirectory from unittest import TestCase from unittest.mock import MagicMock, patch from transformers import AutoModel, TFAutoModel from transformers.onnx import FeaturesManager from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch @require_torch @require_tf class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : List[Any] ) -> int: '''simple docstring''' __snake_case : Optional[int] = SMALL_MODEL_IDENTIFIER __snake_case : str = 'pt' __snake_case : Union[str, Any] = 'tf' def A_ ( self : Dict , __a : Tuple ) -> Dict: '''simple docstring''' __snake_case : Optional[int] = AutoModel.from_pretrained(self.test_model ) model_pt.save_pretrained(__a ) def A_ ( self : Any , __a : Optional[Any] ) -> Dict: '''simple docstring''' __snake_case : Union[str, Any] = TFAutoModel.from_pretrained(self.test_model , from_pt=__a ) model_tf.save_pretrained(__a ) def A_ ( self : Any ) -> Tuple: '''simple docstring''' __snake_case : Tuple = 'mock_framework' # Framework provided - return whatever the user provides __snake_case : int = FeaturesManager.determine_framework(self.test_model , __a ) self.assertEqual(__a , __a ) # Local checkpoint and framework provided - return provided framework # PyTorch checkpoint with TemporaryDirectory() as local_pt_ckpt: self._setup_pt_ckpt(__a ) __snake_case : List[Any] = FeaturesManager.determine_framework(__a , __a ) self.assertEqual(__a , __a ) # TensorFlow checkpoint with TemporaryDirectory() as local_tf_ckpt: self._setup_tf_ckpt(__a ) __snake_case : Tuple = FeaturesManager.determine_framework(__a , __a ) self.assertEqual(__a , __a ) def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' # PyTorch checkpoint with TemporaryDirectory() as local_pt_ckpt: self._setup_pt_ckpt(__a ) __snake_case : Tuple = FeaturesManager.determine_framework(__a ) self.assertEqual(__a , self.framework_pt ) # TensorFlow checkpoint with TemporaryDirectory() as local_tf_ckpt: self._setup_tf_ckpt(__a ) __snake_case : Union[str, Any] = FeaturesManager.determine_framework(__a ) self.assertEqual(__a , self.framework_tf ) # Invalid local checkpoint with TemporaryDirectory() as local_invalid_ckpt: with self.assertRaises(__a ): __snake_case : Optional[int] = FeaturesManager.determine_framework(__a ) def A_ ( self : Any ) -> List[Any]: '''simple docstring''' __snake_case : Union[str, Any] = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ): __snake_case : int = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_pt ) # PyTorch not in environment -> use TensorFlow __snake_case : Tuple = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_torch_available' , __a ): __snake_case : Dict = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_tf ) # Both in environment -> use PyTorch __snake_case : Optional[Any] = MagicMock(return_value=__a ) __snake_case : Tuple = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ), patch( 'transformers.onnx.features.is_torch_available' , __a ): __snake_case : Dict = FeaturesManager.determine_framework(self.test_model ) self.assertEqual(__a , self.framework_pt ) # Both not in environment -> raise error __snake_case : str = MagicMock(return_value=__a ) __snake_case : List[Any] = MagicMock(return_value=__a ) with patch('transformers.onnx.features.is_tf_available' , __a ), patch( 'transformers.onnx.features.is_torch_available' , __a ): with self.assertRaises(__a ): __snake_case : Tuple = FeaturesManager.determine_framework(self.test_model )

'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def a_ ( _UpperCAmelCase : Tuple ) -> Union[str, Any]: __snake_case : Any = image.size __snake_case : Optional[int] = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 __snake_case : int = image.resize((w, h) ,resample=PIL_INTERPOLATION['lanczos'] ) __snake_case : Dict = np.array(_UpperCAmelCase ).astype(np.floataa ) / 2_55.0 __snake_case : Tuple = image[None].transpose(0 ,3 ,1 ,2 ) __snake_case : int = torch.from_numpy(_UpperCAmelCase ) return 2.0 * image - 1.0 class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def __init__( self : List[str] , __a : VQModel , __a : UNetaDModel , __a : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ) -> List[str]: '''simple docstring''' super().__init__() self.register_modules(vqvae=__a , unet=__a , scheduler=__a ) @torch.no_grad() def __call__( self : Tuple , __a : Union[torch.Tensor, PIL.Image.Image] = None , __a : Optional[int] = 1 , __a : Optional[int] = 100 , __a : Optional[float] = 0.0 , __a : Optional[Union[torch.Generator, List[torch.Generator]]] = None , __a : Optional[str] = "pil" , __a : bool = True , ) -> Union[Tuple, ImagePipelineOutput]: '''simple docstring''' if isinstance(__a , PIL.Image.Image ): __snake_case : Union[str, Any] = 1 elif isinstance(__a , torch.Tensor ): __snake_case : str = image.shape[0] else: raise ValueError(f'''`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(__a )}''' ) if isinstance(__a , PIL.Image.Image ): __snake_case : Tuple = preprocess(__a ) __snake_case : Any = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image __snake_case : Dict = (batch_size, self.unet.config.in_channels // 2, height, width) __snake_case : Optional[int] = next(self.unet.parameters() ).dtype __snake_case : int = randn_tensor(__a , generator=__a , device=self.device , dtype=__a ) __snake_case : Union[str, Any] = image.to(device=self.device , dtype=__a ) # set timesteps and move to the correct device self.scheduler.set_timesteps(__a , device=self.device ) __snake_case : List[Any] = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler __snake_case : Optional[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] __snake_case : str = 'eta' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) __snake_case : str = {} if accepts_eta: __snake_case : Optional[Any] = eta for t in self.progress_bar(__a ): # concat latents and low resolution image in the channel dimension. __snake_case : int = torch.cat([latents, image] , dim=1 ) __snake_case : Optional[int] = self.scheduler.scale_model_input(__a , __a ) # predict the noise residual __snake_case : List[str] = self.unet(__a , __a ).sample # compute the previous noisy sample x_t -> x_t-1 __snake_case : List[Any] = self.scheduler.step(__a , __a , __a , **__a ).prev_sample # decode the image latents with the VQVAE __snake_case : Any = self.vqvae.decode(__a ).sample __snake_case : List[Any] = torch.clamp(__a , -1.0 , 1.0 ) __snake_case : Union[str, Any] = image / 2 + 0.5 __snake_case : str = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __snake_case : str = self.numpy_to_pil(__a ) if not return_dict: return (image,) return ImagePipelineOutput(images=__a )

'''simple docstring''' import os import unittest from transformers import BatchEncoding from transformers.models.bert.tokenization_bert import ( BasicTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.models.prophetnet.tokenization_prophetnet import VOCAB_FILES_NAMES, ProphetNetTokenizer from transformers.testing_utils import require_torch, slow from ...test_tokenization_common import TokenizerTesterMixin class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ProphetNetTokenizer A__ = False def A_ ( self : Optional[int] ) -> Dict: '''simple docstring''' super().setUp() __snake_case : Dict = [ '[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest', ] __snake_case : Any = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def A_ ( self : int , __a : Union[str, Any] ) -> List[str]: '''simple docstring''' __snake_case : Optional[int] = 'UNwant\u00E9d,running' __snake_case : List[str] = 'unwanted, running' return input_text, output_text def A_ ( self : Union[str, Any] ) -> str: '''simple docstring''' __snake_case : Dict = self.tokenizer_class(self.vocab_file ) __snake_case : List[str] = tokenizer.tokenize('UNwant\u00E9d,running' ) self.assertListEqual(__a , ['un', '##want', '##ed', ',', 'runn', '##ing'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__a ) , [9, 6, 7, 12, 10, 11] ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : List[str] = BasicTokenizer() self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz' ) , ['ah', '\u535A', '\u63A8', 'zz'] ) def A_ ( self : Union[str, Any] ) -> str: '''simple docstring''' __snake_case : Optional[int] = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['hello', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' __snake_case : List[Any] = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hällo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['h\u00E9llo'] ) def A_ ( self : int ) -> Any: '''simple docstring''' __snake_case : int = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : Optional[int] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Union[str, Any] = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] ) self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] ) def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Dict = BasicTokenizer(do_lower_case=__a ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Any ) -> List[str]: '''simple docstring''' __snake_case : str = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HäLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Union[str, Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : List[Any] = BasicTokenizer(do_lower_case=__a , strip_accents=__a ) self.assertListEqual( tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HaLLo', '!', 'how', 'Are', 'yoU', '?'] ) def A_ ( self : Optional[int] ) -> List[str]: '''simple docstring''' __snake_case : Optional[Any] = BasicTokenizer(do_lower_case=__a , never_split=['[UNK]'] ) self.assertListEqual( tokenizer.tokenize(' \tHeLLo!how \n Are yoU? [UNK]' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'] ) def A_ ( self : Optional[int] ) -> List[Any]: '''simple docstring''' __snake_case : Any = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing'] __snake_case : List[Any] = {} for i, token in enumerate(__a ): __snake_case : List[str] = i __snake_case : Any = WordpieceTokenizer(vocab=__a , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('unwanted running' ) , ['un', '##want', '##ed', 'runn', '##ing'] ) self.assertListEqual(tokenizer.tokenize('unwantedX running' ) , ['[UNK]', 'runn', '##ing'] ) @require_torch def A_ ( self : Union[str, Any] ) -> Tuple: '''simple docstring''' __snake_case : Optional[Any] = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' ) __snake_case : int = ['A long paragraph for summarization.', 'Another paragraph for summarization.'] __snake_case : str = [1037, 2146, 20423, 2005, 7680, 7849, 3989, 1012, 102] __snake_case : Union[str, Any] = tokenizer(__a , padding=__a , return_tensors='pt' ) self.assertIsInstance(__a , __a ) __snake_case : int = list(batch.input_ids.numpy()[0] ) self.assertListEqual(__a , __a ) self.assertEqual((2, 9) , batch.input_ids.shape ) self.assertEqual((2, 9) , batch.attention_mask.shape ) def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' self.assertTrue(_is_whitespace(' ' ) ) self.assertTrue(_is_whitespace('\t' ) ) self.assertTrue(_is_whitespace('\r' ) ) self.assertTrue(_is_whitespace('\n' ) ) self.assertTrue(_is_whitespace('\u00A0' ) ) self.assertFalse(_is_whitespace('A' ) ) self.assertFalse(_is_whitespace('-' ) ) def A_ ( self : Dict ) -> Optional[Any]: '''simple docstring''' self.assertTrue(_is_control('\u0005' ) ) self.assertFalse(_is_control('A' ) ) self.assertFalse(_is_control(' ' ) ) self.assertFalse(_is_control('\t' ) ) self.assertFalse(_is_control('\r' ) ) def A_ ( self : List[Any] ) -> int: '''simple docstring''' self.assertTrue(_is_punctuation('-' ) ) self.assertTrue(_is_punctuation('$' ) ) self.assertTrue(_is_punctuation('`' ) ) self.assertTrue(_is_punctuation('.' ) ) self.assertFalse(_is_punctuation('A' ) ) self.assertFalse(_is_punctuation(' ' ) ) @slow def A_ ( self : str ) -> Optional[int]: '''simple docstring''' __snake_case : str = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' ) __snake_case : Optional[int] = tokenizer.encode('sequence builders' , add_special_tokens=__a ) __snake_case : Optional[int] = tokenizer.encode('multi-sequence build' , add_special_tokens=__a ) __snake_case : Optional[Any] = tokenizer.build_inputs_with_special_tokens(__a ) __snake_case : List[Any] = tokenizer.build_inputs_with_special_tokens(__a , __a ) assert encoded_sentence == text + [102] assert encoded_pair == text + [102] + text_a + [102]

'''simple docstring''' def a_ ( _UpperCAmelCase : str = "The quick brown fox jumps over the lazy dog" ,) -> bool: __snake_case : Optional[Any] = set() # Replace all the whitespace in our sentence __snake_case : int = input_str.replace(' ' ,'' ) for alpha in input_str: if "a" <= alpha.lower() <= "z": frequency.add(alpha.lower() ) return len(_UpperCAmelCase ) == 26 def a_ ( _UpperCAmelCase : str = "The quick brown fox jumps over the lazy dog" ,) -> bool: __snake_case : int = [False] * 26 for char in input_str: if char.islower(): __snake_case : Optional[int] = True elif char.isupper(): __snake_case : Union[str, Any] = True return all(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : str = "The quick brown fox jumps over the lazy dog" ,) -> bool: return len({char for char in input_str.lower() if char.isalpha()} ) == 26 def a_ ( ) -> None: from timeit import timeit __snake_case : Union[str, Any] = 'from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest' print(timeit('is_pangram()' ,setup=_UpperCAmelCase ) ) print(timeit('is_pangram_faster()' ,setup=_UpperCAmelCase ) ) print(timeit('is_pangram_fastest()' ,setup=_UpperCAmelCase ) ) # 5.348480500048026, 2.6477354579837993, 1.8470395830227062 # 5.036091582966037, 2.644472333951853, 1.8869528750656173 if __name__ == "__main__": import doctest doctest.testmod() benchmark()

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available A__ : Optional[Any] = { '''configuration_nllb_moe''': [ '''NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NllbMoeConfig''', ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ '''NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST''', '''NllbMoeForConditionalGeneration''', '''NllbMoeModel''', '''NllbMoePreTrainedModel''', '''NllbMoeTop2Router''', '''NllbMoeSparseMLP''', ] if TYPE_CHECKING: from .configuration_nllb_moe import ( NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP, NllbMoeConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nllb_moe import ( NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST, NllbMoeForConditionalGeneration, NllbMoeModel, NllbMoePreTrainedModel, NllbMoeSparseMLP, NllbMoeTopaRouter, ) else: import sys A__ : str = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' from typing import List, Optional, Union import numpy as np import tensorflow as tf from .utils import logging A__ : Optional[int] = logging.get_logger(__name__) def a_ ( _UpperCAmelCase : Union[tf.Tensor, np.ndarray] ) -> List[int]: if isinstance(_UpperCAmelCase ,np.ndarray ): return list(tensor.shape ) __snake_case : Optional[Any] = tf.shape(_UpperCAmelCase ) if tensor.shape == tf.TensorShape(_UpperCAmelCase ): return dynamic __snake_case : int = tensor.shape.as_list() return [dynamic[i] if s is None else s for i, s in enumerate(_UpperCAmelCase )] def a_ ( _UpperCAmelCase : tf.Tensor ,_UpperCAmelCase : Optional[int] = None ,_UpperCAmelCase : Optional[str] = None ) -> tf.Tensor: return tf.nn.softmax(logits=logits + 1E-9 ,axis=_UpperCAmelCase ,name=_UpperCAmelCase ) def a_ ( _UpperCAmelCase : Optional[int] ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : str ,_UpperCAmelCase : str=1E-5 ,_UpperCAmelCase : Union[str, Any]=-1 ) -> str: # This is a very simplified functional layernorm, designed to duplicate # the functionality of PyTorch nn.functional.layer_norm when this is needed to port # models in Transformers. if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise NotImplementedError('Only 1D weight and bias tensors are supported for now, with only a single axis.' ) # Get mean and variance on the axis to be normalized __snake_case : Union[str, Any] = tf.nn.moments(_UpperCAmelCase ,axes=[axis] ,keepdims=_UpperCAmelCase ) if axis != -1: # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions # on every dimension except axis __snake_case : Optional[Any] = [1] * inputs.shape.rank __snake_case : str = shape_list(_UpperCAmelCase )[axis] __snake_case : Any = tf.reshape(_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : int = tf.reshape(_UpperCAmelCase ,_UpperCAmelCase ) # Compute layer normalization using the batch_normalization # function. __snake_case : int = tf.nn.batch_normalization( _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ,offset=_UpperCAmelCase ,scale=_UpperCAmelCase ,variance_epsilon=_UpperCAmelCase ,) return outputs def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : Dict=0 ,_UpperCAmelCase : int=-1 ) -> Dict: # Replicates the behavior of torch.flatten in TF # If end_dim or start_dim is negative, count them from the end if end_dim < 0: end_dim += input.shape.rank if start_dim < 0: start_dim += input.shape.rank if start_dim == end_dim: return input __snake_case : Any = tf.shape(_UpperCAmelCase ) __snake_case : int = tf.math.reduce_prod(in_shape[start_dim : end_dim + 1] ) __snake_case : Dict = tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]] ,axis=0 ) return tf.reshape(_UpperCAmelCase ,_UpperCAmelCase ) def a_ ( _UpperCAmelCase : tf.Tensor ) -> tf.Tensor: if not isinstance(_UpperCAmelCase ,tf.Tensor ): __snake_case : List[str] = tf.convert_to_tensor(_UpperCAmelCase ) # Catches stray NumPy inputs if encoder_attention_mask.shape.rank == 3: __snake_case : Dict = encoder_attention_mask[:, None, :, :] if encoder_attention_mask.shape.rank == 2: __snake_case : List[str] = encoder_attention_mask[:, None, None, :] # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow # /transformer/transformer_layers.py#L270 # encoder_extended_attention_mask = (encoder_extended_attention_mask == # encoder_extended_attention_mask.transpose(-1, -2)) __snake_case : Any = ( tf.cast(1 ,encoder_attention_mask.dtype ) - encoder_extended_attention_mask ) * encoder_extended_attention_mask.dtype.min return encoder_extended_attention_mask def a_ ( _UpperCAmelCase : tf.Tensor ,_UpperCAmelCase : int ,_UpperCAmelCase : str = "input_ids" ) -> None: tf.debugging.assert_less( _UpperCAmelCase ,tf.cast(_UpperCAmelCase ,dtype=tensor.dtype ) ,message=( f'''The maximum value of {tensor_name} ({tf.math.reduce_max(_UpperCAmelCase )}) must be smaller than the embedding ''' f'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.''' ) ,) def a_ ( _UpperCAmelCase : Tuple ,_UpperCAmelCase : int ,_UpperCAmelCase : Tuple ) -> List[str]: __snake_case : Union[str, Any] = 6_45_12 # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT` # because in that case even chunking the array would not make the saving # possible. __snake_case : Any = [x for x in data if len(_UpperCAmelCase ) > HDF5_OBJECT_HEADER_LIMIT] # Expecting this to never be true. if bad_attributes: raise RuntimeError( 'The following attributes cannot be saved to HDF5 file because ' f'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} ''' f'''bytes: {bad_attributes}''' ) __snake_case : Tuple = np.asarray(_UpperCAmelCase ) __snake_case : List[Any] = 1 __snake_case : List[str] = np.array_split(_UpperCAmelCase ,_UpperCAmelCase ) # This will never loop forever thanks to the test above. while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data ): num_chunks += 1 __snake_case : List[str] = np.array_split(_UpperCAmelCase ,_UpperCAmelCase ) if num_chunks > 1: for chunk_id, chunk_data in enumerate(_UpperCAmelCase ): __snake_case : Dict = chunk_data else: __snake_case : Optional[int] = data def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Union[str, Any] ) -> Optional[Any]: if name in group.attrs: __snake_case : List[str] = [n.decode('utf8' ) if hasattr(_UpperCAmelCase ,'decode' ) else n for n in group.attrs[name]] else: __snake_case : int = [] __snake_case : Tuple = 0 while "%s%d" % (name, chunk_id) in group.attrs: data.extend( [n.decode('utf8' ) if hasattr(_UpperCAmelCase ,'decode' ) else n for n in group.attrs['%s%d' % (name, chunk_id)]] ) chunk_id += 1 return data def a_ ( _UpperCAmelCase : Optional[int] ) -> List[str]: def _expand_single_ad_tensor(_UpperCAmelCase : Tuple ): if isinstance(_UpperCAmelCase ,tf.Tensor ) and t.shape.rank == 1: return tf.expand_dims(_UpperCAmelCase ,axis=-1 ) return t return tf.nest.map_structure(_expand_single_ad_tensor ,_UpperCAmelCase )

'''simple docstring''' def a_ ( _UpperCAmelCase : int ) -> list: # bit count represents no. of bits in the gray code if bit_count < 0: raise ValueError('The given input must be positive' ) # get the generated string sequence __snake_case : Optional[Any] = gray_code_sequence_string(_UpperCAmelCase ) # # convert them to integers for i in range(len(_UpperCAmelCase ) ): __snake_case : Optional[Any] = int(sequence[i] ,2 ) return sequence def a_ ( _UpperCAmelCase : int ) -> list: # The approach is a recursive one # Base case achieved when either n = 0 or n=1 if bit_count == 0: return ["0"] if bit_count == 1: return ["0", "1"] __snake_case : Dict = 1 << bit_count # defines the length of the sequence # 1<< n is equivalent to 2^n # recursive answer will generate answer for n-1 bits __snake_case : Dict = gray_code_sequence_string(bit_count - 1 ) __snake_case : Any = [] # append 0 to first half of the smaller sequence generated for i in range(seq_len // 2 ): __snake_case : str = '0' + smaller_sequence[i] sequence.append(_UpperCAmelCase ) # append 1 to second half ... start from the end of the list for i in reversed(range(seq_len // 2 ) ): __snake_case : Any = '1' + smaller_sequence[i] sequence.append(_UpperCAmelCase ) return sequence if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' import warnings from .state import AcceleratorState, GradientState warnings.filterwarnings('''ignore''', category=UserWarning, module='''torch.optim.lr_scheduler''') class snake_case__ : def __init__( self : List[Any] , __a : Any , __a : Dict , __a : bool = True , __a : bool = False ) -> str: '''simple docstring''' __snake_case : Union[str, Any] = scheduler __snake_case : List[Any] = optimizers if isinstance(__a , (list, tuple) ) else [optimizers] __snake_case : List[Any] = split_batches __snake_case : str = step_with_optimizer __snake_case : int = GradientState() def A_ ( self : Optional[Any] , *__a : Tuple , **__a : Optional[Any] ) -> str: '''simple docstring''' if not self.step_with_optimizer: # No link between scheduler and optimizer -> just step self.scheduler.step(*__a , **__a ) return # Otherwise, first make sure the optimizer was stepped. if not self.gradient_state.sync_gradients: if self.gradient_state.adjust_scheduler: self.scheduler._step_count += 1 return for opt in self.optimizers: if opt.step_was_skipped: return if self.split_batches: # Split batches -> the training dataloader batch size is not changed so one step per training step self.scheduler.step(*__a , **__a ) else: # Otherwise the training dataloader batch size was multiplied by `num_processes`, so we need to do # num_processes steps per training step __snake_case : Dict = AcceleratorState().num_processes for _ in range(__a ): # Special case when using OneCycle and `drop_last` was not used if hasattr(self.scheduler , 'total_steps' ): if self.scheduler._step_count <= self.scheduler.total_steps: self.scheduler.step(*__a , **__a ) else: self.scheduler.step(*__a , **__a ) def A_ ( self : Tuple ) -> Dict: '''simple docstring''' return self.scheduler.get_last_lr() def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' return self.scheduler.state_dict() def A_ ( self : List[str] , __a : List[str] ) -> Optional[int]: '''simple docstring''' self.scheduler.load_state_dict(__a ) def A_ ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' return self.scheduler.get_lr() def A_ ( self : str , *__a : Union[str, Any] , **__a : int ) -> List[str]: '''simple docstring''' return self.scheduler.print_lr(*__a , **__a )

'''simple docstring''' import json import os import shutil import tempfile import unittest import numpy as np from transformers import BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer from transformers.testing_utils import require_tokenizers, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor @require_tokenizers @require_vision class snake_case__ ( unittest.TestCase ): def A_ ( self : int ) -> List[Any]: '''simple docstring''' __snake_case : Any = tempfile.mkdtemp() # fmt: off __snake_case : List[str] = ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest'] # fmt: on __snake_case : Any = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) __snake_case : List[str] = { 'do_resize': True, 'size': {'height': 18, 'width': 18}, 'do_normalize': True, 'image_mean': [0.5, 0.5, 0.5], 'image_std': [0.5, 0.5, 0.5], } __snake_case : Optional[Any] = os.path.join(self.tmpdirname , __a ) with open(self.image_processor_file , 'w' , encoding='utf-8' ) as fp: json.dump(__a , __a ) def A_ ( self : Optional[int] , **__a : Dict ) -> int: '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname , **__a ) def A_ ( self : int , **__a : Dict ) -> Tuple: '''simple docstring''' return ViTImageProcessor.from_pretrained(self.tmpdirname , **__a ) def A_ ( self : Optional[int] ) -> Optional[int]: '''simple docstring''' shutil.rmtree(self.tmpdirname ) def A_ ( self : str ) -> List[str]: '''simple docstring''' __snake_case : Optional[Any] = [np.random.randint(255 , size=(3, 30, 400) , dtype=np.uinta )] __snake_case : List[str] = [Image.fromarray(np.moveaxis(__a , 0 , -1 ) ) for x in image_inputs] return image_inputs def A_ ( self : List[str] ) -> Optional[int]: '''simple docstring''' __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Dict = self.get_image_processor() __snake_case : Any = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) processor.save_pretrained(self.tmpdirname ) __snake_case : Any = VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() ) self.assertIsInstance(processor.image_processor , __a ) def A_ ( self : str ) -> Optional[int]: '''simple docstring''' __snake_case : Optional[Any] = VisionTextDualEncoderProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) __snake_case : Optional[Any] = self.get_tokenizer(bos_token='(BOS)' , eos_token='(EOS)' ) __snake_case : Tuple = self.get_image_processor(do_normalize=__a , padding_value=1.0 ) __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor.from_pretrained( self.tmpdirname , bos_token='(BOS)' , eos_token='(EOS)' , do_normalize=__a , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , __a ) def A_ ( self : Optional[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Tuple = self.get_image_processor() __snake_case : int = self.get_tokenizer() __snake_case : str = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : int = self.prepare_image_inputs() __snake_case : List[str] = image_processor(__a , return_tensors='np' ) __snake_case : List[str] = processor(images=__a , return_tensors='np' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def A_ ( self : Optional[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Dict = self.get_image_processor() __snake_case : int = self.get_tokenizer() __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : Optional[int] = 'lower newer' __snake_case : Dict = processor(text=__a ) __snake_case : List[Any] = tokenizer(__a ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' __snake_case : Dict = self.get_image_processor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : List[Any] = 'lower newer' __snake_case : Optional[Any] = self.prepare_image_inputs() __snake_case : Union[str, Any] = processor(text=__a , images=__a ) self.assertListEqual(list(inputs.keys() ) , ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values'] ) # test if it raises when no input is passed with self.assertRaises(__a ): processor() def A_ ( self : Tuple ) -> Any: '''simple docstring''' __snake_case : Union[str, Any] = self.get_image_processor() __snake_case : Any = self.get_tokenizer() __snake_case : Dict = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __snake_case : int = processor.batch_decode(__a ) __snake_case : Optional[Any] = tokenizer.batch_decode(__a ) self.assertListEqual(__a , __a ) def A_ ( self : Optional[int] ) -> Optional[Any]: '''simple docstring''' __snake_case : List[str] = self.get_image_processor() __snake_case : Dict = self.get_tokenizer() __snake_case : Dict = VisionTextDualEncoderProcessor(tokenizer=__a , image_processor=__a ) __snake_case : Union[str, Any] = 'lower newer' __snake_case : Tuple = self.prepare_image_inputs() __snake_case : Union[str, Any] = processor(text=__a , images=__a ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names )

'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast from ...utils import logging A__ : str = logging.get_logger(__name__) A__ : Optional[int] = { '''EleutherAI/gpt-neo-1.3B''': '''https://huggingface.co/EleutherAI/gpt-neo-1.3B/resolve/main/config.json''', # See all GPTNeo models at https://huggingface.co/models?filter=gpt_neo } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''gpt_neo''' A__ = ['''past_key_values'''] A__ = {'''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : Union[str, Any] , __a : Tuple=50257 , __a : str=2048 , __a : Optional[Any]=2048 , __a : Union[str, Any]=24 , __a : List[str]=[[["global", "local"], 12]] , __a : Optional[int]=16 , __a : List[str]=None , __a : List[Any]=256 , __a : Union[str, Any]="gelu_new" , __a : Optional[int]=0.0 , __a : int=0.0 , __a : Dict=0.0 , __a : List[Any]=0.1 , __a : Tuple=1e-5 , __a : Union[str, Any]=0.0_2 , __a : Union[str, Any]=True , __a : List[str]=50256 , __a : Dict=50256 , **__a : int , ) -> Optional[Any]: '''simple docstring''' __snake_case : int = vocab_size __snake_case : List[str] = max_position_embeddings __snake_case : Optional[Any] = hidden_size __snake_case : List[str] = num_layers __snake_case : List[Any] = num_heads __snake_case : Optional[Any] = intermediate_size __snake_case : Optional[Any] = window_size __snake_case : int = activation_function __snake_case : Optional[int] = resid_dropout __snake_case : List[Any] = embed_dropout __snake_case : int = attention_dropout __snake_case : Any = classifier_dropout __snake_case : int = layer_norm_epsilon __snake_case : List[Any] = initializer_range __snake_case : List[Any] = use_cache __snake_case : Dict = bos_token_id __snake_case : List[Any] = eos_token_id __snake_case : Union[str, Any] = attention_types __snake_case : Union[str, Any] = self.expand_attention_types_params(__a ) if len(self.attention_layers ) != self.num_layers: raise ValueError( 'Configuration for convolutional module is incorrect. ' 'It is required that `len(config.attention_layers)` == `config.num_layers` ' f'''but is `len(config.attention_layers) = {len(self.attention_layers )}`, ''' f'''`config.num_layers = {self.num_layers}`. ''' '`config.attention_layers` is prepared using `config.attention_types`. ' 'Please verify the value of `config.attention_types` argument.' ) super().__init__(bos_token_id=__a , eos_token_id=__a , **__a ) @staticmethod def A_ ( __a : Tuple ) -> Union[str, Any]: '''simple docstring''' __snake_case : Tuple = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def a_ ( _UpperCAmelCase : List[Any] ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Dict ,_UpperCAmelCase : Union[str, Any] ) -> List[Any]: import torch __snake_case : Tuple = input.size() __snake_case : Any = len(_UpperCAmelCase ) __snake_case : Any = shape[dimension] __snake_case : Any = torch.arange(0 ,_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : int = torch.div(sizedim - size ,_UpperCAmelCase ,rounding_mode='floor' ) + 1 __snake_case : List[Any] = torch.arange(_UpperCAmelCase ) + low_indices[:min_length][:, None] __snake_case : int = [slice(_UpperCAmelCase )] * rank __snake_case : Optional[Any] = indices __snake_case : Union[str, Any] = input[s] __snake_case : List[Any] = list(range(0 ,rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : Any ) -> Any: import torch __snake_case : Union[str, Any] = torch.arange(1 ,_UpperCAmelCase ) __snake_case : Dict = torch.remainder(_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : Optional[int] = remainders == 0 __snake_case : Tuple = candidates[divisor_indices] __snake_case : str = torch.max(_UpperCAmelCase ) return largest_divisor, torch.div(_UpperCAmelCase ,_UpperCAmelCase ,rounding_mode='floor' ) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): @property def A_ ( self : Optional[int] ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' __snake_case : Optional[int] = OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}} ) if self.use_past: self.fill_with_past_key_values_(__a , direction='inputs' ) __snake_case : Dict = {0: 'batch', 1: 'past_sequence + sequence'} else: __snake_case : Tuple = {0: 'batch', 1: 'sequence'} return common_inputs @property def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' return self._config.num_heads def A_ ( self : Dict , __a : PreTrainedTokenizer , __a : int = -1 , __a : int = -1 , __a : bool = False , __a : Optional[TensorType] = None , ) -> Mapping[str, Any]: '''simple docstring''' __snake_case : Tuple = super(__a , self ).generate_dummy_inputs( __a , batch_size=__a , seq_length=__a , is_pair=__a , framework=__a ) # We need to order the input in the way they appears in the forward() __snake_case : Union[str, Any] = OrderedDict({'input_ids': common_inputs['input_ids']} ) # Need to add the past_keys if self.use_past: if not is_torch_available(): raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.' ) else: import torch __snake_case : int = common_inputs['input_ids'].shape # Not using the same length for past_key_values __snake_case : List[Any] = seqlen + 2 __snake_case : Union[str, Any] = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) __snake_case : Optional[Any] = [ (torch.zeros(__a ), torch.zeros(__a )) for _ in range(self.num_layers ) ] __snake_case : Dict = common_inputs['attention_mask'] if self.use_past: __snake_case : Dict = ordered_inputs['attention_mask'].dtype __snake_case : Dict = torch.cat( [ordered_inputs['attention_mask'], torch.ones(__a , __a , dtype=__a )] , dim=1 ) return ordered_inputs @property def A_ ( self : int ) -> int: '''simple docstring''' return 13

'''simple docstring''' import argparse import json from collections import OrderedDict import torch from huggingface_hub import cached_download, hf_hub_url from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification def a_ ( _UpperCAmelCase : List[Any] ) -> Tuple: __snake_case : str = [] 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 a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Optional[int] ) -> List[str]: __snake_case : 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 a_ ( _UpperCAmelCase : Union[str, Any] ) -> Dict: __snake_case : Union[str, Any] = [] token.append((f'''cvt.encoder.stages.{idx}.cls_token''', 'stage2.cls_token') ) return token def a_ ( ) -> Optional[Any]: __snake_case : 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 a_ ( _UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : Any ,_UpperCAmelCase : Tuple ,_UpperCAmelCase : Optional[Any] ) -> Tuple: __snake_case : List[str] = 'imagenet-1k-id2label.json' __snake_case : Dict = 10_00 __snake_case : Union[str, Any] = 'huggingface/label-files' __snake_case : str = num_labels __snake_case : str = json.load(open(cached_download(hf_hub_url(_UpperCAmelCase ,_UpperCAmelCase ,repo_type='dataset' ) ) ,'r' ) ) __snake_case : Tuple = {int(_UpperCAmelCase ): v for k, v in idalabel.items()} __snake_case : Optional[Any] = idalabel __snake_case : str = {v: k for k, v in idalabel.items()} __snake_case : Dict = CvtConfig(num_labels=_UpperCAmelCase ,idalabel=_UpperCAmelCase ,labelaid=_UpperCAmelCase ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit('/' ,1 )[-1][4:6] == "13": __snake_case : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit('/' ,1 )[-1][4:6] == "21": __snake_case : str = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: __snake_case : Dict = [2, 2, 20] __snake_case : Any = [3, 12, 16] __snake_case : Tuple = [1_92, 7_68, 10_24] __snake_case : str = CvtForImageClassification(_UpperCAmelCase ) __snake_case : List[Any] = AutoImageProcessor.from_pretrained('facebook/convnext-base-224-22k-1k' ) __snake_case : int = image_size __snake_case : int = torch.load(_UpperCAmelCase ,map_location=torch.device('cpu' ) ) __snake_case : List[Any] = OrderedDict() __snake_case : Union[str, Any] = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: __snake_case : Optional[Any] = list_of_state_dict + cls_token(_UpperCAmelCase ) __snake_case : Tuple = list_of_state_dict + embeddings(_UpperCAmelCase ) for cnt in range(config.depth[idx] ): __snake_case : Optional[int] = list_of_state_dict + attention(_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : str = list_of_state_dict + final() for gg in list_of_state_dict: print(_UpperCAmelCase ) for i in range(len(_UpperCAmelCase ) ): __snake_case : List[str] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(_UpperCAmelCase ) model.save_pretrained(_UpperCAmelCase ) image_processor.save_pretrained(_UpperCAmelCase ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": A__ : Dict = 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_8_4, 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.''' ) A__ : Tuple = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)

'''simple docstring''' def a_ ( _UpperCAmelCase : int = 10_00 ) -> int: __snake_case : Union[str, Any] = 1, 1 __snake_case : Dict = [] for i in range(1 ,n + 1 ): __snake_case : Optional[Any] = prev_numerator + 2 * prev_denominator __snake_case : int = prev_numerator + prev_denominator if len(str(_UpperCAmelCase ) ) > len(str(_UpperCAmelCase ) ): result.append(_UpperCAmelCase ) __snake_case : int = numerator __snake_case : Union[str, Any] = denominator return len(_UpperCAmelCase ) if __name__ == "__main__": print(F"""{solution() = }""")

'''simple docstring''' from __future__ import annotations A__ : List[Any] = list[list[int]] # assigning initial values to the grid A__ : Matrix = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution A__ : Matrix = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def a_ ( _UpperCAmelCase : Matrix ,_UpperCAmelCase : int ,_UpperCAmelCase : int ,_UpperCAmelCase : int ) -> bool: for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def a_ ( _UpperCAmelCase : Matrix ) -> tuple[int, int] | None: for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def a_ ( _UpperCAmelCase : Matrix ) -> Matrix | None: if location := find_empty_location(_UpperCAmelCase ): __snake_case , __snake_case : Optional[int] = location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 ,10 ): if is_safe(_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ): __snake_case : Union[str, Any] = digit if sudoku(_UpperCAmelCase ) is not None: return grid __snake_case : Optional[Any] = 0 return None def a_ ( _UpperCAmelCase : Matrix ) -> None: for row in grid: for cell in row: print(_UpperCAmelCase ,end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print('''\nExample grid:\n''' + '''=''' * 2_0) print_solution(example_grid) print('''\nExample grid solution:''') A__ : List[str] = sudoku(example_grid) if solution is not None: print_solution(solution) else: print('''Cannot find a solution.''')

from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available A__ : Optional[Any] = { '''configuration_nllb_moe''': [ '''NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NllbMoeConfig''', ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ '''NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST''', '''NllbMoeForConditionalGeneration''', '''NllbMoeModel''', '''NllbMoePreTrainedModel''', '''NllbMoeTop2Router''', '''NllbMoeSparseMLP''', ] if TYPE_CHECKING: from .configuration_nllb_moe import ( NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP, NllbMoeConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nllb_moe import ( NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST, NllbMoeForConditionalGeneration, NllbMoeModel, NllbMoePreTrainedModel, NllbMoeSparseMLP, NllbMoeTopaRouter, ) else: import sys A__ : str = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' import unittest import numpy as np import torch from torch import nn from transformers import ( CLIPImageProcessor, CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer, CLIPVisionConfig, CLIPVisionModelWithProjection, ) from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler from diffusers.utils import torch_device from diffusers.utils.testing_utils import enable_full_determinism, skip_mps from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = KandinskyVaaPriorPipeline A__ = ['''prompt'''] A__ = ['''prompt''', '''negative_prompt'''] A__ = [ '''num_images_per_prompt''', '''generator''', '''num_inference_steps''', '''latents''', '''negative_prompt''', '''guidance_scale''', '''output_type''', '''return_dict''', ] A__ = False @property def A_ ( self : Dict ) -> List[str]: '''simple docstring''' return 32 @property def A_ ( self : Any ) -> str: '''simple docstring''' return 32 @property def A_ ( self : str ) -> Optional[int]: '''simple docstring''' return self.time_input_dim @property def A_ ( self : str ) -> int: '''simple docstring''' return self.time_input_dim * 4 @property def A_ ( self : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' return 100 @property def A_ ( self : Tuple ) -> List[str]: '''simple docstring''' __snake_case : Tuple = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) return tokenizer @property def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Union[str, Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) return CLIPTextModelWithProjection(__a ) @property def A_ ( self : Union[str, Any] ) -> Any: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Any = { 'num_attention_heads': 2, 'attention_head_dim': 12, 'embedding_dim': self.text_embedder_hidden_size, 'num_layers': 1, } __snake_case : List[Any] = PriorTransformer(**__a ) # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0 __snake_case : Any = nn.Parameter(torch.ones(model.clip_std.shape ) ) return model @property def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Optional[Any] = CLIPVisionConfig( hidden_size=self.text_embedder_hidden_size , image_size=224 , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , num_attention_heads=4 , num_channels=3 , num_hidden_layers=5 , patch_size=14 , ) __snake_case : Optional[Any] = CLIPVisionModelWithProjection(__a ) return model @property def A_ ( self : Dict ) -> List[Any]: '''simple docstring''' __snake_case : Dict = CLIPImageProcessor( crop_size=224 , do_center_crop=__a , do_normalize=__a , do_resize=__a , image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3] , image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1] , resample=3 , size=224 , ) return image_processor def A_ ( self : Dict ) -> Optional[int]: '''simple docstring''' __snake_case : Tuple = self.dummy_prior __snake_case : List[str] = self.dummy_image_encoder __snake_case : str = self.dummy_text_encoder __snake_case : List[str] = self.dummy_tokenizer __snake_case : List[str] = self.dummy_image_processor __snake_case : Any = UnCLIPScheduler( variance_type='fixed_small_log' , prediction_type='sample' , num_train_timesteps=1000 , clip_sample=__a , clip_sample_range=1_0.0 , ) __snake_case : str = { 'prior': prior, 'image_encoder': image_encoder, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'scheduler': scheduler, 'image_processor': image_processor, } return components def A_ ( self : List[Any] , __a : Optional[Any] , __a : Tuple=0 ) -> Any: '''simple docstring''' if str(__a ).startswith('mps' ): __snake_case : List[str] = torch.manual_seed(__a ) else: __snake_case : List[str] = torch.Generator(device=__a ).manual_seed(__a ) __snake_case : List[Any] = { 'prompt': 'horse', 'generator': generator, 'guidance_scale': 4.0, 'num_inference_steps': 2, 'output_type': 'np', } return inputs def A_ ( self : str ) -> Dict: '''simple docstring''' __snake_case : str = 'cpu' __snake_case : List[str] = self.get_dummy_components() __snake_case : Tuple = self.pipeline_class(**__a ) __snake_case : Optional[Any] = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[int] = pipe(**self.get_dummy_inputs(__a ) ) __snake_case : List[str] = output.image_embeds __snake_case : str = pipe( **self.get_dummy_inputs(__a ) , return_dict=__a , )[0] __snake_case : Union[str, Any] = image[0, -10:] __snake_case : Any = image_from_tuple[0, -10:] assert image.shape == (1, 32) __snake_case : List[Any] = np.array( [-0.0_5_3_2, 1.7_1_2_0, 0.3_6_5_6, -1.0_8_5_2, -0.8_9_4_6, -1.1_7_5_6, 0.4_3_4_8, 0.2_4_8_2, 0.5_1_4_6, -0.1_1_5_6] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2 @skip_mps def A_ ( self : Tuple ) -> Optional[int]: '''simple docstring''' __snake_case : Union[str, Any] = torch_device == 'cpu' __snake_case : Dict = True __snake_case : Union[str, Any] = False self._test_inference_batch_single_identical( test_max_difference=__a , relax_max_difference=__a , test_mean_pixel_difference=__a , ) @skip_mps def A_ ( self : str ) -> Union[str, Any]: '''simple docstring''' __snake_case : Dict = torch_device == 'cpu' __snake_case : Optional[Any] = False self._test_attention_slicing_forward_pass( test_max_difference=__a , test_mean_pixel_difference=__a , )

'''simple docstring''' import json import os import tempfile from transformers.testing_utils import check_json_file_has_correct_format class snake_case__ : A__ = None def A_ ( self : List[str] ) -> List[Any]: '''simple docstring''' __snake_case : Union[str, Any] = self.feature_extraction_class(**self.feat_extract_dict ) __snake_case : str = json.loads(feat_extract.to_json_string() ) for key, value in self.feat_extract_dict.items(): self.assertEqual(obj[key] , __a ) def A_ ( self : List[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Any = self.feature_extraction_class(**self.feat_extract_dict ) with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : Dict = os.path.join(__a , 'feat_extract.json' ) feat_extract_first.to_json_file(__a ) __snake_case : List[str] = self.feature_extraction_class.from_json_file(__a ) self.assertEqual(feat_extract_second.to_dict() , feat_extract_first.to_dict() ) def A_ ( self : int ) -> Union[str, Any]: '''simple docstring''' __snake_case : List[str] = self.feature_extraction_class(**self.feat_extract_dict ) with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : Optional[int] = feat_extract_first.save_pretrained(__a )[0] check_json_file_has_correct_format(__a ) __snake_case : Tuple = self.feature_extraction_class.from_pretrained(__a ) self.assertEqual(feat_extract_second.to_dict() , feat_extract_first.to_dict() ) def A_ ( self : Tuple ) -> Optional[Any]: '''simple docstring''' __snake_case : Any = self.feature_extraction_class() self.assertIsNotNone(__a )

'''simple docstring''' from math import factorial A__ : dict[str, int] = {str(digit): factorial(digit) for digit in range(1_0)} def a_ ( _UpperCAmelCase : int ) -> int: if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise TypeError('Parameter number must be int' ) if number < 0: raise ValueError('Parameter number must be greater than or equal to 0' ) # Converts number in string to iterate on its digits and adds its factorial. return sum(DIGIT_FACTORIAL[digit] for digit in str(_UpperCAmelCase ) ) def a_ ( _UpperCAmelCase : int = 60 ,_UpperCAmelCase : int = 1_00_00_00 ) -> int: if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ) or not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise TypeError('Parameters chain_length and number_limit must be int' ) if chain_length <= 0 or number_limit <= 0: raise ValueError( 'Parameters chain_length and number_limit must be greater than 0' ) # the counter for the chains with the exact desired length __snake_case : List[str] = 0 # the cached sizes of the previous chains __snake_case : dict[int, int] = {} for start_chain_element in range(1 ,_UpperCAmelCase ): # The temporary set will contain the elements of the chain __snake_case : Optional[int] = set() __snake_case : List[Any] = 0 # Stop computing the chain when you find a cached size, a repeating item or the # length is greater then the desired one. __snake_case : str = start_chain_element while ( chain_element not in chain_sets_lengths and chain_element not in chain_set and chain_set_length <= chain_length ): chain_set.add(_UpperCAmelCase ) chain_set_length += 1 __snake_case : Tuple = digit_factorial_sum(_UpperCAmelCase ) if chain_element in chain_sets_lengths: chain_set_length += chain_sets_lengths[chain_element] __snake_case : Optional[Any] = chain_set_length # If chain contains the exact amount of elements increase the counter if chain_set_length == chain_length: chains_counter += 1 return chains_counter if __name__ == "__main__": import doctest doctest.testmod() print(F"""{solution()}""")

'''simple docstring''' import os # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_doctest_list.py A__ : Optional[Any] = '''.''' if __name__ == "__main__": A__ : Optional[Any] = os.path.join(REPO_PATH, '''utils/documentation_tests.txt''') A__ : int = [] A__ : str = [] with open(doctest_file_path) as fp: for line in fp: A__ : Union[str, Any] = line.strip() A__ : Optional[Any] = os.path.join(REPO_PATH, line) if not (os.path.isfile(path) or os.path.isdir(path)): non_existent_paths.append(line) all_paths.append(path) if len(non_existent_paths) > 0: A__ : Union[str, Any] = '''\n'''.join(non_existent_paths) raise ValueError(F"""`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}""") if all_paths != sorted(all_paths): raise ValueError('''Files in `utils/documentation_tests.txt` are not in alphabetical order.''')

'''simple docstring''' def a_ ( _UpperCAmelCase : int = 1_00 ) -> int: __snake_case : Any = n * (n + 1) * (2 * n + 1) / 6 __snake_case : Union[str, Any] = (n * (n + 1) / 2) ** 2 return int(square_of_sum - sum_of_squares ) if __name__ == "__main__": print(F"""{solution() = }""")

'''simple docstring''' def a_ ( _UpperCAmelCase : float ) -> float: if edge <= 0 or not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise ValueError('Length must be a positive.' ) return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2) def a_ ( _UpperCAmelCase : float ) -> float: if edge <= 0 or not isinstance(_UpperCAmelCase ,_UpperCAmelCase ): raise ValueError('Length must be a positive.' ) return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3) if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available A__ : int = { '''configuration_groupvit''': [ '''GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GroupViTConfig''', '''GroupViTOnnxConfig''', '''GroupViTTextConfig''', '''GroupViTVisionConfig''', ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Tuple = [ '''GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''GroupViTModel''', '''GroupViTPreTrainedModel''', '''GroupViTTextModel''', '''GroupViTVisionModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Optional[int] = [ '''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 A__ : List[str] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) A__ : Any = { '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''], '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''], '''processing_wav2vec2''': ['''Wav2Vec2Processor'''], '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Optional[int] = [ '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''', '''Wav2Vec2ForAudioFrameClassification''', '''Wav2Vec2ForCTC''', '''Wav2Vec2ForMaskedLM''', '''Wav2Vec2ForPreTraining''', '''Wav2Vec2ForSequenceClassification''', '''Wav2Vec2ForXVector''', '''Wav2Vec2Model''', '''Wav2Vec2PreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Optional[int] = [ '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFWav2Vec2ForCTC''', '''TFWav2Vec2Model''', '''TFWav2Vec2PreTrainedModel''', '''TFWav2Vec2ForSequenceClassification''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A__ : Dict = [ '''FlaxWav2Vec2ForCTC''', '''FlaxWav2Vec2ForPreTraining''', '''FlaxWav2Vec2Model''', '''FlaxWav2Vec2PreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig from .feature_extraction_wavaveca import WavaVecaFeatureExtractor from .processing_wavaveca import WavaVecaProcessor from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavaveca import ( WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST, WavaVecaForAudioFrameClassification, WavaVecaForCTC, WavaVecaForMaskedLM, WavaVecaForPreTraining, WavaVecaForSequenceClassification, WavaVecaForXVector, WavaVecaModel, WavaVecaPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_wavaveca import ( TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST, TFWavaVecaForCTC, TFWavaVecaForSequenceClassification, TFWavaVecaModel, TFWavaVecaPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_wavaveca import ( FlaxWavaVecaForCTC, FlaxWavaVecaForPreTraining, FlaxWavaVecaModel, FlaxWavaVecaPreTrainedModel, ) else: import sys A__ : str = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring''' import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline from diffusers.pipelines.shap_e import ShapERenderer from diffusers.utils import load_numpy, slow from diffusers.utils.testing_utils import require_torch_gpu, torch_device from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference class snake_case__ ( SCREAMING_SNAKE_CASE_ , unittest.TestCase ): A__ = ShapEPipeline A__ = ['''prompt'''] A__ = ['''prompt'''] A__ = [ '''num_images_per_prompt''', '''num_inference_steps''', '''generator''', '''latents''', '''guidance_scale''', '''frame_size''', '''output_type''', '''return_dict''', ] A__ = False @property def A_ ( self : Optional[Any] ) -> str: '''simple docstring''' return 32 @property def A_ ( self : str ) -> Optional[int]: '''simple docstring''' return 32 @property def A_ ( self : Tuple ) -> List[Any]: '''simple docstring''' return self.time_input_dim * 4 @property def A_ ( self : Tuple ) -> Dict: '''simple docstring''' return 8 @property def A_ ( self : Optional[Any] ) -> List[str]: '''simple docstring''' __snake_case : Dict = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) return tokenizer @property def A_ ( self : List[Any] ) -> Optional[Any]: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Optional[int] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) return CLIPTextModelWithProjection(__a ) @property def A_ ( self : Union[str, Any] ) -> int: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Dict = { 'num_attention_heads': 2, 'attention_head_dim': 16, 'embedding_dim': self.time_input_dim, 'num_embeddings': 32, 'embedding_proj_dim': self.text_embedder_hidden_size, 'time_embed_dim': self.time_embed_dim, 'num_layers': 1, 'clip_embed_dim': self.time_input_dim * 2, 'additional_embeddings': 0, 'time_embed_act_fn': 'gelu', 'norm_in_type': 'layer', 'encoder_hid_proj_type': None, 'added_emb_type': None, } __snake_case : Optional[Any] = PriorTransformer(**__a ) return model @property def A_ ( self : Dict ) -> Dict: '''simple docstring''' torch.manual_seed(0 ) __snake_case : Tuple = { 'param_shapes': ( (self.renderer_dim, 93), (self.renderer_dim, 8), (self.renderer_dim, 8), (self.renderer_dim, 8), ), 'd_latent': self.time_input_dim, 'd_hidden': self.renderer_dim, 'n_output': 12, 'background': ( 0.1, 0.1, 0.1, ), } __snake_case : Optional[int] = ShapERenderer(**__a ) return model def A_ ( self : Tuple ) -> Tuple: '''simple docstring''' __snake_case : Tuple = self.dummy_prior __snake_case : Union[str, Any] = self.dummy_text_encoder __snake_case : List[str] = self.dummy_tokenizer __snake_case : Optional[Any] = self.dummy_renderer __snake_case : List[Any] = HeunDiscreteScheduler( beta_schedule='exp' , num_train_timesteps=1024 , prediction_type='sample' , use_karras_sigmas=__a , clip_sample=__a , clip_sample_range=1.0 , ) __snake_case : int = { 'prior': prior, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'renderer': renderer, 'scheduler': scheduler, } return components def A_ ( self : Union[str, Any] , __a : Dict , __a : int=0 ) -> Optional[Any]: '''simple docstring''' if str(__a ).startswith('mps' ): __snake_case : List[str] = torch.manual_seed(__a ) else: __snake_case : Optional[Any] = torch.Generator(device=__a ).manual_seed(__a ) __snake_case : Optional[int] = { 'prompt': 'horse', 'generator': generator, 'num_inference_steps': 1, 'frame_size': 32, 'output_type': 'np', } return inputs def A_ ( self : List[Any] ) -> List[Any]: '''simple docstring''' __snake_case : Dict = 'cpu' __snake_case : Dict = self.get_dummy_components() __snake_case : int = self.pipeline_class(**__a ) __snake_case : str = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[Any] = pipe(**self.get_dummy_inputs(__a ) ) __snake_case : Dict = output.images[0] __snake_case : int = image[0, -3:, -3:, -1] assert image.shape == (20, 32, 32, 3) __snake_case : str = np.array( [ 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, 0.0_0_0_3_9_2_1_6, ] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def A_ ( self : Any ) -> List[str]: '''simple docstring''' # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches self._test_inference_batch_consistent(batch_sizes=[1, 2] ) def A_ ( self : int ) -> Tuple: '''simple docstring''' __snake_case : int = torch_device == 'cpu' __snake_case : str = True self._test_inference_batch_single_identical( batch_size=2 , test_max_difference=__a , relax_max_difference=__a , ) def A_ ( self : List[str] ) -> Dict: '''simple docstring''' __snake_case : str = self.get_dummy_components() __snake_case : Tuple = self.pipeline_class(**__a ) __snake_case : Dict = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : int = 1 __snake_case : Tuple = 2 __snake_case : Tuple = self.get_dummy_inputs(__a ) for key in inputs.keys(): if key in self.batch_params: __snake_case : Union[str, Any] = batch_size * [inputs[key]] __snake_case : str = pipe(**__a , num_images_per_prompt=__a )[0] assert images.shape[0] == batch_size * num_images_per_prompt @slow @require_torch_gpu class snake_case__ ( unittest.TestCase ): def A_ ( self : str ) -> Dict: '''simple docstring''' # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def A_ ( self : List[str] ) -> Union[str, Any]: '''simple docstring''' __snake_case : Optional[int] = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/test_shap_e_np_out.npy' ) __snake_case : Union[str, Any] = ShapEPipeline.from_pretrained('openai/shap-e' ) __snake_case : Any = pipe.to(__a ) pipe.set_progress_bar_config(disable=__a ) __snake_case : Optional[int] = torch.Generator(device=__a ).manual_seed(0 ) __snake_case : Union[str, Any] = pipe( 'a shark' , generator=__a , guidance_scale=1_5.0 , num_inference_steps=64 , frame_size=64 , output_type='np' , ).images[0] assert images.shape == (20, 64, 64, 3) assert_mean_pixel_difference(__a , __a )

'''simple docstring''' A__ : Tuple = [sum(int(c, 1_0) ** 2 for c in i.__str__()) for i in range(1_0_0_0_0_0)] def a_ ( _UpperCAmelCase : int ) -> int: __snake_case : Dict = 0 while number: # Increased Speed Slightly by checking every 5 digits together. sum_of_digits_squared += DIGITS_SQUARED[number % 10_00_00] number //= 10_00_00 return sum_of_digits_squared # There are 2 Chains made, # One ends with 89 with the chain member 58 being the one which when declared first, # there will be the least number of iterations for all the members to be checked. # The other one ends with 1 and has only one element 1. # So 58 and 1 are chosen to be declared at the starting. # Changed dictionary to an array to quicken the solution A__ : list[bool | None] = [None] * 1_0_0_0_0_0_0_0 A__ : Optional[Any] = True A__ : int = False def a_ ( _UpperCAmelCase : int ) -> bool: if CHAINS[number - 1] is not None: return CHAINS[number - 1] # type: ignore __snake_case : List[str] = chain(next_number(_UpperCAmelCase ) ) __snake_case : Optional[Any] = number_chain while number < 10_00_00_00: __snake_case : Tuple = number_chain number *= 10 return number_chain def a_ ( _UpperCAmelCase : int = 10_00_00_00 ) -> int: for i in range(1 ,_UpperCAmelCase ): if CHAINS[i] is None: chain(i + 1 ) return CHAINS[:number].count(_UpperCAmelCase ) if __name__ == "__main__": import doctest doctest.testmod() print(F"""{solution() = }""")

'''simple docstring''' from __future__ import annotations import time import numpy as np A__ : str = [8, 5, 9, 7] A__ : List[str] = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] A__ : Dict = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class snake_case__ : def __init__( self : Union[str, Any] , __a : list[int] , __a : list[list[int]] , __a : list[list[int]] , ) -> None: '''simple docstring''' __snake_case : int = claim_vector __snake_case : Optional[int] = allocated_resources_table __snake_case : List[str] = maximum_claim_table def A_ ( self : str ) -> list[int]: '''simple docstring''' return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def A_ ( self : int ) -> list[int]: '''simple docstring''' return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def A_ ( self : int ) -> list[list[int]]: '''simple docstring''' return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(__a ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def A_ ( self : str ) -> dict[int, list[int]]: '''simple docstring''' return {self.__need().index(__a ): i for i in self.__need()} def A_ ( self : Union[str, Any] , **__a : int ) -> None: '''simple docstring''' __snake_case : str = self.__need() __snake_case : List[Any] = self.__allocated_resources_table __snake_case : Optional[int] = self.__available_resources() __snake_case : Union[str, Any] = self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('_' * 50 + '\n' ) while need_list: __snake_case : Tuple = False for each_need in need_list: __snake_case : Any = True for index, need in enumerate(__a ): if need > available_resources[index]: __snake_case : List[str] = False break if execution: __snake_case : Union[str, Any] = True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: __snake_case : str = original_need_index print(f'''Process {process_number + 1} is executing.''' ) # remove the process run from stack need_list.remove(__a ) # update available/freed resources stack __snake_case : Union[str, Any] = np.array(__a ) + np.array( alloc_resources_table[process_number] ) print( 'Updated available resource stack for processes: ' + ' '.join([str(__a ) for x in available_resources] ) ) break if safe: print('The process is in a safe state.\n' ) else: print('System in unsafe state. Aborting...\n' ) break def A_ ( self : List[str] ) -> Optional[int]: '''simple docstring''' print(' ' * 9 + 'Allocated Resource Table' ) for item in self.__allocated_resources_table: print( f'''P{self.__allocated_resources_table.index(__a ) + 1}''' + ' '.join(f'''{it:>8}''' for it in item ) + '\n' ) print(' ' * 9 + 'System Resource Table' ) for item in self.__maximum_claim_table: print( f'''P{self.__maximum_claim_table.index(__a ) + 1}''' + ' '.join(f'''{it:>8}''' for it in item ) + '\n' ) print( 'Current Usage by Active Processes: ' + ' '.join(str(__a ) for x in self.__claim_vector ) ) print( 'Initial Available Resources: ' + ' '.join(str(__a ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' import numpy as np def a_ ( _UpperCAmelCase : np.ndarray ,_UpperCAmelCase : np.ndarray ,_UpperCAmelCase : float = 1E-12 ,_UpperCAmelCase : int = 1_00 ,) -> tuple[float, np.ndarray]: assert np.shape(_UpperCAmelCase )[0] == np.shape(_UpperCAmelCase )[1] # Ensure proper dimensionality. assert np.shape(_UpperCAmelCase )[0] == np.shape(_UpperCAmelCase )[0] # Ensure inputs are either both complex or both real assert np.iscomplexobj(_UpperCAmelCase ) == np.iscomplexobj(_UpperCAmelCase ) __snake_case : Dict = np.iscomplexobj(_UpperCAmelCase ) if is_complex: # Ensure complex input_matrix is Hermitian assert np.array_equal(_UpperCAmelCase ,input_matrix.conj().T ) # Set convergence to False. Will define convergence when we exceed max_iterations # or when we have small changes from one iteration to next. __snake_case : Union[str, Any] = False __snake_case : Dict = 0 __snake_case : Any = 0 __snake_case : List[str] = 1E12 while not convergence: # Multiple matrix by the vector. __snake_case : Union[str, Any] = np.dot(_UpperCAmelCase ,_UpperCAmelCase ) # Normalize the resulting output vector. __snake_case : int = w / np.linalg.norm(_UpperCAmelCase ) # Find rayleigh quotient # (faster than usual b/c we know vector is normalized already) __snake_case : Dict = vector.conj().T if is_complex else vector.T __snake_case : Optional[Any] = np.dot(_UpperCAmelCase ,np.dot(_UpperCAmelCase ,_UpperCAmelCase ) ) # Check convergence. __snake_case : Any = np.abs(lambda_ - lambda_previous ) / lambda_ iterations += 1 if error <= error_tol or iterations >= max_iterations: __snake_case : str = True __snake_case : List[Any] = lambda_ if is_complex: __snake_case : List[Any] = np.real(lambda_ ) return lambda_, vector def a_ ( ) -> None: __snake_case : Optional[int] = np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]] ) __snake_case : List[Any] = np.array([41, 4, 20] ) __snake_case : str = real_input_matrix.astype(np.complexaaa ) __snake_case : Optional[int] = np.triu(1J * complex_input_matrix ,1 ) complex_input_matrix += imag_matrix complex_input_matrix += -1 * imag_matrix.T __snake_case : int = np.array([41, 4, 20] ).astype(np.complexaaa ) for problem_type in ["real", "complex"]: if problem_type == "real": __snake_case : List[Any] = real_input_matrix __snake_case : Optional[int] = real_vector elif problem_type == "complex": __snake_case : Dict = complex_input_matrix __snake_case : Dict = complex_vector # Our implementation. __snake_case : Any = power_iteration(_UpperCAmelCase ,_UpperCAmelCase ) # Numpy implementation. # Get eigenvalues and eigenvectors using built-in numpy # eigh (eigh used for symmetric or hermetian matrices). __snake_case : List[Any] = np.linalg.eigh(_UpperCAmelCase ) # Last eigenvalue is the maximum one. __snake_case : str = eigen_values[-1] # Last column in this matrix is eigenvector corresponding to largest eigenvalue. __snake_case : str = eigen_vectors[:, -1] # Check our implementation and numpy gives close answers. assert np.abs(eigen_value - eigen_value_max ) <= 1E-6 # Take absolute values element wise of each eigenvector. # as they are only unique to a minus sign. assert np.linalg.norm(np.abs(_UpperCAmelCase ) - np.abs(_UpperCAmelCase ) ) <= 1E-6 if __name__ == "__main__": import doctest doctest.testmod() test_power_iteration()

'''simple docstring''' import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from .tokenization_electra import ElectraTokenizer A__ : Union[str, Any] = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''} A__ : List[Any] = { '''vocab_file''': { '''google/electra-small-generator''': ( '''https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt''' ), '''google/electra-base-generator''': '''https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt''', '''google/electra-large-generator''': ( '''https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt''' ), '''google/electra-small-discriminator''': ( '''https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt''' ), '''google/electra-base-discriminator''': ( '''https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt''' ), '''google/electra-large-discriminator''': ( '''https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt''' ), }, '''tokenizer_file''': { '''google/electra-small-generator''': ( '''https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json''' ), '''google/electra-base-generator''': ( '''https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json''' ), '''google/electra-large-generator''': ( '''https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json''' ), '''google/electra-small-discriminator''': ( '''https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json''' ), '''google/electra-base-discriminator''': ( '''https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json''' ), '''google/electra-large-discriminator''': ( '''https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json''' ), }, } A__ : List[Any] = { '''google/electra-small-generator''': 5_1_2, '''google/electra-base-generator''': 5_1_2, '''google/electra-large-generator''': 5_1_2, '''google/electra-small-discriminator''': 5_1_2, '''google/electra-base-discriminator''': 5_1_2, '''google/electra-large-discriminator''': 5_1_2, } A__ : Optional[Any] = { '''google/electra-small-generator''': {'''do_lower_case''': True}, '''google/electra-base-generator''': {'''do_lower_case''': True}, '''google/electra-large-generator''': {'''do_lower_case''': True}, '''google/electra-small-discriminator''': {'''do_lower_case''': True}, '''google/electra-base-discriminator''': {'''do_lower_case''': True}, '''google/electra-large-discriminator''': {'''do_lower_case''': True}, } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = VOCAB_FILES_NAMES A__ = PRETRAINED_VOCAB_FILES_MAP A__ = PRETRAINED_INIT_CONFIGURATION A__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A__ = ElectraTokenizer def __init__( self : int , __a : List[Any]=None , __a : int=None , __a : List[str]=True , __a : Any="[UNK]" , __a : Any="[SEP]" , __a : Union[str, Any]="[PAD]" , __a : Dict="[CLS]" , __a : List[Any]="[MASK]" , __a : str=True , __a : Optional[int]=None , **__a : Optional[int] , ) -> str: '''simple docstring''' super().__init__( __a , tokenizer_file=__a , do_lower_case=__a , unk_token=__a , sep_token=__a , pad_token=__a , cls_token=__a , mask_token=__a , tokenize_chinese_chars=__a , strip_accents=__a , **__a , ) __snake_case : Tuple = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('lowercase' , __a ) != do_lower_case or normalizer_state.get('strip_accents' , __a ) != strip_accents or normalizer_state.get('handle_chinese_chars' , __a ) != tokenize_chinese_chars ): __snake_case : List[Any] = getattr(__a , normalizer_state.pop('type' ) ) __snake_case : str = do_lower_case __snake_case : Optional[int] = strip_accents __snake_case : Any = tokenize_chinese_chars __snake_case : Union[str, Any] = normalizer_class(**__a ) __snake_case : Any = do_lower_case def A_ ( self : Any , __a : List[str] , __a : Optional[Any]=None ) -> Dict: '''simple docstring''' __snake_case : Optional[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 A_ ( self : List[Any] , __a : List[int] , __a : Optional[List[int]] = None ) -> List[int]: '''simple docstring''' __snake_case : int = [self.sep_token_id] __snake_case : 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 ) * [0] + len(token_ids_a + sep ) * [1] def A_ ( self : Optional[int] , __a : str , __a : Optional[str] = None ) -> Tuple[str]: '''simple docstring''' __snake_case : Tuple = self._tokenizer.model.save(__a , name=__a ) return tuple(__a )

'''simple docstring''' import argparse import json import os import torch from transformers import LukeConfig, LukeModel, LukeTokenizer, RobertaTokenizer from transformers.tokenization_utils_base import AddedToken @torch.no_grad() def a_ ( _UpperCAmelCase : int ,_UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : List[str] ,_UpperCAmelCase : Union[str, Any] ,_UpperCAmelCase : List[str] ) -> List[str]: # Load configuration defined in the metadata file with open(_UpperCAmelCase ) as metadata_file: __snake_case : Optional[Any] = json.load(_UpperCAmelCase ) __snake_case : Optional[Any] = LukeConfig(use_entity_aware_attention=_UpperCAmelCase ,**metadata['model_config'] ) # Load in the weights from the checkpoint_path __snake_case : int = torch.load(_UpperCAmelCase ,map_location='cpu' ) # Load the entity vocab file __snake_case : Optional[int] = load_entity_vocab(_UpperCAmelCase ) __snake_case : Tuple = RobertaTokenizer.from_pretrained(metadata['model_config']['bert_model_name'] ) # Add special tokens to the token vocabulary for downstream tasks __snake_case : int = AddedToken('<ent>' ,lstrip=_UpperCAmelCase ,rstrip=_UpperCAmelCase ) __snake_case : str = AddedToken('<ent2>' ,lstrip=_UpperCAmelCase ,rstrip=_UpperCAmelCase ) tokenizer.add_special_tokens({'additional_special_tokens': [entity_token_a, entity_token_a]} ) config.vocab_size += 2 print(f'''Saving tokenizer to {pytorch_dump_folder_path}''' ) tokenizer.save_pretrained(_UpperCAmelCase ) with open(os.path.join(_UpperCAmelCase ,LukeTokenizer.vocab_files_names['entity_vocab_file'] ) ,'w' ) as f: json.dump(_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : Optional[int] = LukeTokenizer.from_pretrained(_UpperCAmelCase ) # Initialize the embeddings of the special tokens __snake_case : Dict = state_dict['embeddings.word_embeddings.weight'] __snake_case : List[str] = word_emb[tokenizer.convert_tokens_to_ids(['@'] )[0]].unsqueeze(0 ) __snake_case : str = word_emb[tokenizer.convert_tokens_to_ids(['#'] )[0]].unsqueeze(0 ) __snake_case : int = torch.cat([word_emb, ent_emb, enta_emb] ) # Initialize the query layers of the entity-aware self-attention mechanism for layer_index in range(config.num_hidden_layers ): for matrix_name in ["query.weight", "query.bias"]: __snake_case : Tuple = f'''encoder.layer.{layer_index}.attention.self.''' __snake_case : Optional[Any] = state_dict[prefix + matrix_name] __snake_case : List[Any] = state_dict[prefix + matrix_name] __snake_case : int = state_dict[prefix + matrix_name] # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks __snake_case : Dict = state_dict['entity_embeddings.entity_embeddings.weight'] __snake_case : List[str] = entity_emb[entity_vocab['[MASK]']] __snake_case : int = LukeModel(config=_UpperCAmelCase ).eval() __snake_case : str = model.load_state_dict(_UpperCAmelCase ,strict=_UpperCAmelCase ) if not (len(_UpperCAmelCase ) == 1 and missing_keys[0] == "embeddings.position_ids"): raise ValueError(f'''Missing keys {", ".join(_UpperCAmelCase )}. Expected only missing embeddings.position_ids''' ) if not (all(key.startswith('entity_predictions' ) or key.startswith('lm_head' ) for key in unexpected_keys )): raise ValueError( 'Unexpected keys' f''' {", ".join([key for key in unexpected_keys if not (key.startswith("entity_predictions" ) or key.startswith("lm_head" ))] )}''' ) # Check outputs __snake_case : Optional[Any] = LukeTokenizer.from_pretrained(_UpperCAmelCase ,task='entity_classification' ) __snake_case : List[Any] = ( 'Top seed Ana Ivanovic said on Thursday she could hardly believe her luck as a fortuitous netcord helped the' ' new world number one avoid a humiliating second- round exit at Wimbledon .' ) __snake_case : str = (39, 42) __snake_case : str = tokenizer(_UpperCAmelCase ,entity_spans=[span] ,add_prefix_space=_UpperCAmelCase ,return_tensors='pt' ) __snake_case : Tuple = model(**_UpperCAmelCase ) # Verify word hidden states if model_size == "large": __snake_case : List[str] = torch.Size((1, 42, 10_24) ) __snake_case : Tuple = torch.tensor( [[0.0_1_3_3, 0.0_8_6_5, 0.0_0_9_5], [0.3_0_9_3, -0.2_5_7_6, -0.7_4_1_8], [-0.1_7_2_0, -0.2_1_1_7, -0.2_8_6_9]] ) else: # base __snake_case : List[str] = torch.Size((1, 42, 7_68) ) __snake_case : Union[str, Any] = torch.tensor([[0.0_0_3_7, 0.1_3_6_8, -0.0_0_9_1], [0.1_0_9_9, 0.3_3_2_9, -0.1_0_9_5], [0.0_7_6_5, 0.5_3_3_5, 0.1_1_7_9]] ) if not (outputs.last_hidden_state.shape == expected_shape): raise ValueError( f'''Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}''' ) if not torch.allclose(outputs.last_hidden_state[0, :3, :3] ,_UpperCAmelCase ,atol=1E-4 ): raise ValueError # Verify entity hidden states if model_size == "large": __snake_case : Any = torch.Size((1, 1, 10_24) ) __snake_case : Optional[int] = torch.tensor([[0.0_4_6_6, -0.0_1_0_6, -0.0_1_7_9]] ) else: # base __snake_case : str = torch.Size((1, 1, 7_68) ) __snake_case : Tuple = torch.tensor([[0.1_4_5_7, 0.1_0_4_4, 0.0_1_7_4]] ) if not (outputs.entity_last_hidden_state.shape != expected_shape): raise ValueError( f'''Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is''' f''' {expected_shape}''' ) if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3] ,_UpperCAmelCase ,atol=1E-4 ): raise ValueError # Finally, save our PyTorch model and tokenizer print('Saving PyTorch model to {}'.format(_UpperCAmelCase ) ) model.save_pretrained(_UpperCAmelCase ) def a_ ( _UpperCAmelCase : List[Any] ) -> Any: __snake_case : List[str] = {} with open(_UpperCAmelCase ,'r' ,encoding='utf-8' ) as f: for index, line in enumerate(_UpperCAmelCase ): __snake_case : List[Any] = line.rstrip().split('\t' ) __snake_case : str = index return entity_vocab if __name__ == "__main__": A__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument('''--checkpoint_path''', type=str, help='''Path to a pytorch_model.bin file.''') parser.add_argument( '''--metadata_path''', default=None, type=str, help='''Path to a metadata.json file, defining the configuration.''' ) parser.add_argument( '''--entity_vocab_path''', default=None, type=str, help='''Path to an entity_vocab.tsv file, containing the entity vocabulary.''', ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to where to dump the output PyTorch model.''' ) parser.add_argument( '''--model_size''', default='''base''', type=str, choices=['''base''', '''large'''], help='''Size of the model to be converted.''' ) A__ : str = parser.parse_args() convert_luke_checkpoint( args.checkpoint_path, args.metadata_path, args.entity_vocab_path, args.pytorch_dump_folder_path, args.model_size, )

'''simple docstring''' def a_ ( _UpperCAmelCase : int ) -> bool: __snake_case : Union[str, Any] = n ** (1 / 3) return (val * val * val) == n if __name__ == "__main__": print(perfect_cube(2_7)) print(perfect_cube(4))

'''simple docstring''' import math def a_ ( _UpperCAmelCase : int ) -> bool: return math.sqrt(_UpperCAmelCase ) * math.sqrt(_UpperCAmelCase ) == num def a_ ( _UpperCAmelCase : int ) -> bool: __snake_case : str = 0 __snake_case : str = n while left <= right: __snake_case : Optional[int] = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: __snake_case : int = mid - 1 else: __snake_case : int = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss A__ : Tuple = pytest.mark.integration @require_faiss class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : Any ) -> Tuple: '''simple docstring''' __snake_case : Dict = Dataset.from_dict({'filename': ['my_name-train' + '_' + str(__a ) for x in np.arange(30 ).tolist()]} ) return dset def A_ ( self : Union[str, Any] ) -> List[Any]: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() __snake_case : Dict = dset.map( lambda __a , __a : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=__a , keep_in_memory=__a ) __snake_case : List[Any] = dset.add_faiss_index('vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) __snake_case , __snake_case : Any = dset.get_nearest_examples('vecs' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) dset.drop_index('vecs' ) def A_ ( self : Tuple ) -> Any: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) __snake_case , __snake_case : Any = dset.get_nearest_examples('vecs' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self : List[Any] ) -> Dict: '''simple docstring''' import faiss __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__a ) as tmp_file: dset.save_faiss_index('vecs' , tmp_file.name ) dset.load_faiss_index('vecs2' , tmp_file.name ) os.unlink(tmp_file.name ) __snake_case , __snake_case : str = dset.get_nearest_examples('vecs2' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) def A_ ( self : Union[str, Any] ) -> Dict: '''simple docstring''' __snake_case : Dataset = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='vecs' ) dset.drop_index('vecs' ) self.assertRaises(__a , partial(dset.get_nearest_examples , 'vecs2' , np.ones(5 , dtype=np.floataa ) ) ) def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' from elasticsearch import Elasticsearch __snake_case : Dataset = self._create_dummy_dataset() with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch( 'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk: __snake_case : Any = {'acknowledged': True} mocked_bulk.return_value([(True, None)] * 30 ) __snake_case : Dict = {'hits': {'hits': [{'_score': 1, '_id': 29}]}} __snake_case : Union[str, Any] = Elasticsearch() dset.add_elasticsearch_index('filename' , es_client=__a ) __snake_case , __snake_case : str = dset.get_nearest_examples('filename' , 'my_name-train_29' ) self.assertEqual(examples['filename'][0] , 'my_name-train_29' ) @require_faiss class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : str ) -> int: '''simple docstring''' import faiss __snake_case : int = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query __snake_case : Dict = np.zeros(5 , dtype=np.floataa ) __snake_case : List[str] = 1 __snake_case , __snake_case : List[Any] = index.search(__a ) self.assertRaises(__a , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries __snake_case : List[str] = np.eye(5 , dtype=np.floataa )[::-1] __snake_case , __snake_case : Dict = index.search_batch(__a ) self.assertRaises(__a , index.search_batch , queries[0] ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : List[Any] = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , __a ) def A_ ( self : int ) -> int: '''simple docstring''' import faiss __snake_case : int = FaissIndex(string_factory='Flat' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) __snake_case : List[str] = FaissIndex(string_factory='LSH' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(__a ): __snake_case : Dict = FaissIndex(string_factory='Flat' , custom_index=faiss.IndexFlat(5 ) ) def A_ ( self : str ) -> Dict: '''simple docstring''' import faiss __snake_case : Tuple = faiss.IndexFlat(5 ) __snake_case : List[Any] = FaissIndex(custom_index=__a ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def A_ ( self : List[Any] ) -> int: '''simple docstring''' import faiss __snake_case : Optional[Any] = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=__a ) as tmp_file: index.save(tmp_file.name ) __snake_case : List[Any] = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) __snake_case : List[Any] = np.zeros(5 , dtype=np.floataa ) __snake_case : Any = 1 __snake_case , __snake_case : int = index.search(__a ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def a_ ( _UpperCAmelCase : str ) -> Optional[int]: import faiss __snake_case : int = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 ,dtype=np.floataa ) ) __snake_case : Dict = 'index.faiss' __snake_case : Any = f'''mock://{index_name}''' index.save(_UpperCAmelCase ,storage_options=mockfs.storage_options ) __snake_case : Any = FaissIndex.load(_UpperCAmelCase ,storage_options=mockfs.storage_options ) __snake_case : Any = np.zeros(5 ,dtype=np.floataa ) __snake_case : Any = 1 __snake_case , __snake_case : Tuple = index.search(_UpperCAmelCase ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class snake_case__ ( SCREAMING_SNAKE_CASE_ ): def A_ ( self : List[str] ) -> List[str]: '''simple docstring''' from elasticsearch import Elasticsearch with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch( 'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk: __snake_case : int = Elasticsearch() __snake_case : Dict = {'acknowledged': True} __snake_case : List[Any] = ElasticSearchIndex(es_client=__a ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(['foo', 'bar', 'foobar'] ) # single query __snake_case : Optional[Any] = 'foo' __snake_case : int = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} __snake_case , __snake_case : List[Any] = index.search(__a ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout __snake_case : Dict = 'foo' __snake_case : Dict = {'hits': {'hits': [{'_score': 1, '_id': 0}]}} __snake_case , __snake_case : Optional[Any] = index.search(__a , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries __snake_case : List[Any] = ['foo', 'bar', 'foobar'] __snake_case : str = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} __snake_case , __snake_case : Any = index.search_batch(__a ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : Tuple = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([1, 1, 1] , __a ) # batched queries with timeout __snake_case : Tuple = ['foo', 'bar', 'foobar'] __snake_case : List[Any] = {'hits': {'hits': [{'_score': 1, '_id': 1}]}} __snake_case , __snake_case : int = index.search_batch(__a , request_timeout=30 ) __snake_case : Any = [scores[0] for scores in total_scores] __snake_case : Dict = [indices[0] for indices in total_indices] self.assertGreater(np.min(__a ) , 0 ) self.assertListEqual([1, 1, 1] , __a )

'''simple docstring''' import argparse import numpy as np import torch from transformers import SpeechTaHifiGan, SpeechTaHifiGanConfig, logging logging.set_verbosity_info() A__ : Dict = logging.get_logger('''transformers.models.speecht5''') def a_ ( _UpperCAmelCase : Optional[int] ,_UpperCAmelCase : Optional[int] ,_UpperCAmelCase : List[str] ) -> int: hf_model.apply_weight_norm() __snake_case : List[Any] = checkpoint['input_conv.weight_g'] __snake_case : Optional[int] = checkpoint['input_conv.weight_v'] __snake_case : int = checkpoint['input_conv.bias'] for i in range(len(config.upsample_rates ) ): __snake_case : List[Any] = checkpoint[f'''upsamples.{i}.1.weight_g'''] __snake_case : List[str] = checkpoint[f'''upsamples.{i}.1.weight_v'''] __snake_case : Any = checkpoint[f'''upsamples.{i}.1.bias'''] for i in range(len(config.upsample_rates ) * len(config.resblock_kernel_sizes ) ): for j in range(len(config.resblock_dilation_sizes ) ): __snake_case : Any = checkpoint[f'''blocks.{i}.convs1.{j}.1.weight_g'''] __snake_case : Dict = checkpoint[f'''blocks.{i}.convs1.{j}.1.weight_v'''] __snake_case : Dict = checkpoint[f'''blocks.{i}.convs1.{j}.1.bias'''] __snake_case : Optional[int] = checkpoint[f'''blocks.{i}.convs2.{j}.1.weight_g'''] __snake_case : Any = checkpoint[f'''blocks.{i}.convs2.{j}.1.weight_v'''] __snake_case : Optional[int] = checkpoint[f'''blocks.{i}.convs2.{j}.1.bias'''] __snake_case : List[Any] = checkpoint['output_conv.1.weight_g'] __snake_case : Any = checkpoint['output_conv.1.weight_v'] __snake_case : List[Any] = checkpoint['output_conv.1.bias'] hf_model.remove_weight_norm() @torch.no_grad() def a_ ( _UpperCAmelCase : Optional[Any] ,_UpperCAmelCase : List[Any] ,_UpperCAmelCase : Dict ,_UpperCAmelCase : Optional[int]=None ,_UpperCAmelCase : Dict=None ,) -> Dict: if config_path is not None: __snake_case : Tuple = SpeechTaHifiGanConfig.from_pretrained(_UpperCAmelCase ) else: __snake_case : Union[str, Any] = SpeechTaHifiGanConfig() __snake_case : Optional[Any] = SpeechTaHifiGan(_UpperCAmelCase ) __snake_case : Dict = torch.load(_UpperCAmelCase ) load_weights(orig_checkpoint['model']['generator'] ,_UpperCAmelCase ,_UpperCAmelCase ) __snake_case : List[Any] = np.load(_UpperCAmelCase ) __snake_case : Optional[int] = stats[0].reshape(-1 ) __snake_case : Dict = stats[1].reshape(-1 ) __snake_case : str = torch.from_numpy(_UpperCAmelCase ).float() __snake_case : str = torch.from_numpy(_UpperCAmelCase ).float() model.save_pretrained(_UpperCAmelCase ) if repo_id: print('Pushing to the hub...' ) model.push_to_hub(_UpperCAmelCase ) if __name__ == "__main__": A__ : Optional[Any] = argparse.ArgumentParser() parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to original checkpoint''') parser.add_argument('''--stats_path''', required=True, default=None, type=str, help='''Path to stats.npy file''') parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''') parser.add_argument( '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.''' ) parser.add_argument( '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.''' ) A__ : Optional[int] = parser.parse_args() convert_hifigan_checkpoint( args.checkpoint_path, args.stats_path, args.pytorch_dump_folder_path, args.config_path, args.push_to_hub, )

'''simple docstring''' from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxSeqaSeqConfigWithPast from ...utils import logging A__ : List[Any] = logging.get_logger(__name__) A__ : Tuple = { '''t5-small''': '''https://huggingface.co/t5-small/resolve/main/config.json''', '''t5-base''': '''https://huggingface.co/t5-base/resolve/main/config.json''', '''t5-large''': '''https://huggingface.co/t5-large/resolve/main/config.json''', '''t5-3b''': '''https://huggingface.co/t5-3b/resolve/main/config.json''', '''t5-11b''': '''https://huggingface.co/t5-11b/resolve/main/config.json''', } class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''t5''' A__ = ['''past_key_values'''] A__ = {'''hidden_size''': '''d_model''', '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers'''} def __init__( self : str , __a : Dict=32128 , __a : Dict=512 , __a : Union[str, Any]=64 , __a : str=2048 , __a : Union[str, Any]=6 , __a : Any=None , __a : Any=8 , __a : List[Any]=32 , __a : Any=128 , __a : Tuple=0.1 , __a : str=1e-6 , __a : Dict=1.0 , __a : Tuple="relu" , __a : Dict=True , __a : Union[str, Any]=True , __a : Any=0 , __a : Dict=1 , **__a : Union[str, Any] , ) -> Union[str, Any]: '''simple docstring''' __snake_case : int = vocab_size __snake_case : str = d_model __snake_case : str = d_kv __snake_case : List[Any] = d_ff __snake_case : List[str] = num_layers __snake_case : Tuple = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry __snake_case : Union[str, Any] = num_heads __snake_case : Tuple = relative_attention_num_buckets __snake_case : Optional[int] = relative_attention_max_distance __snake_case : Optional[Any] = dropout_rate __snake_case : str = layer_norm_epsilon __snake_case : List[str] = initializer_factor __snake_case : int = feed_forward_proj __snake_case : Optional[Any] = use_cache __snake_case : Optional[Any] = self.feed_forward_proj.split('-' ) __snake_case : Dict = act_info[-1] __snake_case : List[str] = act_info[0] == 'gated' if len(__a ) > 1 and act_info[0] != "gated" or len(__a ) > 2: raise ValueError( f'''`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.''' 'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. ' '\'gated-gelu\' or \'relu\'' ) # for backwards compatibility if feed_forward_proj == "gated-gelu": __snake_case : Dict = 'gelu_new' super().__init__( pad_token_id=__a , eos_token_id=__a , is_encoder_decoder=__a , **__a , ) class snake_case__ ( SCREAMING_SNAKE_CASE_ ): @property def A_ ( self : str ) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' __snake_case : Union[str, Any] = { 'input_ids': {0: 'batch', 1: 'encoder_sequence'}, 'attention_mask': {0: 'batch', 1: 'encoder_sequence'}, } if self.use_past: __snake_case : Tuple = 'past_encoder_sequence + sequence' __snake_case : Dict = {0: 'batch'} __snake_case : Dict = {0: 'batch', 1: 'past_decoder_sequence + sequence'} else: __snake_case : Tuple = {0: 'batch', 1: 'decoder_sequence'} __snake_case : int = {0: 'batch', 1: 'decoder_sequence'} if self.use_past: self.fill_with_past_key_values_(__a , direction='inputs' ) return common_inputs @property def A_ ( self : List[Any] ) -> int: '''simple docstring''' return 13

'''simple docstring''' import functools from typing import Any def a_ ( _UpperCAmelCase : str ,_UpperCAmelCase : list[str] ) -> bool: # Validation if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ) or len(_UpperCAmelCase ) == 0: raise ValueError('the string should be not empty string' ) if not isinstance(_UpperCAmelCase ,_UpperCAmelCase ) or not all( isinstance(_UpperCAmelCase ,_UpperCAmelCase ) and len(_UpperCAmelCase ) > 0 for item in words ): raise ValueError('the words should be a list of non-empty strings' ) # Build trie __snake_case : dict[str, Any] = {} __snake_case : Any = 'WORD_KEEPER' for word in words: __snake_case : Optional[Any] = trie for c in word: if c not in trie_node: __snake_case : int = {} __snake_case : Any = trie_node[c] __snake_case : str = True __snake_case : Optional[int] = len(_UpperCAmelCase ) # Dynamic programming method @functools.cache def is_breakable(_UpperCAmelCase : int ) -> bool: if index == len_string: return True __snake_case : List[str] = trie for i in range(_UpperCAmelCase ,_UpperCAmelCase ): __snake_case : List[str] = trie_node.get(string[i] ,_UpperCAmelCase ) if trie_node is None: return False if trie_node.get(_UpperCAmelCase ,_UpperCAmelCase ) and is_breakable(i + 1 ): return True return False return is_breakable(0 ) if __name__ == "__main__": import doctest doctest.testmod()

'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging A__ : Tuple = logging.get_logger(__name__) A__ : Optional[int] = {} class snake_case__ ( SCREAMING_SNAKE_CASE_ ): A__ = '''llama''' A__ = ['''past_key_values'''] def __init__( self : Any , __a : List[str]=32000 , __a : Union[str, Any]=4096 , __a : Optional[Any]=11008 , __a : Any=32 , __a : str=32 , __a : Optional[int]=None , __a : Dict="silu" , __a : Dict=2048 , __a : List[str]=0.0_2 , __a : Union[str, Any]=1e-6 , __a : Dict=True , __a : List[str]=0 , __a : Tuple=1 , __a : Tuple=2 , __a : Optional[Any]=1 , __a : Any=False , __a : Tuple=None , **__a : List[Any] , ) -> Optional[int]: '''simple docstring''' __snake_case : str = vocab_size __snake_case : List[str] = max_position_embeddings __snake_case : List[Any] = hidden_size __snake_case : Union[str, Any] = intermediate_size __snake_case : Optional[int] = num_hidden_layers __snake_case : List[Any] = num_attention_heads # for backward compatibility if num_key_value_heads is None: __snake_case : Optional[int] = num_attention_heads __snake_case : Optional[Any] = num_key_value_heads __snake_case : int = hidden_act __snake_case : Any = initializer_range __snake_case : Any = rms_norm_eps __snake_case : Union[str, Any] = pretraining_tp __snake_case : Optional[int] = use_cache __snake_case : Any = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=__a , bos_token_id=__a , eos_token_id=__a , tie_word_embeddings=__a , **__a , ) def A_ ( self : Optional[Any] ) -> Optional[Any]: '''simple docstring''' if self.rope_scaling is None: return if not isinstance(self.rope_scaling , __a ) or len(self.rope_scaling ) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' f'''got {self.rope_scaling}''' ) __snake_case : Optional[Any] = self.rope_scaling.get('type' , __a ) __snake_case : Tuple = self.rope_scaling.get('factor' , __a ) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( f'''`rope_scaling`\'s name field must be one of [\'linear\', \'dynamic\'], got {rope_scaling_type}''' ) if rope_scaling_factor is None or not isinstance(__a , __a ) or rope_scaling_factor <= 1.0: raise ValueError(f'''`rope_scaling`\'s factor field must be an float > 1, got {rope_scaling_factor}''' )

"""simple docstring""" import itertools from dataclasses import dataclass from typing import Optional import pandas as pd import pyarrow as pa import datasets from datasets.table import table_cast @dataclass class _SCREAMING_SNAKE_CASE ( datasets.BuilderConfig ): UpperCAmelCase_ :Optional[datasets.Features] = None class _SCREAMING_SNAKE_CASE ( datasets.ArrowBasedBuilder ): UpperCAmelCase_ :int = PandasConfig def __lowerCAmelCase ( self ) -> Any: return datasets.DatasetInfo(features=self.config.features ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: if not self.config.data_files: raise ValueError(f"""At least one data file must be specified, but got data_files={self.config.data_files}""" ) lowerCAmelCase_ :Any = dl_manager.download_and_extract(self.config.data_files ) if isinstance(__A , (str, list, tuple) ): lowerCAmelCase_ :Any = data_files if isinstance(__A , __A ): lowerCAmelCase_ :List[Any] = [files] # Use `dl_manager.iter_files` to skip hidden files in an extracted archive lowerCAmelCase_ :Optional[Any] = [dl_manager.iter_files(__A ) for file in files] return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={"""files""": files} )] lowerCAmelCase_ :int = [] for split_name, files in data_files.items(): if isinstance(__A , __A ): lowerCAmelCase_ :str = [files] # Use `dl_manager.iter_files` to skip hidden files in an extracted archive lowerCAmelCase_ :List[str] = [dl_manager.iter_files(__A ) for file in files] splits.append(datasets.SplitGenerator(name=__A , gen_kwargs={"""files""": files} ) ) return splits def __lowerCAmelCase ( self , __A ) -> pa.Table: if self.config.features is not None: # more expensive cast to support nested features with keys in a different order # allows str <-> int/float or str to Audio for example lowerCAmelCase_ :int = table_cast(__A , self.config.features.arrow_schema ) return pa_table def __lowerCAmelCase ( self , __A ) -> Optional[int]: for i, file in enumerate(itertools.chain.from_iterable(__A ) ): with open(__A , """rb""" ) as f: lowerCAmelCase_ :List[Any] = pa.Table.from_pandas(pd.read_pickle(__A ) ) yield i, self._cast_table(__A )

"""simple docstring""" import argparse import json import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 , lowercase__ : str = "bert-base-cased" ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained(lowercase__ ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : List[str] ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :str = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset lowerCAmelCase_ :str = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , load_from_cache_file=lowercase__ ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :List[str] = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Union[str, Any] ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(lowercase__ , padding="""max_length""" , max_length=1_2_8 , return_tensors="""pt""" ) return tokenizer.pad(lowercase__ , padding="""longest""" , return_tensors="""pt""" ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[int] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :Any = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : Union[str, Any] , lowercase__ : Tuple , lowercase__ : int ) -> List[str]: '''simple docstring''' model.eval() lowerCAmelCase_ :Dict = 0 for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) # It is slightly faster to call this once, than multiple times lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.gather( (predictions, batch["""labels"""]) ) # If we are in a multiprocess environment, the last batch has duplicates if accelerator.use_distributed: if step == len(lowercase__ ) - 1: lowerCAmelCase_ :Optional[Any] = predictions[: len(eval_dataloader.dataset ) - samples_seen] lowerCAmelCase_ :Any = references[: len(eval_dataloader.dataset ) - samples_seen] else: samples_seen += references.shape[0] metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Tuple = metric.compute() return eval_metric["accuracy"] def _snake_case ( lowercase__ : str , lowercase__ : List[str] ) -> Any: '''simple docstring''' lowerCAmelCase_ :Optional[int] = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :Optional[int] = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Optional[Any] = args.model_name_or_path set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Dict = get_dataloaders(lowercase__ , lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :str = AutoModelForSequenceClassification.from_pretrained(lowercase__ , return_dict=lowercase__ ) # Instantiate optimizer lowerCAmelCase_ :List[str] = ( AdamW if accelerator.state.deepspeed_plugin is None or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) lowerCAmelCase_ :str = optimizer_cls(params=model.parameters() , lr=lowercase__ ) if accelerator.state.deepspeed_plugin is not None: lowerCAmelCase_ :Union[str, Any] = accelerator.state.deepspeed_plugin.deepspeed_config[ """gradient_accumulation_steps""" ] else: lowerCAmelCase_ :Any = 1 lowerCAmelCase_ :str = (len(lowercase__ ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): lowerCAmelCase_ :List[str] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=0 , num_training_steps=lowercase__ , ) else: lowerCAmelCase_ :int = DummyScheduler(lowercase__ , total_num_steps=lowercase__ , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # We need to keep track of how many total steps we have iterated over lowerCAmelCase_ :List[str] = 0 # We also need to keep track of the stating epoch so files are named properly lowerCAmelCase_ :List[Any] = 0 lowerCAmelCase_ :str = evaluate.load("""glue""" , """mrpc""" ) lowerCAmelCase_ :Optional[Any] = num_epochs if args.partial_train_epoch is not None: lowerCAmelCase_ :Dict = args.partial_train_epoch if args.resume_from_checkpoint: accelerator.load_state(args.resume_from_checkpoint ) lowerCAmelCase_ :Optional[Any] = args.resume_from_checkpoint.split("""epoch_""" )[1] lowerCAmelCase_ :int = """""" for char in epoch_string: if char.isdigit(): state_epoch_num += char else: break lowerCAmelCase_ :Union[str, Any] = int(lowercase__ ) + 1 lowerCAmelCase_ :Optional[int] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) accelerator.print("""resumed checkpoint performance:""" , lowercase__ ) accelerator.print("""resumed checkpoint's scheduler's lr:""" , lr_scheduler.get_lr()[0] ) accelerator.print("""resumed optimizers's lr:""" , optimizer.param_groups[0]["""lr"""] ) with open(os.path.join(args.output_dir , f"""state_{starting_epoch-1}.json""" ) , """r""" ) as f: lowerCAmelCase_ :List[str] = json.load(lowercase__ ) assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed" assert ( resumed_state["lr"] == lr_scheduler.get_lr()[0] ), "Scheduler learning rate mismatch, loading from checkpoint failed" assert ( resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"] ), "Optimizer learning rate mismatch, loading from checkpoint failed" assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed" return # Now we train the model lowerCAmelCase_ :List[Any] = {} for epoch in range(lowercase__ , lowercase__ ): model.train() for step, batch in enumerate(lowercase__ ): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Dict = outputs.loss lowerCAmelCase_ :int = loss / gradient_accumulation_steps accelerator.backward(lowercase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 lowerCAmelCase_ :List[str] = f"""epoch_{epoch}""" lowerCAmelCase_ :Any = os.path.join(args.output_dir , lowercase__ ) accelerator.save_state(lowercase__ ) lowerCAmelCase_ :List[Any] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) lowerCAmelCase_ :Union[str, Any] = accuracy lowerCAmelCase_ :Any = lr_scheduler.get_lr()[0] lowerCAmelCase_ :str = optimizer.param_groups[0]["""lr"""] lowerCAmelCase_ :List[Any] = epoch lowerCAmelCase_ :Tuple = overall_step accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , f"""state_{epoch}.json""" ) , """w""" ) as f: json.dump(lowercase__ , lowercase__ ) def _snake_case ( ) -> int: '''simple docstring''' lowerCAmelCase_ :List[Any] = argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage.""" ) parser.add_argument( """--model_name_or_path""" , type=lowercase__ , default="""bert-base-cased""" , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=lowercase__ , ) parser.add_argument( """--output_dir""" , type=lowercase__ , default=""".""" , help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory.""" , ) parser.add_argument( """--resume_from_checkpoint""" , type=lowercase__ , default=lowercase__ , help="""If the training should continue from a checkpoint folder.""" , ) parser.add_argument( """--partial_train_epoch""" , type=lowercase__ , default=lowercase__ , help="""If passed, the training will stop after this number of epochs.""" , ) parser.add_argument( """--num_epochs""" , type=lowercase__ , default=2 , help="""Number of train epochs.""" , ) lowerCAmelCase_ :Optional[int] = parser.parse_args() lowerCAmelCase_ :List[Any] = {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case ( lowercase__ : List[str] , lowercase__ : Any , lowercase__ : int ) -> List[Any]: '''simple docstring''' lowerCAmelCase_ :Optional[int] = AlbertConfig.from_json_file(lowercase__ ) print(f"""Building PyTorch model from configuration: {config}""" ) lowerCAmelCase_ :str = AlbertForPreTraining(lowercase__ ) # Load weights from tf checkpoint load_tf_weights_in_albert(lowercase__ , lowercase__ , lowercase__ ) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , lowercase__ ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.' ) parser.add_argument( '--albert_config_file', default=None, type=str, required=True, help=( 'The config json file corresponding to the pre-trained ALBERT model. \n' 'This specifies the model architecture.' ), ) parser.add_argument( '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.' ) __UpperCAmelCase = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)

"""simple docstring""" import baseaa import io import json import os from copy import deepcopy from ..optimizer import AcceleratedOptimizer from ..scheduler import AcceleratedScheduler class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Union[str, Any]: if isinstance(__A , __A ): # Don't modify user's data should they want to reuse it (e.g. in tests), because once we # modified it, it will not be accepted here again, since `auto` values would have been overridden lowerCAmelCase_ :Tuple = deepcopy(__A ) elif os.path.exists(__A ): with io.open(__A , """r""" , encoding="""utf-8""" ) as f: lowerCAmelCase_ :str = json.load(__A ) else: try: lowerCAmelCase_ :Dict = baseaa.urlsafe_baadecode(__A ).decode("""utf-8""" ) lowerCAmelCase_ :int = json.loads(__A ) except (UnicodeDecodeError, AttributeError, ValueError): raise ValueError( f"""Expected a string path to an existing deepspeed config, or a dictionary, or a base64 encoded string. Received: {config_file_or_dict}""" ) lowerCAmelCase_ :Optional[Any] = config self.set_stage_and_offload() def __lowerCAmelCase ( self ) -> Tuple: # zero stage - this is done as early as possible, before model is created, to allow # ``is_deepspeed_zero3_enabled`` query and getting to the early deepspeed config object # during ``zero.Init()`` which needs to know the dtype, and some other hparams. lowerCAmelCase_ :Tuple = self.get_value("""zero_optimization.stage""" , -1 ) # offload lowerCAmelCase_ :Dict = False if self.is_zeroa() or self.is_zeroa(): lowerCAmelCase_ :Optional[int] = set(["""cpu""", """nvme"""] ) lowerCAmelCase_ :Union[str, Any] = set( [ self.get_value("""zero_optimization.offload_optimizer.device""" ), self.get_value("""zero_optimization.offload_param.device""" ), ] ) if len(offload_devices & offload_devices_valid ) > 0: lowerCAmelCase_ :Optional[int] = True def __lowerCAmelCase ( self , __A ) -> Optional[Any]: lowerCAmelCase_ :str = self.config # find the config node of interest if it exists lowerCAmelCase_ :Tuple = ds_key_long.split(""".""" ) lowerCAmelCase_ :List[str] = nodes.pop() for node in nodes: lowerCAmelCase_ :Tuple = config.get(__A ) if config is None: return None, ds_key return config, ds_key def __lowerCAmelCase ( self , __A , __A=None ) -> Optional[Any]: lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.find_config_node(__A ) if config is None: return default return config.get(__A , __A ) def __lowerCAmelCase ( self , __A , __A=False ) -> Optional[Any]: lowerCAmelCase_ :Tuple = self.config # find the config node of interest if it exists lowerCAmelCase_ :Union[str, Any] = ds_key_long.split(""".""" ) for node in nodes: lowerCAmelCase_ :int = config lowerCAmelCase_ :Any = config.get(__A ) if config is None: if must_exist: raise ValueError(f"""Can't find {ds_key_long} entry in the config: {self.config}""" ) else: return # if found remove it if parent_config is not None: parent_config.pop(__A ) def __lowerCAmelCase ( self , __A ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = self.get_value(__A ) return False if value is None else bool(__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: lowerCAmelCase_ :List[str] = self.get_value(__A ) return False if value is None else not bool(__A ) def __lowerCAmelCase ( self ) -> str: return self._stage == 2 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._stage == 3 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._offload class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Optional[int]: lowerCAmelCase_ :Dict = engine def __lowerCAmelCase ( self , __A , **__A ) -> str: # runs backpropagation and handles mixed precision self.engine.backward(__A , **__A ) # Deepspeed's `engine.step` performs the following operations: # - gradient accumulation check # - gradient clipping # - optimizer step # - zero grad # - checking overflow # - lr_scheduler step (only if engine.lr_scheduler is not None) self.engine.step() # and this plugin overrides the above calls with no-ops when Accelerate runs under # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabling a simple # training loop that works transparently under many training regimes. class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A ) -> List[str]: super().__init__(__A , device_placement=__A , scaler=__A ) lowerCAmelCase_ :List[str] = hasattr(self.optimizer , """overflow""" ) def __lowerCAmelCase ( self , __A=None ) -> Optional[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed def __lowerCAmelCase ( self ) -> List[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed @property def __lowerCAmelCase ( self ) -> int: if self.__has_overflow__: return self.optimizer.overflow return False class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A , __A ) -> Optional[int]: super().__init__(__A , __A ) def __lowerCAmelCase ( self ) -> Any: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=0.0_0_1 , __A=0 , **__A ) -> List[Any]: lowerCAmelCase_ :str = params lowerCAmelCase_ :Any = lr lowerCAmelCase_ :List[Any] = weight_decay lowerCAmelCase_ :Any = kwargs class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=None , __A=0 , **__A ) -> List[str]: lowerCAmelCase_ :Optional[int] = optimizer lowerCAmelCase_ :int = total_num_steps lowerCAmelCase_ :List[Any] = warmup_num_steps lowerCAmelCase_ :int = kwargs

"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0_0_0_0_0_0_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :Optional[Any] = set() lowerCAmelCase_ :Union[str, Any] = int((limit - 2_4) ** (1 / 2) ) lowerCAmelCase_ :Any = set(range(3 , prime_square_limit + 1 , 2 ) ) primes.add(2 ) for p in range(3 , prime_square_limit + 1 , 2 ): if p not in primes: continue primes.difference_update(set(range(p * p , prime_square_limit + 1 , lowercase__ ) ) ) for primea in primes: lowerCAmelCase_ :int = primea * primea for primea in primes: lowerCAmelCase_ :Any = primea * primea * primea if square + cube >= limit - 1_6: break for primea in primes: lowerCAmelCase_ :Optional[Any] = primea * primea * primea * primea lowerCAmelCase_ :Tuple = square + cube + tetr if total >= limit: break ret.add(lowercase__ ) return len(lowercase__ ) if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import numpy as np import torch from ..models.clipseg import CLIPSegForImageSegmentation from ..utils import is_vision_available, requires_backends from .base import PipelineTool if is_vision_available(): from PIL import Image class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Dict = ( "This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image." "It takes two arguments named `image` which should be the original image, and `label` which should be a text " "describing the elements what should be identified in the segmentation mask. The tool returns the mask." ) UpperCAmelCase_ :List[str] = "CIDAS/clipseg-rd64-refined" UpperCAmelCase_ :List[Any] = "image_segmenter" UpperCAmelCase_ :Optional[int] = CLIPSegForImageSegmentation UpperCAmelCase_ :Tuple = ["image", "text"] UpperCAmelCase_ :Dict = ["image"] def __init__( self , *__A , **__A ) -> Optional[Any]: requires_backends(self , ["""vision"""] ) super().__init__(*__A , **__A ) def __lowerCAmelCase ( self , __A , __A ) -> Any: return self.pre_processor(text=[label] , images=[image] , padding=__A , return_tensors="""pt""" ) def __lowerCAmelCase ( self , __A ) -> Tuple: with torch.no_grad(): lowerCAmelCase_ :Dict = self.model(**__A ).logits return logits def __lowerCAmelCase ( self , __A ) -> Tuple: lowerCAmelCase_ :Optional[int] = outputs.cpu().detach().numpy() lowerCAmelCase_ :List[str] = 0 lowerCAmelCase_ :str = 1 return Image.fromarray((array * 255).astype(np.uinta ) )

"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'google/bigbird-roberta-base': 'https://huggingface.co/google/bigbird-roberta-base/resolve/main/config.json', 'google/bigbird-roberta-large': 'https://huggingface.co/google/bigbird-roberta-large/resolve/main/config.json', 'google/bigbird-base-trivia-itc': 'https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/config.json', # See all BigBird models at https://huggingface.co/models?filter=big_bird } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Optional[Any] = "big_bird" def __init__( self , __A=5_0358 , __A=768 , __A=12 , __A=12 , __A=3072 , __A="gelu_new" , __A=0.1 , __A=0.1 , __A=4096 , __A=2 , __A=0.0_2 , __A=1E-12 , __A=True , __A=0 , __A=1 , __A=2 , __A=66 , __A="block_sparse" , __A=True , __A=False , __A=64 , __A=3 , __A=None , **__A , ) -> Optional[Any]: super().__init__( pad_token_id=__A , bos_token_id=__A , eos_token_id=__A , sep_token_id=__A , **__A , ) lowerCAmelCase_ :Tuple = vocab_size lowerCAmelCase_ :List[Any] = max_position_embeddings lowerCAmelCase_ :Union[str, Any] = hidden_size lowerCAmelCase_ :List[Any] = num_hidden_layers lowerCAmelCase_ :str = num_attention_heads lowerCAmelCase_ :Tuple = intermediate_size lowerCAmelCase_ :Tuple = hidden_act lowerCAmelCase_ :Any = hidden_dropout_prob lowerCAmelCase_ :Tuple = attention_probs_dropout_prob lowerCAmelCase_ :List[str] = initializer_range lowerCAmelCase_ :Dict = type_vocab_size lowerCAmelCase_ :List[str] = layer_norm_eps lowerCAmelCase_ :Optional[int] = use_cache lowerCAmelCase_ :List[Any] = rescale_embeddings lowerCAmelCase_ :Dict = attention_type lowerCAmelCase_ :Tuple = use_bias lowerCAmelCase_ :Optional[int] = block_size lowerCAmelCase_ :Dict = num_random_blocks lowerCAmelCase_ :Dict = classifier_dropout class _SCREAMING_SNAKE_CASE ( A__ ): @property def __lowerCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: if self.task == "multiple-choice": lowerCAmelCase_ :Dict = {0: """batch""", 1: """choice""", 2: """sequence"""} else: lowerCAmelCase_ :Dict = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ] )

"""simple docstring""" def _snake_case ( lowercase__ : list , lowercase__ : list , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> int: '''simple docstring''' if index == number_of_items: return 0 lowerCAmelCase_ :Any = 0 lowerCAmelCase_ :str = 0 lowerCAmelCase_ :Dict = knapsack(lowercase__ , lowercase__ , lowercase__ , lowercase__ , index + 1 ) if weights[index] <= max_weight: lowerCAmelCase_ :str = values[index] + knapsack( lowercase__ , lowercase__ , lowercase__ , max_weight - weights[index] , index + 1 ) return max(lowercase__ , lowercase__ ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __UpperCAmelCase = { 'configuration_pegasus_x': ['PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PegasusXConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST', 'PegasusXForConditionalGeneration', 'PegasusXModel', 'PegasusXPreTrainedModel', ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

"""simple docstring""" from .imports import is_tqdm_available if is_tqdm_available(): from tqdm.auto import tqdm as _tqdm from ..state import PartialState def _snake_case ( lowercase__ : bool = True , *lowercase__ : Optional[int] , **lowercase__ : str ) -> Optional[Any]: '''simple docstring''' if not is_tqdm_available(): raise ImportError("""Accelerate's `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`.""" ) lowerCAmelCase_ :Tuple = False if main_process_only: lowerCAmelCase_ :Dict = PartialState().local_process_index == 0 return _tqdm(*lowercase__ , **lowercase__ , disable=lowercase__ )

"""simple docstring""" import gc import unittest from transformers import CTRLConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( CTRL_PRETRAINED_MODEL_ARCHIVE_LIST, CTRLForSequenceClassification, CTRLLMHeadModel, CTRLModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=14 , __A=7 , __A=True , __A=True , __A=True , __A=True , __A=True , __A=99 , __A=32 , __A=5 , __A=4 , __A=37 , __A="gelu" , __A=0.1 , __A=0.1 , __A=512 , __A=16 , __A=2 , __A=0.0_2 , __A=3 , __A=4 , __A=None , ) -> Optional[Any]: lowerCAmelCase_ :Any = parent lowerCAmelCase_ :List[Any] = batch_size lowerCAmelCase_ :Union[str, Any] = seq_length lowerCAmelCase_ :Optional[Any] = is_training lowerCAmelCase_ :Optional[Any] = use_token_type_ids lowerCAmelCase_ :List[Any] = use_input_mask lowerCAmelCase_ :List[Any] = use_labels lowerCAmelCase_ :Optional[Any] = use_mc_token_ids lowerCAmelCase_ :Union[str, Any] = vocab_size lowerCAmelCase_ :Any = hidden_size lowerCAmelCase_ :List[Any] = num_hidden_layers lowerCAmelCase_ :Optional[Any] = num_attention_heads lowerCAmelCase_ :Optional[int] = intermediate_size lowerCAmelCase_ :List[Any] = hidden_act lowerCAmelCase_ :Any = hidden_dropout_prob lowerCAmelCase_ :List[str] = attention_probs_dropout_prob lowerCAmelCase_ :str = max_position_embeddings lowerCAmelCase_ :List[Any] = type_vocab_size lowerCAmelCase_ :Tuple = type_sequence_label_size lowerCAmelCase_ :str = initializer_range lowerCAmelCase_ :List[Any] = num_labels lowerCAmelCase_ :Dict = num_choices lowerCAmelCase_ :List[Any] = scope lowerCAmelCase_ :Union[str, Any] = self.vocab_size - 1 def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCAmelCase_ :int = None if self.use_input_mask: lowerCAmelCase_ :List[str] = random_attention_mask([self.batch_size, self.seq_length] ) lowerCAmelCase_ :Union[str, Any] = None if self.use_token_type_ids: lowerCAmelCase_ :int = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCAmelCase_ :str = None if self.use_mc_token_ids: lowerCAmelCase_ :Dict = ids_tensor([self.batch_size, self.num_choices] , self.seq_length ) lowerCAmelCase_ :Optional[Any] = None lowerCAmelCase_ :Dict = None lowerCAmelCase_ :Optional[Any] = None if self.use_labels: lowerCAmelCase_ :str = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCAmelCase_ :Any = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCAmelCase_ :int = ids_tensor([self.batch_size] , self.num_choices ) lowerCAmelCase_ :Union[str, Any] = self.get_config() lowerCAmelCase_ :Dict = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, input_mask, head_mask, token_type_ids, mc_token_ids, sequence_labels, token_labels, choice_labels, ) def __lowerCAmelCase ( self ) -> Union[str, Any]: return CTRLConfig( vocab_size=self.vocab_size , n_embd=self.hidden_size , n_layer=self.num_hidden_layers , n_head=self.num_attention_heads , n_positions=self.max_position_embeddings , pad_token_id=self.pad_token_id , ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , *__A ) -> List[Any]: lowerCAmelCase_ :int = CTRLModel(config=__A ) model.to(__A ) model.eval() model(__A , token_type_ids=__A , head_mask=__A ) model(__A , token_type_ids=__A ) lowerCAmelCase_ :Dict = model(__A ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(len(result.past_key_values ) , config.n_layer ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , *__A ) -> Optional[int]: lowerCAmelCase_ :Dict = CTRLLMHeadModel(__A ) model.to(__A ) model.eval() lowerCAmelCase_ :Optional[int] = model(__A , token_type_ids=__A , labels=__A ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :str = self.prepare_config_and_inputs() ( ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ) :Optional[Any] = config_and_inputs lowerCAmelCase_ :Any = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """head_mask""": head_mask} return config, inputs_dict def __lowerCAmelCase ( self , __A , __A , __A , __A , *__A ) -> Optional[int]: lowerCAmelCase_ :Optional[Any] = self.num_labels lowerCAmelCase_ :Optional[int] = CTRLForSequenceClassification(__A ) model.to(__A ) model.eval() lowerCAmelCase_ :Optional[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCAmelCase_ :str = model(__A , token_type_ids=__A , labels=__A ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) @require_torch class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :Optional[int] = (CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else () UpperCAmelCase_ :Optional[Any] = (CTRLLMHeadModel,) if is_torch_available() else () UpperCAmelCase_ :Tuple = ( { "feature-extraction": CTRLModel, "text-classification": CTRLForSequenceClassification, "text-generation": CTRLLMHeadModel, "zero-shot": CTRLForSequenceClassification, } if is_torch_available() else {} ) UpperCAmelCase_ :int = True UpperCAmelCase_ :int = False UpperCAmelCase_ :List[Any] = False def __lowerCAmelCase ( self , __A , __A , __A , __A , __A ) -> Optional[Any]: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny # config could not be created. return True return False def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :int = CTRLModelTester(self ) lowerCAmelCase_ :Union[str, Any] = ConfigTester(self , config_class=__A , n_embd=37 ) def __lowerCAmelCase ( self ) -> str: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) -> Dict: self.config_tester.run_common_tests() def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_ctrl_model(*__A ) def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*__A ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def __lowerCAmelCase ( self ) -> Optional[Any]: pass @slow def __lowerCAmelCase ( self ) -> Any: for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCAmelCase_ :str = CTRLModel.from_pretrained(__A ) self.assertIsNotNone(__A ) @unittest.skip("""The model doesn't support left padding""" ) # and it's not used enough to be worth fixing :) def __lowerCAmelCase ( self ) -> Any: pass @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Dict: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() torch.cuda.empty_cache() @slow def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :List[str] = CTRLLMHeadModel.from_pretrained("""ctrl""" ) model.to(__A ) lowerCAmelCase_ :Union[str, Any] = torch.tensor( [[1_1859, 0, 1611, 8]] , dtype=torch.long , device=__A ) # Legal the president is lowerCAmelCase_ :Dict = [ 1_1859, 0, 1611, 8, 5, 150, 2_6449, 2, 19, 348, 469, 3, 2595, 48, 2_0740, 24_6533, 24_6533, 19, 30, 5, ] # Legal the president is a good guy and I don't want to lose my job. \n \n I have a lowerCAmelCase_ :str = model.generate(__A , do_sample=__A ) self.assertListEqual(output_ids[0].tolist() , __A )

"""simple docstring""" import importlib import json import os import sys import tempfile import unittest from pathlib import Path import transformers import transformers.models.auto from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig from transformers.models.bert.configuration_bert import BertConfig from transformers.models.roberta.configuration_roberta import RobertaConfig from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils')) from test_module.custom_configuration import CustomConfig # noqa E402 __UpperCAmelCase = get_tests_dir('fixtures/dummy-config.json') class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = 0 def __lowerCAmelCase ( self ) -> List[str]: self.assertIsNotNone(transformers.models.auto.__spec__ ) self.assertIsNotNone(importlib.util.find_spec("""transformers.models.auto""" ) ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""bert-base-uncased""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = AutoConfig.for_model("""roberta""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Tuple: with tempfile.TemporaryDirectory() as tmp_dir: # This model name contains bert and roberta, but roberta ends up being picked. lowerCAmelCase_ :int = os.path.join(__A , """fake-roberta""" ) os.makedirs(__A , exist_ok=__A ) with open(os.path.join(__A , """config.json""" ) , """w""" ) as f: f.write(json.dumps({} ) ) lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertEqual(type(__A ) , __A ) def __lowerCAmelCase ( self ) -> Optional[int]: try: AutoConfig.register("""custom""" , __A ) # Wrong model type will raise an error with self.assertRaises(__A ): AutoConfig.register("""model""" , __A ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(__A ): AutoConfig.register("""bert""" , __A ) # Now that the config is registered, it can be used as any other config with the auto-API lowerCAmelCase_ :Union[str, Any] = CustomConfig() with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Optional[int] = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] def __lowerCAmelCase ( self ) -> Tuple: with self.assertRaisesRegex( __A , """bert-base is not a local folder and is not a valid model identifier""" ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""bert-base""" ) def __lowerCAmelCase ( self ) -> Any: with self.assertRaisesRegex( __A , r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ): lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , revision="""aaaaaa""" ) def __lowerCAmelCase ( self ) -> int: with self.assertRaisesRegex( __A , """hf-internal-testing/no-config-test-repo does not appear to have a file named config.json.""" , ): lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/no-config-test-repo""" ) def __lowerCAmelCase ( self ) -> Tuple: # If remote code is not set, we will time out when asking whether to load the model. with self.assertRaises(__A ): lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(__A ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) lowerCAmelCase_ :str = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) # Test config can be reloaded. with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , trust_remote_code=__A ) self.assertEqual(reloaded_config.__class__.__name__ , """NewModelConfig""" ) def __lowerCAmelCase ( self ) -> int: class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :int = "new-model" try: AutoConfig.register("""new-model""" , __A ) # If remote code is not set, the default is to use local lowerCAmelCase_ :Any = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote code is disabled, we load the local one. lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote is enabled, we load from the Hub lowerCAmelCase_ :Optional[Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) finally: if "new-model" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["new-model"]

"""simple docstring""" from .imports import is_tqdm_available if is_tqdm_available(): from tqdm.auto import tqdm as _tqdm from ..state import PartialState def _snake_case ( lowercase__ : bool = True , *lowercase__ : Optional[int] , **lowercase__ : str ) -> Optional[Any]: '''simple docstring''' if not is_tqdm_available(): raise ImportError("""Accelerate's `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`.""" ) lowerCAmelCase_ :Tuple = False if main_process_only: lowerCAmelCase_ :Dict = PartialState().local_process_index == 0 return _tqdm(*lowercase__ , **lowercase__ , disable=lowercase__ )

"""simple docstring""" import json import os import unittest from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import ( VOCAB_FILES_NAMES, GPTSanJapaneseTokenizer, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :str = GPTSanJapaneseTokenizer UpperCAmelCase_ :Optional[int] = False UpperCAmelCase_ :Optional[int] = {"do_clean_text": False, "add_prefix_space": False} def __lowerCAmelCase ( self ) -> Tuple: super().setUp() # fmt: off lowerCAmelCase_ :Dict = ["""こん""", """こんに""", """にちは""", """ばんは""", """世界,㔺界""", """、""", """。""", """<BR>""", """<SP>""", """<TAB>""", """<URL>""", """<EMAIL>""", """<TEL>""", """<DATE>""", """<PRICE>""", """<BLOCK>""", """<KIGOU>""", """<U2000U2BFF>""", """<|emoji1|>""", """<unk>""", """<|bagoftoken|>""", """<|endoftext|>"""] # fmt: on lowerCAmelCase_ :List[str] = {"""emoji""": {"""\ud83d\ude00""": """<|emoji1|>"""}, """emoji_inv""": {"""<|emoji1|>""": """\ud83d\ude00"""}} # 😀 lowerCAmelCase_ :int = {"""unk_token""": """<unk>"""} lowerCAmelCase_ :Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) lowerCAmelCase_ :int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""emoji_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) with open(self.emoji_file , """w""" ) as emoji_writer: emoji_writer.write(json.dumps(__A ) ) def __lowerCAmelCase ( self , **__A ) -> int: kwargs.update(self.special_tokens_map ) return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname , **__A ) def __lowerCAmelCase ( self , __A ) -> Dict: lowerCAmelCase_ :List[Any] = """こんにちは、世界。 \nこんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[int] = """こんにちは、世界。 \nこんばんは、世界。😀""" return input_text, output_text def __lowerCAmelCase ( self , __A ) -> str: lowerCAmelCase_ , lowerCAmelCase_ :Tuple = self.get_input_output_texts(__A ) lowerCAmelCase_ :List[str] = tokenizer.encode(__A , add_special_tokens=__A ) lowerCAmelCase_ :str = tokenizer.decode(__A , clean_up_tokenization_spaces=__A ) return text, ids def __lowerCAmelCase ( self ) -> str: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> int: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :Union[str, Any] = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、世界。　こんばんは、㔺界。""" lowerCAmelCase_ :Any = ["""こん""", """にちは""", """、""", """世界""", """。""", """<SP>""", """こん""", """ばんは""", """、""", """㔺界""", """。"""] lowerCAmelCase_ :Tuple = tokenizer.tokenize(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids without special tokens lowerCAmelCase_ :List[Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6] lowerCAmelCase_ :List[str] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids with special tokens lowerCAmelCase_ :Any = tokens + [tokenizer.unk_token] lowerCAmelCase_ :Union[str, Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19] lowerCAmelCase_ :Union[str, Any] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。""" lowerCAmelCase_ :str = """こんにちは、、、、世界。こんばんは、、、、世界。""" lowerCAmelCase_ :str = tokenizer.encode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Tuple = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Any = """こんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。こんばんは、世界。😀""" lowerCAmelCase_ :List[Any] = tokenizer.encode(prefix_text + input_text ) lowerCAmelCase_ :List[str] = tokenizer.encode("""""" , prefix_text=prefix_text + input_text ) lowerCAmelCase_ :int = tokenizer.encode(__A , prefix_text=__A ) lowerCAmelCase_ :int = tokenizer.decode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) lowerCAmelCase_ :Tuple = tokenizer.decode(__A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :int = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :List[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Optional[int] = """こんばんは、㔺界。😀""" lowerCAmelCase_ :List[str] = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :Dict = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :int = [1] + [0] * (len_prefix + len_text + 1) lowerCAmelCase_ :List[Any] = [1] * (len_prefix + len_text + 1) + [0] lowerCAmelCase_ :Dict = [1] + [1] * (len_prefix) + [0] * (len_text + 1) lowerCAmelCase_ :List[Any] = tokenizer(prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[str] = tokenizer("""""" , prefix_text=prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[Any] = tokenizer(__A , prefix_text=__A ).token_type_ids self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Dict = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = tokenizer.encode("""あンいワ""" ) lowerCAmelCase_ :Optional[Any] = tokenizer.encode("""""" , prefix_text="""あンいワ""" ) lowerCAmelCase_ :int = tokenizer.encode("""いワ""" , prefix_text="""あン""" ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertNotEqual(__A , __A ) self.assertNotEqual(__A , __A ) self.assertEqual(x_token_a[1] , x_token_a[-1] ) # SEG token self.assertEqual(x_token_a[1] , x_token_a[3] ) # SEG token @slow def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Union[str, Any] = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = [["""武田信玄""", """は、"""], ["""織田信長""", """の配下の、"""]] lowerCAmelCase_ :Dict = tokenizer(__A , padding=__A ) lowerCAmelCase_ :Any = tokenizer.batch_encode_plus(__A , padding=__A ) # fmt: off lowerCAmelCase_ :int = [[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]] lowerCAmelCase_ :List[str] = [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]] lowerCAmelCase_ :int = [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]] # fmt: on self.assertListEqual(x_token.input_ids , __A ) self.assertListEqual(x_token.token_type_ids , __A ) self.assertListEqual(x_token.attention_mask , __A ) self.assertListEqual(x_token_a.input_ids , __A ) self.assertListEqual(x_token_a.token_type_ids , __A ) self.assertListEqual(x_token_a.attention_mask , __A ) def __lowerCAmelCase ( self ) -> Tuple: # Intentionally convert some words to accommodate character fluctuations unique to Japanese pass def __lowerCAmelCase ( self ) -> str: # tokenizer has no padding token pass

"""simple docstring""" import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :List[Any] = ConsistencyModelPipeline UpperCAmelCase_ :Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS UpperCAmelCase_ :Union[str, Any] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt UpperCAmelCase_ :int = frozenset( [ "num_inference_steps", "generator", "latents", "output_type", "return_dict", "callback", "callback_steps", ] ) @property def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :int = UNetaDModel.from_pretrained( """diffusers/consistency-models-test""" , subfolder="""test_unet""" , ) return unet @property def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Optional[int] = UNetaDModel.from_pretrained( """diffusers/consistency-models-test""" , subfolder="""test_unet_class_cond""" , ) return unet def __lowerCAmelCase ( self , __A=False ) -> Dict: if class_cond: lowerCAmelCase_ :int = self.dummy_cond_unet else: lowerCAmelCase_ :int = self.dummy_uncond_unet # Default to CM multistep sampler lowerCAmelCase_ :Dict = CMStochasticIterativeScheduler( num_train_timesteps=40 , sigma_min=0.0_0_2 , sigma_max=8_0.0 , ) lowerCAmelCase_ :str = { """unet""": unet, """scheduler""": scheduler, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> Tuple: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Union[str, Any] = torch.manual_seed(__A ) else: lowerCAmelCase_ :Any = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :List[str] = { """batch_size""": 1, """num_inference_steps""": None, """timesteps""": [22, 0], """generator""": generator, """output_type""": """np""", } return inputs def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :str = """cpu""" # ensure determinism for the device-dependent torch.Generator lowerCAmelCase_ :List[Any] = self.get_dummy_components() lowerCAmelCase_ :int = ConsistencyModelPipeline(**__A ) lowerCAmelCase_ :Any = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Optional[int] = pipe(**__A ).images assert image.shape == (1, 32, 32, 3) lowerCAmelCase_ :Optional[int] = image[0, -3:, -3:, -1] lowerCAmelCase_ :str = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Union[str, Any] = """cpu""" # ensure determinism for the device-dependent torch.Generator lowerCAmelCase_ :Optional[int] = self.get_dummy_components(class_cond=__A ) lowerCAmelCase_ :Optional[Any] = ConsistencyModelPipeline(**__A ) lowerCAmelCase_ :Tuple = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Any = self.get_dummy_inputs(__A ) lowerCAmelCase_ :int = 0 lowerCAmelCase_ :Optional[Any] = pipe(**__A ).images assert image.shape == (1, 32, 32, 3) lowerCAmelCase_ :Tuple = image[0, -3:, -3:, -1] lowerCAmelCase_ :List[Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Union[str, Any] = """cpu""" # ensure determinism for the device-dependent torch.Generator lowerCAmelCase_ :Any = self.get_dummy_components() lowerCAmelCase_ :str = ConsistencyModelPipeline(**__A ) lowerCAmelCase_ :Optional[int] = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Optional[Any] = 1 lowerCAmelCase_ :Any = None lowerCAmelCase_ :str = pipe(**__A ).images assert image.shape == (1, 32, 32, 3) lowerCAmelCase_ :Dict = image[0, -3:, -3:, -1] lowerCAmelCase_ :Dict = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Dict = """cpu""" # ensure determinism for the device-dependent torch.Generator lowerCAmelCase_ :List[Any] = self.get_dummy_components(class_cond=__A ) lowerCAmelCase_ :Union[str, Any] = ConsistencyModelPipeline(**__A ) lowerCAmelCase_ :Union[str, Any] = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Optional[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Tuple = 1 lowerCAmelCase_ :Dict = None lowerCAmelCase_ :int = 0 lowerCAmelCase_ :Optional[Any] = pipe(**__A ).images assert image.shape == (1, 32, 32, 3) lowerCAmelCase_ :List[str] = image[0, -3:, -3:, -1] lowerCAmelCase_ :Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 @slow @require_torch_gpu class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Any: super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self , __A=0 , __A=False , __A="cpu" , __A=torch.floataa , __A=(1, 3, 64, 64) ) -> Tuple: lowerCAmelCase_ :Any = torch.manual_seed(__A ) lowerCAmelCase_ :Optional[int] = { """num_inference_steps""": None, """timesteps""": [22, 0], """class_labels""": 0, """generator""": generator, """output_type""": """np""", } if get_fixed_latents: lowerCAmelCase_ :Dict = self.get_fixed_latents(seed=__A , device=__A , dtype=__A , shape=__A ) lowerCAmelCase_ :Tuple = latents return inputs def __lowerCAmelCase ( self , __A=0 , __A="cpu" , __A=torch.floataa , __A=(1, 3, 64, 64) ) -> List[str]: if type(__A ) == str: lowerCAmelCase_ :int = torch.device(__A ) lowerCAmelCase_ :str = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :Union[str, Any] = randn_tensor(__A , generator=__A , device=__A , dtype=__A ) return latents def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Optional[Any] = UNetaDModel.from_pretrained("""diffusers/consistency_models""" , subfolder="""diffusers_cd_imagenet64_l2""" ) lowerCAmelCase_ :int = CMStochasticIterativeScheduler( num_train_timesteps=40 , sigma_min=0.0_0_2 , sigma_max=8_0.0 , ) lowerCAmelCase_ :Optional[int] = ConsistencyModelPipeline(unet=__A , scheduler=__A ) pipe.to(torch_device=__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Optional[Any] = self.get_inputs() lowerCAmelCase_ :Union[str, Any] = pipe(**__A ).images assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :Any = image[0, -3:, -3:, -1] lowerCAmelCase_ :Union[str, Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 2E-2 def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Dict = UNetaDModel.from_pretrained("""diffusers/consistency_models""" , subfolder="""diffusers_cd_imagenet64_l2""" ) lowerCAmelCase_ :Tuple = CMStochasticIterativeScheduler( num_train_timesteps=40 , sigma_min=0.0_0_2 , sigma_max=8_0.0 , ) lowerCAmelCase_ :List[str] = ConsistencyModelPipeline(unet=__A , scheduler=__A ) pipe.to(torch_device=__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :str = self.get_inputs() lowerCAmelCase_ :List[str] = 1 lowerCAmelCase_ :Optional[int] = None lowerCAmelCase_ :str = pipe(**__A ).images assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :str = image[0, -3:, -3:, -1] lowerCAmelCase_ :Union[str, Any] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 2E-2 @require_torch_a def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :int = UNetaDModel.from_pretrained("""diffusers/consistency_models""" , subfolder="""diffusers_cd_imagenet64_l2""" ) lowerCAmelCase_ :List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40 , sigma_min=0.0_0_2 , sigma_max=8_0.0 , ) lowerCAmelCase_ :Dict = ConsistencyModelPipeline(unet=__A , scheduler=__A ) pipe.to(torch_device=__A , torch_dtype=torch.floataa ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[Any] = self.get_inputs(get_fixed_latents=__A , device=__A ) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=__A , enable_math=__A , enable_mem_efficient=__A ): lowerCAmelCase_ :Tuple = pipe(**__A ).images assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :Union[str, Any] = image[0, -3:, -3:, -1] lowerCAmelCase_ :Optional[int] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3 @require_torch_a def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[Any] = UNetaDModel.from_pretrained("""diffusers/consistency_models""" , subfolder="""diffusers_cd_imagenet64_l2""" ) lowerCAmelCase_ :Union[str, Any] = CMStochasticIterativeScheduler( num_train_timesteps=40 , sigma_min=0.0_0_2 , sigma_max=8_0.0 , ) lowerCAmelCase_ :Dict = ConsistencyModelPipeline(unet=__A , scheduler=__A ) pipe.to(torch_device=__A , torch_dtype=torch.floataa ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Dict = self.get_inputs(get_fixed_latents=__A , device=__A ) lowerCAmelCase_ :Any = 1 lowerCAmelCase_ :List[Any] = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=__A , enable_math=__A , enable_mem_efficient=__A ): lowerCAmelCase_ :Any = pipe(**__A ).images assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :Union[str, Any] = image[0, -3:, -3:, -1] lowerCAmelCase_ :List[str] = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-3

"""simple docstring""" import pandas as pd from matplotlib import pyplot as plt from sklearn.linear_model import LinearRegression # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split # Fitting Polynomial Regression to the dataset from sklearn.preprocessing import PolynomialFeatures # Importing the dataset __UpperCAmelCase = pd.read_csv( 'https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/' 'position_salaries.csv' ) __UpperCAmelCase = dataset.iloc[:, 1:2].values __UpperCAmelCase = dataset.iloc[:, 2].values __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = train_test_split(X, y, test_size=0.2, random_state=0) __UpperCAmelCase = PolynomialFeatures(degree=4) __UpperCAmelCase = poly_reg.fit_transform(X) __UpperCAmelCase = LinearRegression() pol_reg.fit(X_poly, y) def _snake_case ( ) -> str: '''simple docstring''' plt.scatter(lowercase__ , lowercase__ , color="""red""" ) plt.plot(lowercase__ , pol_reg.predict(poly_reg.fit_transform(lowercase__ ) ) , color="""blue""" ) plt.title("""Truth or Bluff (Linear Regression)""" ) plt.xlabel("""Position level""" ) plt.ylabel("""Salary""" ) plt.show() if __name__ == "__main__": viz_polymonial() # Predicting a new result with Polymonial Regression pol_reg.predict(poly_reg.fit_transform([[5.5]])) # output should be 132148.43750003

"""simple docstring""" from functools import lru_cache @lru_cache def _snake_case ( lowercase__ : int ) -> int: '''simple docstring''' if num < 0: raise ValueError("""Number should not be negative.""" ) return 1 if num in (0, 1) else num * factorial(num - 1 ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" from __future__ import annotations __UpperCAmelCase = 1.6021e-19 # units = C def _snake_case ( lowercase__ : float , lowercase__ : float , lowercase__ : float , ) -> tuple[str, float]: '''simple docstring''' if (conductivity, electron_conc, mobility).count(0 ) != 1: raise ValueError("""You cannot supply more or less than 2 values""" ) elif conductivity < 0: raise ValueError("""Conductivity cannot be negative""" ) elif electron_conc < 0: raise ValueError("""Electron concentration cannot be negative""" ) elif mobility < 0: raise ValueError("""mobility cannot be negative""" ) elif conductivity == 0: return ( "conductivity", mobility * electron_conc * ELECTRON_CHARGE, ) elif electron_conc == 0: return ( "electron_conc", conductivity / (mobility * ELECTRON_CHARGE), ) else: return ( "mobility", conductivity / (electron_conc * ELECTRON_CHARGE), ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" def _snake_case ( lowercase__ : List[Any] ) -> List[str]: '''simple docstring''' lowerCAmelCase_ :Optional[int] = 0 lowerCAmelCase_ :int = len(lowercase__ ) for i in range(n - 1 ): for j in range(i + 1 , lowercase__ ): if arr[i] > arr[j]: num_inversions += 1 return num_inversions def _snake_case ( lowercase__ : List[str] ) -> Optional[Any]: '''simple docstring''' if len(lowercase__ ) <= 1: return arr, 0 lowerCAmelCase_ :Dict = len(lowercase__ ) // 2 lowerCAmelCase_ :List[str] = arr[0:mid] lowerCAmelCase_ :Dict = arr[mid:] lowerCAmelCase_ , lowerCAmelCase_ :str = count_inversions_recursive(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = count_inversions_recursive(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Any = _count_cross_inversions(lowercase__ , lowercase__ ) lowerCAmelCase_ :str = inversion_p + inversions_q + cross_inversions return c, num_inversions def _snake_case ( lowercase__ : Optional[int] , lowercase__ : Union[str, Any] ) -> List[Any]: '''simple docstring''' lowerCAmelCase_ :List[str] = [] lowerCAmelCase_ :str = 0 while i < len(lowercase__ ) and j < len(lowercase__ ): if p[i] > q[j]: # if P[1] > Q[j], then P[k] > Q[k] for all i < k <= len(P) # These are all inversions. The claim emerges from the # property that P is sorted. num_inversion += len(lowercase__ ) - i r.append(q[j] ) j += 1 else: r.append(p[i] ) i += 1 if i < len(lowercase__ ): r.extend(p[i:] ) else: r.extend(q[j:] ) return r, num_inversion def _snake_case ( ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase_ :int = [1_0, 2, 1, 5, 5, 2, 1_1] # this arr has 8 inversions: # (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2) lowerCAmelCase_ :List[Any] = count_inversions_bf(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = count_inversions_recursive(lowercase__ ) assert num_inversions_bf == num_inversions_recursive == 8 print("""number of inversions = """ , lowercase__ ) # testing an array with zero inversion (a sorted arr_1) arr_a.sort() lowerCAmelCase_ :List[Any] = count_inversions_bf(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :str = count_inversions_recursive(lowercase__ ) assert num_inversions_bf == num_inversions_recursive == 0 print("""number of inversions = """ , lowercase__ ) # an empty list should also have zero inversions lowerCAmelCase_ :Union[str, Any] = [] lowerCAmelCase_ :str = count_inversions_bf(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = count_inversions_recursive(lowercase__ ) assert num_inversions_bf == num_inversions_recursive == 0 print("""number of inversions = """ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" import warnings from ...utils import logging from .image_processing_clip import CLIPImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , *__A , **__A ) -> None: warnings.warn( """The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use CLIPImageProcessor instead.""" , __A , ) super().__init__(*__A , **__A )

"""simple docstring""" from __future__ import annotations __UpperCAmelCase = { 'A': ['B', 'C', 'E'], 'B': ['A', 'D', 'E'], 'C': ['A', 'F', 'G'], 'D': ['B'], 'E': ['A', 'B', 'D'], 'F': ['C'], 'G': ['C'], } class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A ) -> None: lowerCAmelCase_ :Dict = graph # mapping node to its parent in resulting breadth first tree lowerCAmelCase_ :dict[str, str | None] = {} lowerCAmelCase_ :Any = source_vertex def __lowerCAmelCase ( self ) -> None: lowerCAmelCase_ :Optional[int] = {self.source_vertex} lowerCAmelCase_ :str = None lowerCAmelCase_ :Tuple = [self.source_vertex] # first in first out queue while queue: lowerCAmelCase_ :Optional[int] = queue.pop(0 ) for adjacent_vertex in self.graph[vertex]: if adjacent_vertex not in visited: visited.add(__A ) lowerCAmelCase_ :Any = vertex queue.append(__A ) def __lowerCAmelCase ( self , __A ) -> str: if target_vertex == self.source_vertex: return self.source_vertex lowerCAmelCase_ :Optional[Any] = self.parent.get(__A ) if target_vertex_parent is None: lowerCAmelCase_ :str = ( f"""No path from vertex: {self.source_vertex} to vertex: {target_vertex}""" ) raise ValueError(__A ) return self.shortest_path(__A ) + f"""->{target_vertex}""" if __name__ == "__main__": __UpperCAmelCase = Graph(graph, 'G') g.breath_first_search() print(g.shortest_path('D')) print(g.shortest_path('G')) print(g.shortest_path('Foo'))

"""simple docstring""" from itertools import zip_longest import requests from bsa import BeautifulSoup from pandas import DataFrame def _snake_case ( lowercase__ : str = "laptop" ) -> DataFrame: '''simple docstring''' lowerCAmelCase_ :Dict = f"""https://www.amazon.in/laptop/s?k={product}""" lowerCAmelCase_ :List[str] = { """User-Agent""": """Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/44.0.2403.157 Safari/537.36""", """Accept-Language""": """en-US, en;q=0.5""", } lowerCAmelCase_ :List[Any] = BeautifulSoup(requests.get(lowercase__ , headers=lowercase__ ).text ) # Initialize a Pandas dataframe with the column titles lowerCAmelCase_ :Union[str, Any] = DataFrame( columns=[ """Product Title""", """Product Link""", """Current Price of the product""", """Product Rating""", """MRP of the product""", """Discount""", ] ) # Loop through each entry and store them in the dataframe for item, _ in zip_longest( soup.find_all( """div""" , attrs={"""class""": """s-result-item""", """data-component-type""": """s-search-result"""} , ) , soup.find_all("""div""" , attrs={"""class""": """a-row a-size-base a-color-base"""} ) , ): try: lowerCAmelCase_ :str = item.ha.text lowerCAmelCase_ :Dict = """https://www.amazon.in/""" + item.ha.a["""href"""] lowerCAmelCase_ :int = item.find("""span""" , attrs={"""class""": """a-offscreen"""} ).text try: lowerCAmelCase_ :Dict = item.find("""span""" , attrs={"""class""": """a-icon-alt"""} ).text except AttributeError: lowerCAmelCase_ :int = """Not available""" try: lowerCAmelCase_ :str = ( """₹""" + item.find( """span""" , attrs={"""class""": """a-price a-text-price"""} ).text.split("""₹""" )[1] ) except AttributeError: lowerCAmelCase_ :Optional[Any] = """""" try: lowerCAmelCase_ :str = float( ( ( float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) - float(product_price.strip("""₹""" ).replace(""",""" , """""" ) ) ) / float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) ) * 1_0_0 ) except ValueError: lowerCAmelCase_ :Union[str, Any] = float("""nan""" ) except AttributeError: pass lowerCAmelCase_ :Any = [ product_title, product_link, product_price, product_rating, product_mrp, discount, ] lowerCAmelCase_ :List[Any] = """ """ lowerCAmelCase_ :Tuple = """ """ data_frame.index += 1 return data_frame if __name__ == "__main__": __UpperCAmelCase = 'headphones' get_amazon_product_data(product).to_csv(F"""Amazon Product Data for {product}.csv""")

"""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() __UpperCAmelCase = logging.get_logger(__name__) # here we list all keys to be renamed (original name on the left, our name on the right) __UpperCAmelCase = [] 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 _snake_case ( lowercase__ : List[Any] , lowercase__ : Tuple , lowercase__ : Any ) -> Optional[int]: '''simple docstring''' lowerCAmelCase_ :Optional[int] = state_dict.pop(lowercase__ ) lowerCAmelCase_ :List[str] = val def _snake_case ( lowercase__ : Optional[Any] ) -> int: '''simple docstring''' lowerCAmelCase_ :Any = OrderedDict() for key, value in state_dict.items(): if "backbone.0.body" in key: lowerCAmelCase_ :Union[str, Any] = key.replace("""backbone.0.body""" , """backbone.conv_encoder.model""" ) lowerCAmelCase_ :Dict = value else: lowerCAmelCase_ :Union[str, Any] = value return new_state_dict def _snake_case ( lowercase__ : Any ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :List[Any] = """""" # 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) lowerCAmelCase_ :Optional[Any] = state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""" ) lowerCAmelCase_ :str = 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 lowerCAmelCase_ :List[str] = in_proj_weight[:2_5_6, :] lowerCAmelCase_ :Tuple = in_proj_bias[:2_5_6] lowerCAmelCase_ :Tuple = in_proj_weight[2_5_6:5_1_2, :] lowerCAmelCase_ :List[Any] = in_proj_bias[2_5_6:5_1_2] lowerCAmelCase_ :int = in_proj_weight[-2_5_6:, :] lowerCAmelCase_ :Any = in_proj_bias[-2_5_6:] # next: transformer decoder (which is a bit more complex because it also includes cross-attention) for i in range(6 ): # read in weights + bias of input projection layer of self-attention lowerCAmelCase_ :Dict = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""" ) lowerCAmelCase_ :List[str] = 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 lowerCAmelCase_ :Union[str, Any] = in_proj_weight[:2_5_6, :] lowerCAmelCase_ :Dict = in_proj_bias[:2_5_6] lowerCAmelCase_ :Optional[Any] = in_proj_weight[2_5_6:5_1_2, :] lowerCAmelCase_ :List[Any] = in_proj_bias[2_5_6:5_1_2] lowerCAmelCase_ :Any = in_proj_weight[-2_5_6:, :] lowerCAmelCase_ :Optional[int] = in_proj_bias[-2_5_6:] # read in weights + bias of input projection layer of cross-attention lowerCAmelCase_ :Tuple = state_dict.pop( f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""" ) lowerCAmelCase_ :Union[str, Any] = 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 lowerCAmelCase_ :Optional[int] = in_proj_weight_cross_attn[:2_5_6, :] lowerCAmelCase_ :str = in_proj_bias_cross_attn[:2_5_6] lowerCAmelCase_ :List[Any] = in_proj_weight_cross_attn[2_5_6:5_1_2, :] lowerCAmelCase_ :Optional[int] = in_proj_bias_cross_attn[2_5_6:5_1_2] lowerCAmelCase_ :Any = in_proj_weight_cross_attn[-2_5_6:, :] lowerCAmelCase_ :List[Any] = in_proj_bias_cross_attn[-2_5_6:] def _snake_case ( lowercase__ : Union[str, Any] , lowercase__ : Dict ) -> Tuple: '''simple docstring''' lowerCAmelCase_ , lowerCAmelCase_ :Tuple = image.size lowerCAmelCase_ :Any = max(lowercase__ , lowercase__ ) lowerCAmelCase_ :Optional[Any] = 8_0_0 if """detection""" in checkpoint_url else 1_0_0_0 lowerCAmelCase_ :int = target_max_size / current_max_size lowerCAmelCase_ :Optional[Any] = image.resize((int(round(scale * width ) ), int(round(scale * height ) )) ) return resized_image def _snake_case ( lowercase__ : Any ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase_ :List[str] = F.to_tensor(lowercase__ ) lowerCAmelCase_ :List[str] = F.normalize(lowercase__ , mean=[0.485, 0.456, 0.406] , std=[0.229, 0.224, 0.225] ) return image @torch.no_grad() def _snake_case ( lowercase__ : List[str] , lowercase__ : int , lowercase__ : Any ) -> Tuple: '''simple docstring''' logger.info("""Converting model...""" ) # load original state dict lowerCAmelCase_ :int = torch.hub.load_state_dict_from_url(lowercase__ , map_location="""cpu""" ) # rename keys for src, dest in rename_keys: rename_key(lowercase__ , lowercase__ , lowercase__ ) lowerCAmelCase_ :Tuple = rename_backbone_keys(lowercase__ ) # query, key and value matrices need special treatment read_in_q_k_v(lowercase__ ) # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them lowerCAmelCase_ :Optional[Any] = """model.""" for key in state_dict.copy().keys(): if not key.startswith("""class_labels_classifier""" ) and not key.startswith("""bbox_predictor""" ): lowerCAmelCase_ :Union[str, Any] = state_dict.pop(lowercase__ ) lowerCAmelCase_ :str = val # create HuggingFace model and load state dict lowerCAmelCase_ :List[Any] = 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: lowerCAmelCase_ :str = 1_5 lowerCAmelCase_ :Any = 2 lowerCAmelCase_ :Union[str, Any] = {0: """table""", 1: """table rotated"""} lowerCAmelCase_ :List[Any] = idalabel lowerCAmelCase_ :Dict = {v: k for k, v in idalabel.items()} else: lowerCAmelCase_ :int = 1_2_5 lowerCAmelCase_ :Optional[Any] = 6 lowerCAmelCase_ :Optional[int] = { 0: """table""", 1: """table column""", 2: """table row""", 3: """table column header""", 4: """table projected row header""", 5: """table spanning cell""", } lowerCAmelCase_ :Optional[int] = idalabel lowerCAmelCase_ :List[Any] = {v: k for k, v in idalabel.items()} lowerCAmelCase_ :int = DetrImageProcessor( format="""coco_detection""" , max_size=8_0_0 if """detection""" in checkpoint_url else 1_0_0_0 ) lowerCAmelCase_ :Any = TableTransformerForObjectDetection(lowercase__ ) model.load_state_dict(lowercase__ ) model.eval() # verify our conversion lowerCAmelCase_ :Union[str, Any] = """example_pdf.png""" if """detection""" in checkpoint_url else """example_table.png""" lowerCAmelCase_ :Union[str, Any] = hf_hub_download(repo_id="""nielsr/example-pdf""" , repo_type="""dataset""" , filename=lowercase__ ) lowerCAmelCase_ :Union[str, Any] = Image.open(lowercase__ ).convert("""RGB""" ) lowerCAmelCase_ :int = normalize(resize(lowercase__ , lowercase__ ) ).unsqueeze(0 ) lowerCAmelCase_ :List[str] = model(lowercase__ ) if "detection" in checkpoint_url: lowerCAmelCase_ :List[str] = (1, 1_5, 3) lowerCAmelCase_ :Optional[Any] = torch.tensor( [[-6.7897, -16.9985, 6.7937], [-8.0186, -22.2192, 6.9677], [-7.3117, -21.0708, 7.4055]] ) lowerCAmelCase_ :Union[str, Any] = torch.tensor([[0.4867, 0.1767, 0.6732], [0.6718, 0.4479, 0.3830], [0.4716, 0.1760, 0.6364]] ) else: lowerCAmelCase_ :List[Any] = (1, 1_2_5, 7) lowerCAmelCase_ :Dict = torch.tensor( [[-18.1430, -8.3214, 4.8274], [-18.4685, -7.1361, -4.2667], [-26.3693, -9.3429, -4.9962]] ) lowerCAmelCase_ :Tuple = torch.tensor([[0.4983, 0.5595, 0.9440], [0.4916, 0.6315, 0.5954], [0.6108, 0.8637, 0.1135]] ) assert outputs.logits.shape == expected_shape assert torch.allclose(outputs.logits[0, :3, :3] , lowercase__ , atol=1E-4 ) assert torch.allclose(outputs.pred_boxes[0, :3, :3] , lowercase__ , 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(lowercase__ ).mkdir(exist_ok=lowercase__ ) model.save_pretrained(lowercase__ ) image_processor.save_pretrained(lowercase__ ) if push_to_hub: # Push model to HF hub logger.info("""Pushing model to the hub...""" ) lowerCAmelCase_ :Dict = ( """microsoft/table-transformer-detection""" if """detection""" in checkpoint_url else """microsoft/table-transformer-structure-recognition""" ) model.push_to_hub(lowercase__ ) image_processor.push_to_hub(lowercase__ ) if __name__ == "__main__": __UpperCAmelCase = 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.' ) __UpperCAmelCase = parser.parse_args() convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)

"""simple docstring""" import shutil import tempfile import unittest from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast from transformers.testing_utils import require_sentencepiece, require_torchaudio from .test_feature_extraction_clap import floats_list @require_torchaudio @require_sentencepiece class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Any = """laion/clap-htsat-unfused""" lowerCAmelCase_ :Optional[Any] = tempfile.mkdtemp() def __lowerCAmelCase ( self , **__A ) -> List[Any]: return RobertaTokenizer.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self , **__A ) -> Tuple: return ClapFeatureExtractor.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self ) -> int: shutil.rmtree(self.tmpdirname ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Optional[Any] = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :Optional[Any] = ClapProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Dict = ClapProcessor(tokenizer=self.get_tokenizer() , feature_extractor=self.get_feature_extractor() ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :str = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) lowerCAmelCase_ :Dict = self.get_feature_extractor(do_normalize=__A , padding_value=1.0 ) lowerCAmelCase_ :Union[str, Any] = ClapProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=__A , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Dict = self.get_feature_extractor() lowerCAmelCase_ :str = self.get_tokenizer() lowerCAmelCase_ :List[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :Optional[Any] = floats_list((3, 1000) ) lowerCAmelCase_ :Optional[Any] = feature_extractor(__A , return_tensors="""np""" ) lowerCAmelCase_ :str = processor(audios=__A , return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :List[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :List[Any] = """This is a test string""" lowerCAmelCase_ :Dict = processor(text=__A ) lowerCAmelCase_ :List[str] = tokenizer(__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :int = self.get_feature_extractor() lowerCAmelCase_ :Tuple = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] lowerCAmelCase_ :Tuple = processor.batch_decode(__A ) lowerCAmelCase_ :Optional[Any] = tokenizer.batch_decode(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) self.assertListEqual( processor.model_input_names[2:] , feature_extractor.model_input_names , msg="""`processor` and `feature_extractor` model input names do not match""" , )

"""simple docstring""" import os def _snake_case ( ) -> Dict: '''simple docstring''' lowerCAmelCase_ :Any = os.path.dirname(os.path.realpath(lowercase__ ) ) lowerCAmelCase_ :Optional[int] = os.path.join(lowercase__ , """triangle.txt""" ) with open(lowercase__ ) as f: lowerCAmelCase_ :Optional[int] = f.readlines() lowerCAmelCase_ :Optional[Any] = [] for line in triangle: lowerCAmelCase_ :Union[str, Any] = [] for number in line.strip().split(""" """ ): numbers_from_line.append(int(lowercase__ ) ) a.append(lowercase__ ) for i in range(1 , len(lowercase__ ) ): for j in range(len(a[i] ) ): lowerCAmelCase_ :List[str] = a[i - 1][j] if j != len(a[i - 1] ) else 0 lowerCAmelCase_ :Dict = a[i - 1][j - 1] if j > 0 else 0 a[i][j] += max(lowercase__ , lowercase__ ) return max(a[-1] ) if __name__ == "__main__": print(solution())

"""simple docstring""" import os from math import logaa def _snake_case ( lowercase__ : str = "base_exp.txt" ) -> int: '''simple docstring''' lowerCAmelCase_ :float = 0 lowerCAmelCase_ :Union[str, Any] = 0 for i, line in enumerate(open(os.path.join(os.path.dirname(lowercase__ ) , lowercase__ ) ) ): lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = list(map(lowercase__ , line.split(""",""" ) ) ) if x * logaa(lowercase__ ) > largest: lowerCAmelCase_ :Any = x * logaa(lowercase__ ) lowerCAmelCase_ :List[Any] = i + 1 return result if __name__ == "__main__": print(solution())

"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json', } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[Any] = "gpt_neox_japanese" def __init__( self , __A=3_2000 , __A=2560 , __A=32 , __A=32 , __A=4 , __A="gelu" , __A=1.0_0 , __A=1_0000 , __A=2048 , __A=0.0_2 , __A=1E-5 , __A=True , __A=3_1996 , __A=3_1999 , __A=0.1 , __A=0.0 , **__A , ) -> Tuple: super().__init__(bos_token_id=__A , eos_token_id=__A , **__A ) lowerCAmelCase_ :int = vocab_size lowerCAmelCase_ :Dict = max_position_embeddings lowerCAmelCase_ :Dict = hidden_size lowerCAmelCase_ :str = num_hidden_layers lowerCAmelCase_ :Any = num_attention_heads lowerCAmelCase_ :str = intermediate_multiple_size lowerCAmelCase_ :Dict = hidden_act lowerCAmelCase_ :List[Any] = rotary_pct lowerCAmelCase_ :List[Any] = rotary_emb_base lowerCAmelCase_ :Union[str, Any] = initializer_range lowerCAmelCase_ :Tuple = layer_norm_eps lowerCAmelCase_ :Optional[Any] = use_cache lowerCAmelCase_ :int = attention_dropout lowerCAmelCase_ :Dict = hidden_dropout

"""simple docstring""" import itertools import math def _snake_case ( lowercase__ : int ) -> bool: '''simple docstring''' if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(lowercase__ ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def _snake_case ( ) -> Dict: '''simple docstring''' lowerCAmelCase_ :List[Any] = 2 while True: if is_prime(lowercase__ ): yield num num += 1 def _snake_case ( lowercase__ : int = 1_0_0_0_1 ) -> int: '''simple docstring''' return next(itertools.islice(prime_generator() , nth - 1 , lowercase__ ) ) if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" import argparse import json import re from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileNetVaConfig, MobileNetVaForImageClassification, MobileNetVaImageProcessor, load_tf_weights_in_mobilenet_va, ) from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) def _snake_case ( lowercase__ : List[Any] ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase_ :Tuple = MobileNetVaConfig(layer_norm_eps=0.001 ) if "_quant" in model_name: raise ValueError("""Quantized models are not supported.""" ) lowerCAmelCase_ :List[Any] = re.match(r"""^mobilenet_v1_([^_]*)_([^_]*)$""" , lowercase__ ) if matches: lowerCAmelCase_ :Optional[int] = float(matches[1] ) lowerCAmelCase_ :Dict = int(matches[2] ) # The TensorFlow version of MobileNetV1 predicts 1001 classes instead of # the usual 1000. The first class (index 0) is "background". lowerCAmelCase_ :Union[str, Any] = 1_0_0_1 lowerCAmelCase_ :Dict = """imagenet-1k-id2label.json""" lowerCAmelCase_ :List[str] = """huggingface/label-files""" lowerCAmelCase_ :Dict = json.load(open(hf_hub_download(lowercase__ , lowercase__ , repo_type="""dataset""" ) , """r""" ) ) lowerCAmelCase_ :Tuple = {int(lowercase__ ) + 1: v for k, v in idalabel.items()} lowerCAmelCase_ :str = """background""" lowerCAmelCase_ :Union[str, Any] = idalabel lowerCAmelCase_ :List[str] = {v: k for k, v in idalabel.items()} return config def _snake_case ( ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :Dict = """http://images.cocodataset.org/val2017/000000039769.jpg""" lowerCAmelCase_ :Optional[int] = Image.open(requests.get(lowercase__ , stream=lowercase__ ).raw ) return im @torch.no_grad() def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : Optional[int] , lowercase__ : Union[str, Any] , lowercase__ : str=False ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :Dict = get_mobilenet_va_config(lowercase__ ) # Load 🤗 model lowerCAmelCase_ :str = MobileNetVaForImageClassification(lowercase__ ).eval() # Load weights from TensorFlow checkpoint load_tf_weights_in_mobilenet_va(lowercase__ , lowercase__ , lowercase__ ) # Check outputs on an image, prepared by MobileNetV1ImageProcessor lowerCAmelCase_ :Optional[int] = MobileNetVaImageProcessor( crop_size={"""width""": config.image_size, """height""": config.image_size} , size={"""shortest_edge""": config.image_size + 3_2} , ) lowerCAmelCase_ :List[str] = image_processor(images=prepare_img() , return_tensors="""pt""" ) lowerCAmelCase_ :int = model(**lowercase__ ) lowerCAmelCase_ :List[Any] = outputs.logits assert logits.shape == (1, 1_0_0_1) if model_name == "mobilenet_v1_1.0_224": lowerCAmelCase_ :str = torch.tensor([-4.1739, -1.1233, 3.1205] ) elif model_name == "mobilenet_v1_0.75_192": lowerCAmelCase_ :Optional[int] = torch.tensor([-3.9440, -2.3141, -0.3333] ) else: lowerCAmelCase_ :List[str] = None if expected_logits is not None: assert torch.allclose(logits[0, :3] , lowercase__ , atol=1E-4 ) Path(lowercase__ ).mkdir(exist_ok=lowercase__ ) print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(lowercase__ ) print(f"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(lowercase__ ) if push_to_hub: print("""Pushing to the hub...""" ) lowerCAmelCase_ :Union[str, Any] = """google/""" + model_name image_processor.push_to_hub(lowercase__ ) model.push_to_hub(lowercase__ ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='mobilenet_v1_1.0_224', type=str, help='Name of the MobileNetV1 model you\'d like to convert. Should in the form \'mobilenet_v1_<depth>_<size>\'.', ) parser.add_argument( '--checkpoint_path', required=True, type=str, help='Path to the original TensorFlow checkpoint (.ckpt file).' ) parser.add_argument( '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) __UpperCAmelCase = parser.parse_args() convert_movilevit_checkpoint( args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub )

"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :int = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" from datetime import datetime as dt import os from github import Github __UpperCAmelCase = [ 'good first issue', 'good second issue', 'good difficult issue', 'feature request', 'new model', 'wip', ] def _snake_case ( ) -> Optional[int]: '''simple docstring''' lowerCAmelCase_ :Any = Github(os.environ["""GITHUB_TOKEN"""] ) lowerCAmelCase_ :Dict = g.get_repo("""huggingface/transformers""" ) lowerCAmelCase_ :List[str] = repo.get_issues(state="""open""" ) for issue in open_issues: lowerCAmelCase_ :Dict = sorted([comment for comment in issue.get_comments()] , key=lambda lowercase__ : i.created_at , reverse=lowercase__ ) lowerCAmelCase_ :Any = comments[0] if len(lowercase__ ) > 0 else None if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and (dt.utcnow() - issue.updated_at).days > 7 and (dt.utcnow() - issue.created_at).days >= 3_0 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.") issue.edit(state="""closed""" ) elif ( (dt.utcnow() - issue.updated_at).days > 2_3 and (dt.utcnow() - issue.created_at).days >= 3_0 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # print(f"Would add stale comment to {issue.number}") issue.create_comment( """This issue has been automatically marked as stale because it has not had """ """recent activity. If you think this still needs to be addressed """ """please comment on this thread.\n\nPlease note that issues that do not follow the """ """[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) """ """are likely to be ignored.""" ) if __name__ == "__main__": main()

"""simple docstring""" # This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/ 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, ControlNetModel, DDIMScheduler, StableDiffusionControlNetImgaImgPipeline, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import ( IMAGE_TO_IMAGE_IMAGE_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS, ) from ..test_pipelines_common import ( PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin, ) enable_full_determinism() class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :Tuple = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :List[str] = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"} ) UpperCAmelCase_ :Optional[Any] = IMAGE_TO_IMAGE_IMAGE_PARAMS def __lowerCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) lowerCAmelCase_ :Tuple = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[str] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Union[str, Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :List[Any] = CLIPTextModel(__A ) lowerCAmelCase_ :int = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Union[str, Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> List[str]: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Tuple = torch.manual_seed(__A ) else: lowerCAmelCase_ :Optional[int] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :List[Any] = 2 lowerCAmelCase_ :int = randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ) lowerCAmelCase_ :Optional[int] = floats_tensor(control_image.shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Tuple = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :Union[str, Any] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> int: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Union[str, Any]: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) class _SCREAMING_SNAKE_CASE ( A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :List[str] = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :int = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :int = frozenset([] ) # TO_DO: add image_params once refactored VaeImageProcessor.preprocess def __lowerCAmelCase ( self ) -> Optional[int]: torch.manual_seed(0 ) lowerCAmelCase_ :Dict = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) def init_weights(__A ): if isinstance(__A , torch.nn.Convad ): torch.nn.init.normal(m.weight ) m.bias.data.fill_(1.0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[int] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :str = CLIPTextModel(__A ) lowerCAmelCase_ :str = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Optional[Any] = MultiControlNetModel([controlneta, controlneta] ) lowerCAmelCase_ :List[Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> str: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Optional[Any] = torch.manual_seed(__A ) else: lowerCAmelCase_ :List[Any] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :Optional[Any] = 2 lowerCAmelCase_ :Optional[int] = [ randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), ] lowerCAmelCase_ :int = floats_tensor(control_image[0].shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Optional[Any] = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :List[str] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) lowerCAmelCase_ :Union[str, Any] = 1_0.0 lowerCAmelCase_ :Union[str, Any] = 4 lowerCAmelCase_ :Tuple = self.get_dummy_inputs(__A ) lowerCAmelCase_ :List[str] = steps lowerCAmelCase_ :int = scale lowerCAmelCase_ :Union[str, Any] = pipe(**__A )[0] lowerCAmelCase_ :Any = self.get_dummy_inputs(__A ) lowerCAmelCase_ :str = steps lowerCAmelCase_ :str = scale lowerCAmelCase_ :Tuple = pipe(**__A , control_guidance_start=0.1 , control_guidance_end=0.2 )[0] lowerCAmelCase_ :Optional[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Union[str, Any] = steps lowerCAmelCase_ :Union[str, Any] = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=[0.1, 0.3] , control_guidance_end=[0.2, 0.7] )[0] lowerCAmelCase_ :List[str] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Optional[int] = steps lowerCAmelCase_ :Tuple = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=0.4 , control_guidance_end=[0.5, 0.8] )[0] # make sure that all outputs are different assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 def __lowerCAmelCase ( self ) -> Dict: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Tuple: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> Optional[int]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :str = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) with tempfile.TemporaryDirectory() as tmpdir: try: # save_pretrained is not implemented for Multi-ControlNet pipe.save_pretrained(__A ) except NotImplementedError: pass @slow @require_torch_gpu class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> int: super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Any = ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny""" ) lowerCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline.from_pretrained( """runwayml/stable-diffusion-v1-5""" , safety_checker=__A , controlnet=__A ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[str] = torch.Generator(device="""cpu""" ).manual_seed(0 ) lowerCAmelCase_ :List[Any] = """evil space-punk bird""" lowerCAmelCase_ :List[Any] = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png""" ).resize((512, 512) ) lowerCAmelCase_ :int = load_image( """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png""" ).resize((512, 512) ) lowerCAmelCase_ :Union[str, Any] = pipe( __A , __A , control_image=__A , generator=__A , output_type="""np""" , num_inference_steps=50 , strength=0.6 , ) lowerCAmelCase_ :Tuple = output.images[0] assert image.shape == (512, 512, 3) lowerCAmelCase_ :Tuple = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy""" ) assert np.abs(expected_image - image ).max() < 9E-2

"""simple docstring""" 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 _SCREAMING_SNAKE_CASE ( A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :List[Any] = IFImgaImgSuperResolutionPipeline UpperCAmelCase_ :Any = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"} UpperCAmelCase_ :Tuple = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"} ) UpperCAmelCase_ :int = PipelineTesterMixin.required_optional_params - {"latents"} def __lowerCAmelCase ( self ) -> List[str]: return self._get_superresolution_dummy_components() def __lowerCAmelCase ( self , __A , __A=0 ) -> Optional[int]: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Optional[int] = torch.manual_seed(__A ) else: lowerCAmelCase_ :Any = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :int = floats_tensor((1, 3, 32, 32) , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :List[Any] = floats_tensor((1, 3, 16, 16) , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :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 __lowerCAmelCase ( self ) -> Dict: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3 ) def __lowerCAmelCase ( self ) -> Tuple: self._test_save_load_optional_components() @unittest.skipIf(torch_device != """cuda""" , reason="""float16 requires CUDA""" ) def __lowerCAmelCase ( self ) -> Any: # 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 __lowerCAmelCase ( self ) -> str: self._test_attention_slicing_forward_pass(expected_max_diff=1E-2 ) def __lowerCAmelCase ( self ) -> Dict: self._test_save_load_local() def __lowerCAmelCase ( self ) -> Union[str, Any]: self._test_inference_batch_single_identical( expected_max_diff=1E-2 , )

"""simple docstring""" from typing import Optional import numpy as np import torch from torch import nn from transformers import GPTaConfig, GPTaLMHeadModel from transformers.modeling_utils import ModuleUtilsMixin from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ ): UpperCAmelCase_ :List[str] = [r"h\.\d+\.attn\.bias", r"h\.\d+\.attn\.masked_bias"] @register_to_config def __init__( self , __A , __A , __A = None , __A = 5_0257 , __A = 1024 , __A = 768 , __A = 12 , __A = 12 , __A = None , __A = "gelu_new" , __A = 0.1 , __A = 0.1 , __A = 0.1 , __A = 1E-5 , __A = 0.0_2 , __A = True , __A = True , __A = False , __A = False , ) -> Optional[Any]: super().__init__() lowerCAmelCase_ :List[str] = prefix_length if prefix_inner_dim != n_embd and prefix_hidden_dim is None: raise ValueError( f"""`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and""" f""" `n_embd`: {n_embd} are not equal.""" ) lowerCAmelCase_ :Union[str, Any] = prefix_inner_dim lowerCAmelCase_ :str = prefix_hidden_dim lowerCAmelCase_ :str = ( nn.Linear(self.prefix_inner_dim , self.prefix_hidden_dim ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :List[Any] = ( nn.Linear(self.prefix_hidden_dim , __A ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :Any = GPTaConfig( vocab_size=__A , n_positions=__A , n_embd=__A , n_layer=__A , n_head=__A , n_inner=__A , activation_function=__A , resid_pdrop=__A , embd_pdrop=__A , attn_pdrop=__A , layer_norm_epsilon=__A , initializer_range=__A , scale_attn_weights=__A , use_cache=__A , scale_attn_by_inverse_layer_idx=__A , reorder_and_upcast_attn=__A , ) lowerCAmelCase_ :Any = GPTaLMHeadModel(__A ) def __lowerCAmelCase ( self , __A , __A , __A = None , __A = None , ) -> List[str]: lowerCAmelCase_ :str = self.transformer.transformer.wte(__A ) lowerCAmelCase_ :Any = self.encode_prefix(__A ) lowerCAmelCase_ :Optional[Any] = self.decode_prefix(__A ) lowerCAmelCase_ :Optional[int] = torch.cat((prefix_embeds, embedding_text) , dim=1 ) if labels is not None: lowerCAmelCase_ :int = self.get_dummy_token(input_ids.shape[0] , input_ids.device ) lowerCAmelCase_ :Optional[Any] = torch.cat((dummy_token, input_ids) , dim=1 ) lowerCAmelCase_ :Tuple = self.transformer(inputs_embeds=__A , labels=__A , attention_mask=__A ) if self.prefix_hidden_dim is not None: return out, hidden else: return out def __lowerCAmelCase ( self , __A , __A ) -> torch.Tensor: return torch.zeros(__A , self.prefix_length , dtype=torch.intaa , device=__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: return self.encode_prefix(__A ) @torch.no_grad() def __lowerCAmelCase ( self , __A , __A , __A ) -> Optional[int]: lowerCAmelCase_ :Tuple = torch.split(__A , 1 , dim=0 ) lowerCAmelCase_ :Optional[int] = [] lowerCAmelCase_ :List[str] = [] for feature in features: lowerCAmelCase_ :Tuple = self.decode_prefix(feature.to(__A ) ) # back to the clip feature # Only support beam search for now lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.generate_beam( input_embeds=__A , device=__A , eos_token_id=__A ) generated_tokens.append(output_tokens[0] ) generated_seq_lengths.append(seq_lengths[0] ) lowerCAmelCase_ :Tuple = torch.stack(__A ) lowerCAmelCase_ :int = torch.stack(__A ) return generated_tokens, generated_seq_lengths @torch.no_grad() def __lowerCAmelCase ( self , __A=None , __A=None , __A=None , __A = 5 , __A = 67 , __A = 1.0 , __A = None , ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = eos_token_id lowerCAmelCase_ :Optional[int] = None lowerCAmelCase_ :Any = None lowerCAmelCase_ :int = torch.ones(__A , device=__A , dtype=torch.int ) lowerCAmelCase_ :Optional[int] = torch.zeros(__A , device=__A , dtype=torch.bool ) if input_embeds is not None: lowerCAmelCase_ :List[str] = input_embeds else: lowerCAmelCase_ :Union[str, Any] = self.transformer.transformer.wte(__A ) for i in range(__A ): lowerCAmelCase_ :Optional[int] = self.transformer(inputs_embeds=__A ) lowerCAmelCase_ :str = outputs.logits lowerCAmelCase_ :str = logits[:, -1, :] / (temperature if temperature > 0 else 1.0) lowerCAmelCase_ :Dict = logits.softmax(-1 ).log() if scores is None: lowerCAmelCase_ , lowerCAmelCase_ :Any = logits.topk(__A , -1 ) lowerCAmelCase_ :Union[str, Any] = generated.expand(__A , *generated.shape[1:] ) lowerCAmelCase_ , lowerCAmelCase_ :List[str] = next_tokens.permute(1 , 0 ), scores.squeeze(0 ) if tokens is None: lowerCAmelCase_ :List[str] = next_tokens else: lowerCAmelCase_ :List[Any] = tokens.expand(__A , *tokens.shape[1:] ) lowerCAmelCase_ :Any = torch.cat((tokens, next_tokens) , dim=1 ) else: lowerCAmelCase_ :List[Any] = -float(np.inf ) lowerCAmelCase_ :int = 0 lowerCAmelCase_ :Optional[int] = scores[:, None] + logits seq_lengths[~is_stopped] += 1 lowerCAmelCase_ :List[Any] = scores_sum / seq_lengths[:, None] lowerCAmelCase_ , lowerCAmelCase_ :Tuple = scores_sum_average.view(-1 ).topk(__A , -1 ) lowerCAmelCase_ :Optional[Any] = next_tokens // scores_sum.shape[1] lowerCAmelCase_ :Dict = seq_lengths[next_tokens_source] lowerCAmelCase_ :Tuple = next_tokens % scores_sum.shape[1] lowerCAmelCase_ :Optional[Any] = next_tokens.unsqueeze(1 ) lowerCAmelCase_ :str = tokens[next_tokens_source] lowerCAmelCase_ :List[Any] = torch.cat((tokens, next_tokens) , dim=1 ) lowerCAmelCase_ :Dict = generated[next_tokens_source] lowerCAmelCase_ :Dict = scores_sum_average * seq_lengths lowerCAmelCase_ :Tuple = is_stopped[next_tokens_source] lowerCAmelCase_ :str = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] , 1 , -1 ) lowerCAmelCase_ :List[Any] = torch.cat((generated, next_token_embed) , dim=1 ) lowerCAmelCase_ :Optional[int] = is_stopped + next_tokens.eq(__A ).squeeze() if is_stopped.all(): break lowerCAmelCase_ :str = scores / seq_lengths lowerCAmelCase_ :Optional[int] = scores.argsort(descending=__A ) # tokens tensors are already padded to max_seq_length lowerCAmelCase_ :Optional[Any] = [tokens[i] for i in order] lowerCAmelCase_ :Dict = torch.stack(__A , dim=0 ) lowerCAmelCase_ :Tuple = torch.tensor([seq_lengths[i] for i in order] , dtype=seq_lengths.dtype ) return output_texts, seq_lengths

"""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 _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[str] = ["image_processor", "tokenizer"] UpperCAmelCase_ :str = "ViltImageProcessor" UpperCAmelCase_ :str = ("BertTokenizer", "BertTokenizerFast") def __init__( self , __A=None , __A=None , **__A ) -> Any: lowerCAmelCase_ :Any = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __A , ) lowerCAmelCase_ :Optional[Any] = kwargs.pop("""feature_extractor""" ) lowerCAmelCase_ :Dict = 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__(__A , __A ) lowerCAmelCase_ :Optional[int] = self.image_processor def __call__( self , __A , __A = None , __A = True , __A = False , __A = None , __A = None , __A = 0 , __A = None , __A = None , __A = None , __A = False , __A = False , __A = False , __A = False , __A = True , __A = None , **__A , ) -> BatchEncoding: lowerCAmelCase_ :int = self.tokenizer( text=__A , add_special_tokens=__A , padding=__A , truncation=__A , max_length=__A , stride=__A , pad_to_multiple_of=__A , return_token_type_ids=__A , return_attention_mask=__A , return_overflowing_tokens=__A , return_special_tokens_mask=__A , return_offsets_mapping=__A , return_length=__A , verbose=__A , return_tensors=__A , **__A , ) # add pixel_values + pixel_mask lowerCAmelCase_ :int = self.image_processor(__A , return_tensors=__A ) encoding.update(__A ) return encoding def __lowerCAmelCase ( self , *__A , **__A ) -> Any: return self.tokenizer.batch_decode(*__A , **__A ) def __lowerCAmelCase ( self , *__A , **__A ) -> Union[str, Any]: return self.tokenizer.decode(*__A , **__A ) @property def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Dict = self.tokenizer.model_input_names lowerCAmelCase_ :Dict = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) ) @property def __lowerCAmelCase ( self ) -> Any: warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __A , ) return self.image_processor_class @property def __lowerCAmelCase ( self ) -> Dict: warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __A , ) return self.image_processor

"""simple docstring""" import copy from collections import OrderedDict from typing import Dict, Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto import CONFIG_MAPPING __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'facebook/detr-resnet-50': 'https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json', # See all DETR models at https://huggingface.co/models?filter=detr } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :str = "detr" UpperCAmelCase_ :str = ["past_key_values"] UpperCAmelCase_ :Tuple = { "hidden_size": "d_model", "num_attention_heads": "encoder_attention_heads", } def __init__( self , __A=True , __A=None , __A=3 , __A=100 , __A=6 , __A=2048 , __A=8 , __A=6 , __A=2048 , __A=8 , __A=0.0 , __A=0.0 , __A=True , __A="relu" , __A=256 , __A=0.1 , __A=0.0 , __A=0.0 , __A=0.0_2 , __A=1.0 , __A=False , __A="sine" , __A="resnet50" , __A=True , __A=False , __A=1 , __A=5 , __A=2 , __A=1 , __A=1 , __A=5 , __A=2 , __A=0.1 , **__A , ) -> List[Any]: if backbone_config is not None and use_timm_backbone: raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`.""" ) if not use_timm_backbone: if backbone_config is None: logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.""" ) lowerCAmelCase_ :int = CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""] ) elif isinstance(__A , __A ): lowerCAmelCase_ :str = backbone_config.get("""model_type""" ) lowerCAmelCase_ :List[Any] = CONFIG_MAPPING[backbone_model_type] lowerCAmelCase_ :Optional[Any] = config_class.from_dict(__A ) # set timm attributes to None lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = None, None, None lowerCAmelCase_ :Tuple = use_timm_backbone lowerCAmelCase_ :Optional[int] = backbone_config lowerCAmelCase_ :Optional[int] = num_channels lowerCAmelCase_ :int = num_queries lowerCAmelCase_ :List[Any] = d_model lowerCAmelCase_ :Optional[int] = encoder_ffn_dim lowerCAmelCase_ :Tuple = encoder_layers lowerCAmelCase_ :int = encoder_attention_heads lowerCAmelCase_ :Optional[Any] = decoder_ffn_dim lowerCAmelCase_ :List[str] = decoder_layers lowerCAmelCase_ :Dict = decoder_attention_heads lowerCAmelCase_ :Dict = dropout lowerCAmelCase_ :Tuple = attention_dropout lowerCAmelCase_ :Union[str, Any] = activation_dropout lowerCAmelCase_ :Any = activation_function lowerCAmelCase_ :List[str] = init_std lowerCAmelCase_ :Optional[int] = init_xavier_std lowerCAmelCase_ :int = encoder_layerdrop lowerCAmelCase_ :Union[str, Any] = decoder_layerdrop lowerCAmelCase_ :List[str] = encoder_layers lowerCAmelCase_ :Union[str, Any] = auxiliary_loss lowerCAmelCase_ :str = position_embedding_type lowerCAmelCase_ :List[Any] = backbone lowerCAmelCase_ :str = use_pretrained_backbone lowerCAmelCase_ :str = dilation # Hungarian matcher lowerCAmelCase_ :List[Any] = class_cost lowerCAmelCase_ :Union[str, Any] = bbox_cost lowerCAmelCase_ :Tuple = giou_cost # Loss coefficients lowerCAmelCase_ :Optional[int] = mask_loss_coefficient lowerCAmelCase_ :Union[str, Any] = dice_loss_coefficient lowerCAmelCase_ :Tuple = bbox_loss_coefficient lowerCAmelCase_ :Tuple = giou_loss_coefficient lowerCAmelCase_ :Dict = eos_coefficient super().__init__(is_encoder_decoder=__A , **__A ) @property def __lowerCAmelCase ( self ) -> int: return self.encoder_attention_heads @property def __lowerCAmelCase ( self ) -> int: return self.d_model @classmethod def __lowerCAmelCase ( cls , __A , **__A ) -> Any: return cls(backbone_config=__A , **__A ) def __lowerCAmelCase ( self ) -> Dict[str, any]: lowerCAmelCase_ :List[str] = copy.deepcopy(self.__dict__ ) if output["backbone_config"] is not None: lowerCAmelCase_ :Dict = self.backbone_config.to_dict() lowerCAmelCase_ :str = self.__class__.model_type return output class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[Any] = version.parse("1.11" ) @property def __lowerCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ("""pixel_mask""", {0: """batch"""}), ] ) @property def __lowerCAmelCase ( self ) -> float: return 1E-5 @property def __lowerCAmelCase ( self ) -> int: return 12

"""simple docstring""" import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def _snake_case ( lowercase__ : Any ) -> int: '''simple docstring''' monkeypatch.setattr("""datasets.utils.deprecation_utils._emitted_deprecation_warnings""" , set() ) @pytest.fixture def _snake_case ( lowercase__ : List[str] ) -> Any: '''simple docstring''' class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> int: lowerCAmelCase_ :Union[str, Any] = metric_id class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :Any = [MetricMock(A__ ) for metric_id in ["accuracy", "mse", "precision", "codeparrot/apps_metric"]] def __lowerCAmelCase ( self ) -> List[str]: return self._metrics monkeypatch.setattr("""datasets.inspect.huggingface_hub""" , HfhMock() ) @pytest.mark.parametrize( """func, args""" , [(load_metric, ("""metrics/mse""",)), (list_metrics, ()), (inspect_metric, ("""metrics/mse""", """tmp_path"""))] ) def _snake_case ( lowercase__ : int , lowercase__ : Dict , lowercase__ : Tuple , lowercase__ : Dict , lowercase__ : Optional[Any] ) -> List[Any]: '''simple docstring''' if "tmp_path" in args: lowerCAmelCase_ :Union[str, Any] = tuple(arg if arg != """tmp_path""" else tmp_path for arg in args ) with pytest.warns(lowercase__ , match="""https://huggingface.co/docs/evaluate""" ): func(*lowercase__ )

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available, is_vision_available, ) __UpperCAmelCase = {'configuration_deit': ['DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeiTConfig', 'DeiTOnnxConfig']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['DeiTFeatureExtractor'] __UpperCAmelCase = ['DeiTImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'DEIT_PRETRAINED_MODEL_ARCHIVE_LIST', 'DeiTForImageClassification', 'DeiTForImageClassificationWithTeacher', 'DeiTForMaskedImageModeling', 'DeiTModel', 'DeiTPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFDeiTForImageClassification', 'TFDeiTForImageClassificationWithTeacher', 'TFDeiTForMaskedImageModeling', 'TFDeiTModel', 'TFDeiTPreTrainedModel', ] if TYPE_CHECKING: from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_deit import DeiTFeatureExtractor from .image_processing_deit import DeiTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_deit import ( DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, DeiTModel, DeiTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_deit import ( TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher, TFDeiTForMaskedImageModeling, TFDeiTModel, TFDeiTPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

"""simple docstring""" import logging import os import sys from dataclasses import dataclass, field from typing import Optional import numpy as np import torch from datasets import load_dataset from torchvision.transforms import Compose, Lambda, Normalize, RandomHorizontalFlip, RandomResizedCrop, ToTensor import transformers from transformers import ( CONFIG_MAPPING, IMAGE_PROCESSOR_MAPPING, MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING, AutoConfig, AutoImageProcessor, AutoModelForMaskedImageModeling, HfArgumentParser, Trainer, TrainingArguments, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version, send_example_telemetry from transformers.utils.versions import require_version __UpperCAmelCase = logging.getLogger(__name__) # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version('4.31.0') require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt') __UpperCAmelCase = list(MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING.keys()) __UpperCAmelCase = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :Optional[str] = field( default="cifar10" , metadata={"help": "Name of a dataset from the datasets package"} ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={"help": "The column name of the images in the files. If not set, will try to use 'image' or 'img'."} , ) UpperCAmelCase_ :Optional[str] = field(default=A__ , metadata={"help": "A folder containing the training data."} ) UpperCAmelCase_ :Optional[str] = field(default=A__ , metadata={"help": "A folder containing the validation data."} ) UpperCAmelCase_ :Optional[float] = field( default=0.1_5 , metadata={"help": "Percent to split off of train for validation."} ) UpperCAmelCase_ :int = field(default=32 , metadata={"help": "The size of the square patches to use for masking."} ) UpperCAmelCase_ :float = field( default=0.6 , metadata={"help": "Percentage of patches to mask."} , ) UpperCAmelCase_ :Optional[int] = field( default=A__ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of training examples to this " "value if set." ) } , ) UpperCAmelCase_ :Optional[int] = field( default=A__ , metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of evaluation examples to this " "value if set." ) } , ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Tuple = {} if self.train_dir is not None: lowerCAmelCase_ :str = self.train_dir if self.validation_dir is not None: lowerCAmelCase_ :str = self.validation_dir lowerCAmelCase_ :Any = data_files if data_files else None @dataclass class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :str = field( default=A__ , metadata={ "help": ( "The model checkpoint for weights initialization. Can be a local path to a pytorch_model.bin or a " "checkpoint identifier on the hub. " "Don't set if you want to train a model from scratch." ) } , ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={"help": "If training from scratch, pass a model type from the list: " + ", ".join(A__ )} , ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={"help": "Pretrained config name or path if not the same as model_name"} ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={ "help": ( "Override some existing default config settings when a model is trained from scratch. Example: " "n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index" ) } , ) UpperCAmelCase_ :Optional[str] = field( default=A__ , metadata={"help": "Where do you want to store (cache) the pretrained models/datasets downloaded from the hub"} , ) UpperCAmelCase_ :str = field( default="main" , metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."} , ) UpperCAmelCase_ :str = field(default=A__ , metadata={"help": "Name or path of preprocessor config."} ) UpperCAmelCase_ :bool = field( default=A__ , metadata={ "help": ( "Will use the token generated when running `huggingface-cli login` (necessary to use this script " "with private models)." ) } , ) UpperCAmelCase_ :Optional[int] = field( default=A__ , metadata={ "help": ( "The size (resolution) of each image. If not specified, will use `image_size` of the configuration." ) } , ) UpperCAmelCase_ :Optional[int] = field( default=A__ , metadata={ "help": ( "The size (resolution) of each patch. If not specified, will use `patch_size` of the configuration." ) } , ) UpperCAmelCase_ :Optional[int] = field( default=A__ , metadata={"help": "Stride to use for the encoder."} , ) class _SCREAMING_SNAKE_CASE : def __init__( self , __A=192 , __A=32 , __A=4 , __A=0.6 ) -> List[str]: lowerCAmelCase_ :List[str] = input_size lowerCAmelCase_ :Optional[Any] = mask_patch_size lowerCAmelCase_ :Tuple = model_patch_size lowerCAmelCase_ :Optional[int] = mask_ratio if self.input_size % self.mask_patch_size != 0: raise ValueError("""Input size must be divisible by mask patch size""" ) if self.mask_patch_size % self.model_patch_size != 0: raise ValueError("""Mask patch size must be divisible by model patch size""" ) lowerCAmelCase_ :Any = self.input_size // self.mask_patch_size lowerCAmelCase_ :Tuple = self.mask_patch_size // self.model_patch_size lowerCAmelCase_ :Union[str, Any] = self.rand_size**2 lowerCAmelCase_ :str = int(np.ceil(self.token_count * self.mask_ratio ) ) def __call__( self ) -> str: lowerCAmelCase_ :Optional[Any] = np.random.permutation(self.token_count )[: self.mask_count] lowerCAmelCase_ :Optional[Any] = np.zeros(self.token_count , dtype=__A ) lowerCAmelCase_ :Optional[Any] = 1 lowerCAmelCase_ :Any = mask.reshape((self.rand_size, self.rand_size) ) lowerCAmelCase_ :Union[str, Any] = mask.repeat(self.scale , axis=0 ).repeat(self.scale , axis=1 ) return torch.tensor(mask.flatten() ) def _snake_case ( lowercase__ : Dict ) -> List[str]: '''simple docstring''' lowerCAmelCase_ :int = torch.stack([example["""pixel_values"""] for example in examples] ) lowerCAmelCase_ :str = torch.stack([example["""mask"""] for example in examples] ) return {"pixel_values": pixel_values, "bool_masked_pos": mask} def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :List[Any] = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Tuple = parser.parse_args_into_dataclasses() # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The # information sent is the one passed as arguments along with your Python/PyTorch versions. send_example_telemetry("""run_mim""" , lowercase__ , lowercase__ ) # Setup logging logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , ) if training_args.should_log: # The default of training_args.log_level is passive, so we set log level at info here to have that default. transformers.utils.logging.set_verbosity_info() lowerCAmelCase_ :str = training_args.get_process_log_level() logger.setLevel(lowercase__ ) transformers.utils.logging.set_verbosity(lowercase__ ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( f"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}""" + f"""distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}""" ) logger.info(f"""Training/evaluation parameters {training_args}""" ) # Detecting last checkpoint. lowerCAmelCase_ :Any = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: lowerCAmelCase_ :int = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f"""Output directory ({training_args.output_dir}) already exists and is not empty. """ """Use --overwrite_output_dir to overcome.""" ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( f"""Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change """ """the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" ) # Initialize our dataset. lowerCAmelCase_ :List[Any] = load_dataset( data_args.dataset_name , data_args.dataset_config_name , data_files=data_args.data_files , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , ) # If we don't have a validation split, split off a percentage of train as validation. lowerCAmelCase_ :str = None if """validation""" in ds.keys() else data_args.train_val_split if isinstance(data_args.train_val_split , lowercase__ ) and data_args.train_val_split > 0.0: lowerCAmelCase_ :Optional[int] = ds["""train"""].train_test_split(data_args.train_val_split ) lowerCAmelCase_ :Union[str, Any] = split["""train"""] lowerCAmelCase_ :Any = split["""test"""] # Create config # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. lowerCAmelCase_ :Any = { """cache_dir""": model_args.cache_dir, """revision""": model_args.model_revision, """use_auth_token""": True if model_args.use_auth_token else None, } if model_args.config_name_or_path: lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(model_args.config_name_or_path , **lowercase__ ) elif model_args.model_name_or_path: lowerCAmelCase_ :List[Any] = AutoConfig.from_pretrained(model_args.model_name_or_path , **lowercase__ ) else: lowerCAmelCase_ :Union[str, Any] = CONFIG_MAPPING[model_args.model_type]() logger.warning("""You are instantiating a new config instance from scratch.""" ) if model_args.config_overrides is not None: logger.info(f"""Overriding config: {model_args.config_overrides}""" ) config.update_from_string(model_args.config_overrides ) logger.info(f"""New config: {config}""" ) # make sure the decoder_type is "simmim" (only relevant for BEiT) if hasattr(lowercase__ , """decoder_type""" ): lowerCAmelCase_ :Optional[Any] = """simmim""" # adapt config lowerCAmelCase_ :Optional[int] = model_args.image_size if model_args.image_size is not None else config.image_size lowerCAmelCase_ :List[Any] = model_args.patch_size if model_args.patch_size is not None else config.patch_size lowerCAmelCase_ :str = ( model_args.encoder_stride if model_args.encoder_stride is not None else config.encoder_stride ) config.update( { """image_size""": model_args.image_size, """patch_size""": model_args.patch_size, """encoder_stride""": model_args.encoder_stride, } ) # create image processor if model_args.image_processor_name: lowerCAmelCase_ :Optional[int] = AutoImageProcessor.from_pretrained(model_args.image_processor_name , **lowercase__ ) elif model_args.model_name_or_path: lowerCAmelCase_ :int = AutoImageProcessor.from_pretrained(model_args.model_name_or_path , **lowercase__ ) else: lowerCAmelCase_ :Union[str, Any] = { conf.model_type: image_processor_class for conf, image_processor_class in IMAGE_PROCESSOR_MAPPING.items() } lowerCAmelCase_ :Dict = IMAGE_PROCESSOR_TYPES[model_args.model_type]() # create model if model_args.model_name_or_path: lowerCAmelCase_ :Dict = AutoModelForMaskedImageModeling.from_pretrained( model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=lowercase__ , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) else: logger.info("""Training new model from scratch""" ) lowerCAmelCase_ :List[str] = AutoModelForMaskedImageModeling.from_config(lowercase__ ) if training_args.do_train: lowerCAmelCase_ :Dict = ds["""train"""].column_names else: lowerCAmelCase_ :str = ds["""validation"""].column_names if data_args.image_column_name is not None: lowerCAmelCase_ :Optional[int] = data_args.image_column_name elif "image" in column_names: lowerCAmelCase_ :str = """image""" elif "img" in column_names: lowerCAmelCase_ :Dict = """img""" else: lowerCAmelCase_ :List[Any] = column_names[0] # transformations as done in original SimMIM paper # source: https://github.com/microsoft/SimMIM/blob/main/data/data_simmim.py lowerCAmelCase_ :Union[str, Any] = Compose( [ Lambda(lambda lowercase__ : img.convert("""RGB""" ) if img.mode != "RGB" else img ), RandomResizedCrop(model_args.image_size , scale=(0.67, 1.0) , ratio=(3.0 / 4.0, 4.0 / 3.0) ), RandomHorizontalFlip(), ToTensor(), Normalize(mean=image_processor.image_mean , std=image_processor.image_std ), ] ) # create mask generator lowerCAmelCase_ :Union[str, Any] = MaskGenerator( input_size=model_args.image_size , mask_patch_size=data_args.mask_patch_size , model_patch_size=model_args.patch_size , mask_ratio=data_args.mask_ratio , ) def preprocess_images(lowercase__ : Any ): lowerCAmelCase_ :Any = [transforms(lowercase__ ) for image in examples[image_column_name]] lowerCAmelCase_ :Optional[Any] = [mask_generator() for i in range(len(examples[image_column_name] ) )] return examples if training_args.do_train: if "train" not in ds: raise ValueError("""--do_train requires a train dataset""" ) if data_args.max_train_samples is not None: lowerCAmelCase_ :str = ds["""train"""].shuffle(seed=training_args.seed ).select(range(data_args.max_train_samples ) ) # Set the training transforms ds["train"].set_transform(lowercase__ ) if training_args.do_eval: if "validation" not in ds: raise ValueError("""--do_eval requires a validation dataset""" ) if data_args.max_eval_samples is not None: lowerCAmelCase_ :Dict = ( ds["""validation"""].shuffle(seed=training_args.seed ).select(range(data_args.max_eval_samples ) ) ) # Set the validation transforms ds["validation"].set_transform(lowercase__ ) # Initialize our trainer lowerCAmelCase_ :List[str] = Trainer( model=lowercase__ , args=lowercase__ , train_dataset=ds["""train"""] if training_args.do_train else None , eval_dataset=ds["""validation"""] if training_args.do_eval else None , tokenizer=lowercase__ , data_collator=lowercase__ , ) # Training if training_args.do_train: lowerCAmelCase_ :Tuple = None if training_args.resume_from_checkpoint is not None: lowerCAmelCase_ :List[Any] = training_args.resume_from_checkpoint elif last_checkpoint is not None: lowerCAmelCase_ :Optional[int] = last_checkpoint lowerCAmelCase_ :Dict = trainer.train(resume_from_checkpoint=lowercase__ ) trainer.save_model() trainer.log_metrics("""train""" , train_result.metrics ) trainer.save_metrics("""train""" , train_result.metrics ) trainer.save_state() # Evaluation if training_args.do_eval: lowerCAmelCase_ :List[Any] = trainer.evaluate() trainer.log_metrics("""eval""" , lowercase__ ) trainer.save_metrics("""eval""" , lowercase__ ) # Write model card and (optionally) push to hub lowerCAmelCase_ :Dict = { """finetuned_from""": model_args.model_name_or_path, """tasks""": """masked-image-modeling""", """dataset""": data_args.dataset_name, """tags""": ["""masked-image-modeling"""], } if training_args.push_to_hub: trainer.push_to_hub(**lowercase__ ) else: trainer.create_model_card(**lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __UpperCAmelCase = { 'configuration_squeezebert': [ 'SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SqueezeBertConfig', 'SqueezeBertOnnxConfig', ], 'tokenization_squeezebert': ['SqueezeBertTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['SqueezeBertTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'SqueezeBertForMaskedLM', 'SqueezeBertForMultipleChoice', 'SqueezeBertForQuestionAnswering', 'SqueezeBertForSequenceClassification', 'SqueezeBertForTokenClassification', 'SqueezeBertModel', 'SqueezeBertModule', 'SqueezeBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_squeezebert import ( SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, SqueezeBertConfig, SqueezeBertOnnxConfig, ) from .tokenization_squeezebert import SqueezeBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_squeezebert import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, SqueezeBertModule, SqueezeBertPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

"""simple docstring""" import os import tempfile import unittest from transformers import NezhaConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, NezhaModel, ) from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=13 , __A=7 , __A=True , __A=True , __A=True , __A=True , __A=99 , __A=32 , __A=5 , __A=4 , __A=37 , __A="gelu" , __A=0.1 , __A=0.1 , __A=128 , __A=32 , __A=16 , __A=2 , __A=0.0_2 , __A=3 , __A=4 , __A=None , ) -> str: lowerCAmelCase_ :Union[str, Any] = parent lowerCAmelCase_ :str = batch_size lowerCAmelCase_ :Optional[Any] = seq_length lowerCAmelCase_ :Union[str, Any] = is_training lowerCAmelCase_ :Any = use_input_mask lowerCAmelCase_ :Optional[int] = use_token_type_ids lowerCAmelCase_ :List[str] = use_labels lowerCAmelCase_ :Any = vocab_size lowerCAmelCase_ :Union[str, Any] = hidden_size lowerCAmelCase_ :Tuple = num_hidden_layers lowerCAmelCase_ :Optional[int] = num_attention_heads lowerCAmelCase_ :Tuple = intermediate_size lowerCAmelCase_ :Tuple = hidden_act lowerCAmelCase_ :List[str] = hidden_dropout_prob lowerCAmelCase_ :Optional[int] = attention_probs_dropout_prob lowerCAmelCase_ :Optional[int] = max_position_embeddings lowerCAmelCase_ :Tuple = type_vocab_size lowerCAmelCase_ :Union[str, Any] = type_sequence_label_size lowerCAmelCase_ :int = initializer_range lowerCAmelCase_ :str = num_labels lowerCAmelCase_ :List[str] = num_choices lowerCAmelCase_ :int = scope def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :str = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCAmelCase_ :Dict = None if self.use_input_mask: lowerCAmelCase_ :Optional[int] = random_attention_mask([self.batch_size, self.seq_length] ) lowerCAmelCase_ :Union[str, Any] = None if self.use_token_type_ids: lowerCAmelCase_ :Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCAmelCase_ :List[Any] = None lowerCAmelCase_ :List[Any] = None lowerCAmelCase_ :str = None if self.use_labels: lowerCAmelCase_ :Optional[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCAmelCase_ :List[str] = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCAmelCase_ :Any = ids_tensor([self.batch_size] , self.num_choices ) lowerCAmelCase_ :List[str] = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def __lowerCAmelCase ( self ) -> Optional[int]: return NezhaConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=__A , initializer_range=self.initializer_range , ) def __lowerCAmelCase ( self ) -> str: ( ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ) :Optional[Any] = self.prepare_config_and_inputs() lowerCAmelCase_ :List[Any] = True lowerCAmelCase_ :Optional[Any] = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCAmelCase_ :Dict = 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 __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> List[str]: lowerCAmelCase_ :Tuple = NezhaModel(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :str = model(__A , attention_mask=__A , token_type_ids=__A ) lowerCAmelCase_ :int = model(__A , token_type_ids=__A ) lowerCAmelCase_ :Dict = model(__A ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A , __A , __A , ) -> Tuple: lowerCAmelCase_ :Optional[Any] = True lowerCAmelCase_ :int = NezhaModel(__A ) model.to(__A ) model.eval() lowerCAmelCase_ :str = model( __A , attention_mask=__A , token_type_ids=__A , encoder_hidden_states=__A , encoder_attention_mask=__A , ) lowerCAmelCase_ :Tuple = model( __A , attention_mask=__A , token_type_ids=__A , encoder_hidden_states=__A , ) lowerCAmelCase_ :str = model(__A , attention_mask=__A , token_type_ids=__A ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> int: lowerCAmelCase_ :List[Any] = NezhaForMaskedLM(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :List[str] = model(__A , attention_mask=__A , token_type_ids=__A , labels=__A ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> Optional[int]: lowerCAmelCase_ :Any = NezhaForNextSentencePrediction(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :str = model( __A , attention_mask=__A , token_type_ids=__A , labels=__A , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> Any: lowerCAmelCase_ :Dict = NezhaForPreTraining(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :str = model( __A , attention_mask=__A , token_type_ids=__A , labels=__A , next_sentence_label=__A , ) self.parent.assertEqual(result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> List[Any]: lowerCAmelCase_ :Tuple = NezhaForQuestionAnswering(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :Tuple = model( __A , attention_mask=__A , token_type_ids=__A , start_positions=__A , end_positions=__A , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> Any: lowerCAmelCase_ :Union[str, Any] = self.num_labels lowerCAmelCase_ :Tuple = NezhaForSequenceClassification(__A ) model.to(__A ) model.eval() lowerCAmelCase_ :List[Any] = model(__A , attention_mask=__A , token_type_ids=__A , labels=__A ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> List[Any]: lowerCAmelCase_ :Tuple = self.num_labels lowerCAmelCase_ :List[str] = NezhaForTokenClassification(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :int = model(__A , attention_mask=__A , token_type_ids=__A , labels=__A ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def __lowerCAmelCase ( self , __A , __A , __A , __A , __A , __A , __A ) -> Dict: lowerCAmelCase_ :Dict = self.num_choices lowerCAmelCase_ :Dict = NezhaForMultipleChoice(config=__A ) model.to(__A ) model.eval() lowerCAmelCase_ :Union[str, Any] = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCAmelCase_ :List[Any] = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCAmelCase_ :Any = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() lowerCAmelCase_ :Dict = model( __A , attention_mask=__A , token_type_ids=__A , labels=__A , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :List[Any] = self.prepare_config_and_inputs() ( ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ) :int = config_and_inputs lowerCAmelCase_ :List[Any] = {"""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__ , A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :Union[str, Any] = ( ( NezhaModel, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, ) if is_torch_available() else () ) UpperCAmelCase_ :Optional[int] = ( { "feature-extraction": NezhaModel, "fill-mask": NezhaForMaskedLM, "question-answering": NezhaForQuestionAnswering, "text-classification": NezhaForSequenceClassification, "token-classification": NezhaForTokenClassification, "zero-shot": NezhaForSequenceClassification, } if is_torch_available() else {} ) UpperCAmelCase_ :Optional[Any] = True def __lowerCAmelCase ( self , __A , __A , __A=False ) -> Optional[Any]: lowerCAmelCase_ :str = super()._prepare_for_class(__A , __A , return_labels=__A ) if return_labels: if model_class in get_values(__A ): lowerCAmelCase_ :Dict = torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=__A ) lowerCAmelCase_ :Optional[int] = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=__A ) return inputs_dict def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :List[Any] = NezhaModelTester(self ) lowerCAmelCase_ :int = ConfigTester(self , config_class=__A , hidden_size=37 ) def __lowerCAmelCase ( self ) -> str: self.config_tester.run_common_tests() def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Optional[Any] = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*__A ) def __lowerCAmelCase ( self ) -> str: # This regression test was failing with PyTorch < 1.3 ( ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ( lowerCAmelCase_ ) , ) :Tuple = self.model_tester.prepare_config_and_inputs_for_decoder() lowerCAmelCase_ :Any = None self.model_tester.create_and_check_model_as_decoder( __A , __A , __A , __A , __A , __A , __A , __A , __A , ) def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*__A ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*__A ) def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_next_sequence_prediction(*__A ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*__A ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*__A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*__A ) def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*__A ) @slow def __lowerCAmelCase ( self ) -> str: for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCAmelCase_ :Tuple = NezhaModel.from_pretrained(__A ) self.assertIsNotNone(__A ) @slow @require_torch_gpu def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ , lowerCAmelCase_ :int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # NezhaForMultipleChoice behaves incorrectly in JIT environments. if model_class == NezhaForMultipleChoice: return lowerCAmelCase_ :int = True lowerCAmelCase_ :Optional[int] = model_class(config=__A ) lowerCAmelCase_ :Any = self._prepare_for_class(__A , __A ) lowerCAmelCase_ :Optional[int] = torch.jit.trace( __A , (inputs_dict["""input_ids"""].to("""cpu""" ), inputs_dict["""attention_mask"""].to("""cpu""" )) ) with tempfile.TemporaryDirectory() as tmp: torch.jit.save(__A , os.path.join(__A , """bert.pt""" ) ) lowerCAmelCase_ :Union[str, Any] = torch.jit.load(os.path.join(__A , """bert.pt""" ) , map_location=__A ) loaded(inputs_dict["""input_ids"""].to(__A ) , inputs_dict["""attention_mask"""].to(__A ) ) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Optional[int] = NezhaModel.from_pretrained("""sijunhe/nezha-cn-base""" ) lowerCAmelCase_ :List[str] = torch.tensor([[0, 1, 2, 3, 4, 5]] ) lowerCAmelCase_ :Union[str, Any] = torch.tensor([[0, 1, 1, 1, 1, 1]] ) with torch.no_grad(): lowerCAmelCase_ :Dict = model(__A , attention_mask=__A )[0] lowerCAmelCase_ :int = torch.Size((1, 6, 768) ) self.assertEqual(output.shape , __A ) lowerCAmelCase_ :Optional[Any] = torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]] ) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , __A , atol=1E-4 ) ) @slow def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Dict = NezhaForMaskedLM.from_pretrained("""sijunhe/nezha-cn-base""" ) lowerCAmelCase_ :Tuple = torch.tensor([[0, 1, 2, 3, 4, 5]] ) lowerCAmelCase_ :Optional[int] = torch.tensor([[1, 1, 1, 1, 1, 1]] ) with torch.no_grad(): lowerCAmelCase_ :Tuple = model(__A , attention_mask=__A )[0] lowerCAmelCase_ :Dict = torch.Size((1, 6, 2_1128) ) self.assertEqual(output.shape , __A ) lowerCAmelCase_ :str = torch.tensor( [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]] ) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , __A , atol=1E-4 ) )

"""simple docstring""" __UpperCAmelCase = 2_56 # Modulus to hash a string __UpperCAmelCase = 1_00_00_03 def _snake_case ( lowercase__ : str , lowercase__ : str ) -> bool: '''simple docstring''' lowerCAmelCase_ :Tuple = len(lowercase__ ) lowerCAmelCase_ :List[str] = len(lowercase__ ) if p_len > t_len: return False lowerCAmelCase_ :List[str] = 0 lowerCAmelCase_ :Optional[int] = 0 lowerCAmelCase_ :Any = 1 # Calculating the hash of pattern and substring of text for i in range(lowercase__ ): lowerCAmelCase_ :int = (ord(pattern[i] ) + p_hash * alphabet_size) % modulus lowerCAmelCase_ :Any = (ord(text[i] ) + text_hash * alphabet_size) % modulus if i == p_len - 1: continue lowerCAmelCase_ :Optional[Any] = (modulus_power * alphabet_size) % modulus for i in range(0 , t_len - p_len + 1 ): if text_hash == p_hash and text[i : i + p_len] == pattern: return True if i == t_len - p_len: continue # Calculate the https://en.wikipedia.org/wiki/Rolling_hash lowerCAmelCase_ :Any = ( (text_hash - ord(text[i] ) * modulus_power) * alphabet_size + ord(text[i + p_len] ) ) % modulus return False def _snake_case ( ) -> None: '''simple docstring''' lowerCAmelCase_ :int = """abc1abc12""" lowerCAmelCase_ :Dict = """alskfjaldsabc1abc1abc12k23adsfabcabc""" lowerCAmelCase_ :int = """alskfjaldsk23adsfabcabc""" assert rabin_karp(lowercase__ , lowercase__ ) and not rabin_karp(lowercase__ , lowercase__ ) # Test 2) lowerCAmelCase_ :Dict = """ABABX""" lowerCAmelCase_ :int = """ABABZABABYABABX""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 3) lowerCAmelCase_ :Union[str, Any] = """AAAB""" lowerCAmelCase_ :List[str] = """ABAAAAAB""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 4) lowerCAmelCase_ :Dict = """abcdabcy""" lowerCAmelCase_ :Union[str, Any] = """abcxabcdabxabcdabcdabcy""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 5) lowerCAmelCase_ :Optional[int] = """Lü""" lowerCAmelCase_ :Optional[int] = """Lüsai""" assert rabin_karp(lowercase__ , lowercase__ ) lowerCAmelCase_ :Optional[int] = """Lue""" assert not rabin_karp(lowercase__ , lowercase__ ) print("""Success.""" ) if __name__ == "__main__": test_rabin_karp()

"""simple docstring""" import importlib import os from dataclasses import dataclass from enum import Enum from typing import Any, Dict, Optional, Union import torch from ..utils import BaseOutput __UpperCAmelCase = 'scheduler_config.json' class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Tuple = 1 UpperCAmelCase_ :str = 2 UpperCAmelCase_ :Optional[int] = 3 UpperCAmelCase_ :Optional[Any] = 4 UpperCAmelCase_ :Dict = 5 UpperCAmelCase_ :Optional[Any] = 6 UpperCAmelCase_ :Optional[Any] = 7 UpperCAmelCase_ :Optional[int] = 8 UpperCAmelCase_ :Optional[Any] = 9 UpperCAmelCase_ :List[Any] = 10 UpperCAmelCase_ :List[Any] = 11 UpperCAmelCase_ :Dict = 12 UpperCAmelCase_ :Tuple = 13 UpperCAmelCase_ :int = 14 @dataclass class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :torch.FloatTensor class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :Any = SCHEDULER_CONFIG_NAME UpperCAmelCase_ :Optional[int] = [] UpperCAmelCase_ :Optional[Any] = True @classmethod def __lowerCAmelCase ( cls , __A = None , __A = None , __A=False , **__A , ) -> int: lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = cls.load_config( pretrained_model_name_or_path=__A , subfolder=__A , return_unused_kwargs=__A , return_commit_hash=__A , **__A , ) return cls.from_config(__A , return_unused_kwargs=__A , **__A ) def __lowerCAmelCase ( self , __A , __A = False , **__A ) -> int: self.save_config(save_directory=__A , push_to_hub=__A , **__A ) @property def __lowerCAmelCase ( self ) -> Dict: return self._get_compatibles() @classmethod def __lowerCAmelCase ( cls ) -> Tuple: lowerCAmelCase_ :str = list(set([cls.__name__] + cls._compatibles ) ) lowerCAmelCase_ :Dict = importlib.import_module(__name__.split(""".""" )[0] ) lowerCAmelCase_ :int = [ getattr(__A , __A ) for c in compatible_classes_str if hasattr(__A , __A ) ] return compatible_classes

"""simple docstring""" import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.local_sgd import LocalSGD ######################################################################## # This is a fully working simple example to use Accelerate # with LocalSGD, which is a method to synchronize model # parameters every K batches. It is different, but complementary # to gradient accumulation. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 ) -> str: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained("""bert-base-cased""" ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : int ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :Optional[int] = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): lowerCAmelCase_ :Optional[Any] = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :str = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Dict ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCAmelCase_ :int = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCAmelCase_ :List[Any] = 1_6 elif accelerator.mixed_precision != "no": lowerCAmelCase_ :List[str] = 8 else: lowerCAmelCase_ :Optional[int] = None return tokenizer.pad( lowercase__ , padding="""longest""" , max_length=lowercase__ , pad_to_multiple_of=lowercase__ , return_tensors="""pt""" , ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[Any] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :List[Any] = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS', None) == "1": from accelerate.test_utils.training import mocked_dataloaders __UpperCAmelCase = mocked_dataloaders # noqa: F811 def _snake_case ( lowercase__ : List[Any] , lowercase__ : Optional[int] ) -> Optional[Any]: '''simple docstring''' if os.environ.get("""TESTING_MOCKED_DATALOADERS""" , lowercase__ ) == "1": lowerCAmelCase_ :Optional[Any] = 2 # New Code # lowerCAmelCase_ :List[str] = int(args.gradient_accumulation_steps ) lowerCAmelCase_ :int = int(args.local_sgd_steps ) # Initialize accelerator lowerCAmelCase_ :str = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=lowercase__ ) if accelerator.distributed_type not in [DistributedType.NO, DistributedType.MULTI_CPU, DistributedType.MULTI_GPU]: raise NotImplementedError("""LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)""" ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :int = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Union[str, Any] = evaluate.load("""glue""" , """mrpc""" ) set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = get_dataloaders(lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :Optional[int] = AutoModelForSequenceClassification.from_pretrained("""bert-base-cased""" , return_dict=lowercase__ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). lowerCAmelCase_ :Union[str, Any] = model.to(accelerator.device ) # Instantiate optimizer lowerCAmelCase_ :Optional[Any] = AdamW(params=model.parameters() , lr=lowercase__ ) # Instantiate scheduler lowerCAmelCase_ :Union[str, Any] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowercase__ ) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Now we train the model for epoch in range(lowercase__ ): model.train() with LocalSGD( accelerator=lowercase__ , model=lowercase__ , local_sgd_steps=lowercase__ , enabled=local_sgd_steps is not None ) as local_sgd: for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(lowercase__ ): lowerCAmelCase_ :str = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = output.loss accelerator.backward(lowercase__ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() # LocalSGD-specific line local_sgd.step() model.eval() for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.gather_for_metrics((predictions, batch["""labels"""]) ) metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Any = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :str = argparse.ArgumentParser(description="""Simple example of training script.""" ) parser.add_argument( """--mixed_precision""" , type=lowercase__ , default=lowercase__ , choices=["""no""", """fp16""", """bf16""", """fp8"""] , help="""Whether to use mixed precision. Choose""" """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.""" """and an Nvidia Ampere GPU.""" , ) # New Code # parser.add_argument( """--gradient_accumulation_steps""" , type=lowercase__ , default=1 , help="""The number of minibatches to be ran before gradients are accumulated.""" , ) parser.add_argument( """--local_sgd_steps""" , type=lowercase__ , default=8 , help="""Number of local SGD steps or None to disable local SGD""" ) parser.add_argument("""--cpu""" , action="""store_true""" , help="""If passed, will train on the CPU.""" ) lowerCAmelCase_ :Optional[Any] = parser.parse_args() lowerCAmelCase_ :Tuple = {"""lr""": 2E-5, """num_epochs""": 3, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" import json import sys import tempfile import unittest from pathlib import Path import transformers from transformers import ( CONFIG_MAPPING, FEATURE_EXTRACTOR_MAPPING, AutoConfig, AutoFeatureExtractor, WavaVecaConfig, WavaVecaFeatureExtractor, ) from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils')) from test_module.custom_configuration import CustomConfig # noqa E402 from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 __UpperCAmelCase = get_tests_dir('fixtures') __UpperCAmelCase = get_tests_dir('fixtures/dummy_feature_extractor_config.json') __UpperCAmelCase = get_tests_dir('fixtures/dummy-config.json') class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = 0 def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :List[str] = AutoFeatureExtractor.from_pretrained("""facebook/wav2vec2-base-960h""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :List[Any] = AutoFeatureExtractor.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> int: with tempfile.TemporaryDirectory() as tmpdirname: lowerCAmelCase_ :Optional[int] = WavaVecaConfig() # remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained(__A ).to_dict() config_dict.pop("""feature_extractor_type""" ) lowerCAmelCase_ :Optional[Any] = WavaVecaFeatureExtractor(**__A ) # save in new folder model_config.save_pretrained(__A ) config.save_pretrained(__A ) lowerCAmelCase_ :Dict = AutoFeatureExtractor.from_pretrained(__A ) # make sure private variable is not incorrectly saved lowerCAmelCase_ :Union[str, Any] = json.loads(config.to_json_string() ) self.assertTrue("""_processor_class""" not in dict_as_saved ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :List[Any] = AutoFeatureExtractor.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Tuple: with self.assertRaisesRegex( __A , """bert-base is not a local folder and is not a valid model identifier""" ): lowerCAmelCase_ :Optional[int] = AutoFeatureExtractor.from_pretrained("""bert-base""" ) def __lowerCAmelCase ( self ) -> Optional[int]: with self.assertRaisesRegex( __A , r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ): lowerCAmelCase_ :int = AutoFeatureExtractor.from_pretrained(__A , revision="""aaaaaa""" ) def __lowerCAmelCase ( self ) -> Any: with self.assertRaisesRegex( __A , """hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.""" , ): lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained("""hf-internal-testing/config-no-model""" ) def __lowerCAmelCase ( self ) -> Tuple: # If remote code is not set, we will time out when asking whether to load the model. with self.assertRaises(__A ): lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(__A ): lowerCAmelCase_ :Any = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" , trust_remote_code=__A ) lowerCAmelCase_ :Dict = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" , trust_remote_code=__A ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) # Test feature extractor can be reloaded. with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained(__A ) lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained(__A , trust_remote_code=__A ) self.assertEqual(reloaded_feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) def __lowerCAmelCase ( self ) -> Optional[int]: try: AutoConfig.register("""custom""" , __A ) AutoFeatureExtractor.register(__A , __A ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(__A ): AutoFeatureExtractor.register(__A , __A ) # Now that the config is registered, it can be used as any other config with the auto-API lowerCAmelCase_ :List[str] = CustomFeatureExtractor.from_pretrained(__A ) with tempfile.TemporaryDirectory() as tmp_dir: feature_extractor.save_pretrained(__A ) lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained(__A ) self.assertIsInstance(__A , __A ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] def __lowerCAmelCase ( self ) -> Union[str, Any]: class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[str] = True try: AutoConfig.register("""custom""" , __A ) AutoFeatureExtractor.register(__A , __A ) # If remote code is not set, the default is to use local lowerCAmelCase_ :Union[str, Any] = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) self.assertTrue(feature_extractor.is_local ) # If remote code is disabled, we load the local one. lowerCAmelCase_ :Tuple = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" , trust_remote_code=__A ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) self.assertTrue(feature_extractor.is_local ) # If remote is enabled, we load from the Hub lowerCAmelCase_ :Union[str, Any] = AutoFeatureExtractor.from_pretrained( """hf-internal-testing/test_dynamic_feature_extractor""" , trust_remote_code=__A ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) self.assertTrue(not hasattr(__A , """is_local""" ) ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]

"""simple docstring""" import argparse import json import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 , lowercase__ : str = "bert-base-cased" ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained(lowercase__ ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : List[str] ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :str = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset lowerCAmelCase_ :str = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , load_from_cache_file=lowercase__ ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :List[str] = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Union[str, Any] ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(lowercase__ , padding="""max_length""" , max_length=1_2_8 , return_tensors="""pt""" ) return tokenizer.pad(lowercase__ , padding="""longest""" , return_tensors="""pt""" ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[int] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :Any = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : Union[str, Any] , lowercase__ : Tuple , lowercase__ : int ) -> List[str]: '''simple docstring''' model.eval() lowerCAmelCase_ :Dict = 0 for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) # It is slightly faster to call this once, than multiple times lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.gather( (predictions, batch["""labels"""]) ) # If we are in a multiprocess environment, the last batch has duplicates if accelerator.use_distributed: if step == len(lowercase__ ) - 1: lowerCAmelCase_ :Optional[Any] = predictions[: len(eval_dataloader.dataset ) - samples_seen] lowerCAmelCase_ :Any = references[: len(eval_dataloader.dataset ) - samples_seen] else: samples_seen += references.shape[0] metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Tuple = metric.compute() return eval_metric["accuracy"] def _snake_case ( lowercase__ : str , lowercase__ : List[str] ) -> Any: '''simple docstring''' lowerCAmelCase_ :Optional[int] = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :Optional[int] = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Optional[Any] = args.model_name_or_path set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Dict = get_dataloaders(lowercase__ , lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :str = AutoModelForSequenceClassification.from_pretrained(lowercase__ , return_dict=lowercase__ ) # Instantiate optimizer lowerCAmelCase_ :List[str] = ( AdamW if accelerator.state.deepspeed_plugin is None or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) lowerCAmelCase_ :str = optimizer_cls(params=model.parameters() , lr=lowercase__ ) if accelerator.state.deepspeed_plugin is not None: lowerCAmelCase_ :Union[str, Any] = accelerator.state.deepspeed_plugin.deepspeed_config[ """gradient_accumulation_steps""" ] else: lowerCAmelCase_ :Any = 1 lowerCAmelCase_ :str = (len(lowercase__ ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): lowerCAmelCase_ :List[str] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=0 , num_training_steps=lowercase__ , ) else: lowerCAmelCase_ :int = DummyScheduler(lowercase__ , total_num_steps=lowercase__ , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # We need to keep track of how many total steps we have iterated over lowerCAmelCase_ :List[str] = 0 # We also need to keep track of the stating epoch so files are named properly lowerCAmelCase_ :List[Any] = 0 lowerCAmelCase_ :str = evaluate.load("""glue""" , """mrpc""" ) lowerCAmelCase_ :Optional[Any] = num_epochs if args.partial_train_epoch is not None: lowerCAmelCase_ :Dict = args.partial_train_epoch if args.resume_from_checkpoint: accelerator.load_state(args.resume_from_checkpoint ) lowerCAmelCase_ :Optional[Any] = args.resume_from_checkpoint.split("""epoch_""" )[1] lowerCAmelCase_ :int = """""" for char in epoch_string: if char.isdigit(): state_epoch_num += char else: break lowerCAmelCase_ :Union[str, Any] = int(lowercase__ ) + 1 lowerCAmelCase_ :Optional[int] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) accelerator.print("""resumed checkpoint performance:""" , lowercase__ ) accelerator.print("""resumed checkpoint's scheduler's lr:""" , lr_scheduler.get_lr()[0] ) accelerator.print("""resumed optimizers's lr:""" , optimizer.param_groups[0]["""lr"""] ) with open(os.path.join(args.output_dir , f"""state_{starting_epoch-1}.json""" ) , """r""" ) as f: lowerCAmelCase_ :List[str] = json.load(lowercase__ ) assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed" assert ( resumed_state["lr"] == lr_scheduler.get_lr()[0] ), "Scheduler learning rate mismatch, loading from checkpoint failed" assert ( resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"] ), "Optimizer learning rate mismatch, loading from checkpoint failed" assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed" return # Now we train the model lowerCAmelCase_ :List[Any] = {} for epoch in range(lowercase__ , lowercase__ ): model.train() for step, batch in enumerate(lowercase__ ): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Dict = outputs.loss lowerCAmelCase_ :int = loss / gradient_accumulation_steps accelerator.backward(lowercase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 lowerCAmelCase_ :List[str] = f"""epoch_{epoch}""" lowerCAmelCase_ :Any = os.path.join(args.output_dir , lowercase__ ) accelerator.save_state(lowercase__ ) lowerCAmelCase_ :List[Any] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) lowerCAmelCase_ :Union[str, Any] = accuracy lowerCAmelCase_ :Any = lr_scheduler.get_lr()[0] lowerCAmelCase_ :str = optimizer.param_groups[0]["""lr"""] lowerCAmelCase_ :List[Any] = epoch lowerCAmelCase_ :Tuple = overall_step accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , f"""state_{epoch}.json""" ) , """w""" ) as f: json.dump(lowercase__ , lowercase__ ) def _snake_case ( ) -> int: '''simple docstring''' lowerCAmelCase_ :List[Any] = argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage.""" ) parser.add_argument( """--model_name_or_path""" , type=lowercase__ , default="""bert-base-cased""" , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=lowercase__ , ) parser.add_argument( """--output_dir""" , type=lowercase__ , default=""".""" , help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory.""" , ) parser.add_argument( """--resume_from_checkpoint""" , type=lowercase__ , default=lowercase__ , help="""If the training should continue from a checkpoint folder.""" , ) parser.add_argument( """--partial_train_epoch""" , type=lowercase__ , default=lowercase__ , help="""If passed, the training will stop after this number of epochs.""" , ) parser.add_argument( """--num_epochs""" , type=lowercase__ , default=2 , help="""Number of train epochs.""" , ) lowerCAmelCase_ :Optional[int] = parser.parse_args() lowerCAmelCase_ :List[Any] = {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'facebook/convnextv2-tiny-1k-224': 'https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json', } class _SCREAMING_SNAKE_CASE ( A__ , A__ ): UpperCAmelCase_ :Union[str, Any] = "convnextv2" def __init__( self , __A=3 , __A=4 , __A=4 , __A=None , __A=None , __A="gelu" , __A=0.0_2 , __A=1E-12 , __A=0.0 , __A=224 , __A=None , __A=None , **__A , ) -> Any: super().__init__(**__A ) lowerCAmelCase_ :str = num_channels lowerCAmelCase_ :Tuple = patch_size lowerCAmelCase_ :str = num_stages lowerCAmelCase_ :Tuple = [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes lowerCAmelCase_ :Optional[Any] = [3, 3, 9, 3] if depths is None else depths lowerCAmelCase_ :Optional[int] = hidden_act lowerCAmelCase_ :int = initializer_range lowerCAmelCase_ :List[Any] = layer_norm_eps lowerCAmelCase_ :List[Any] = drop_path_rate lowerCAmelCase_ :Any = image_size lowerCAmelCase_ :Union[str, Any] = ["""stem"""] + [f"""stage{idx}""" for idx in range(1 , len(self.depths ) + 1 )] lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = get_aligned_output_features_output_indices( out_features=__A , out_indices=__A , stage_names=self.stage_names )

"""simple docstring""" import baseaa import io import json import os from copy import deepcopy from ..optimizer import AcceleratedOptimizer from ..scheduler import AcceleratedScheduler class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Union[str, Any]: if isinstance(__A , __A ): # Don't modify user's data should they want to reuse it (e.g. in tests), because once we # modified it, it will not be accepted here again, since `auto` values would have been overridden lowerCAmelCase_ :Tuple = deepcopy(__A ) elif os.path.exists(__A ): with io.open(__A , """r""" , encoding="""utf-8""" ) as f: lowerCAmelCase_ :str = json.load(__A ) else: try: lowerCAmelCase_ :Dict = baseaa.urlsafe_baadecode(__A ).decode("""utf-8""" ) lowerCAmelCase_ :int = json.loads(__A ) except (UnicodeDecodeError, AttributeError, ValueError): raise ValueError( f"""Expected a string path to an existing deepspeed config, or a dictionary, or a base64 encoded string. Received: {config_file_or_dict}""" ) lowerCAmelCase_ :Optional[Any] = config self.set_stage_and_offload() def __lowerCAmelCase ( self ) -> Tuple: # zero stage - this is done as early as possible, before model is created, to allow # ``is_deepspeed_zero3_enabled`` query and getting to the early deepspeed config object # during ``zero.Init()`` which needs to know the dtype, and some other hparams. lowerCAmelCase_ :Tuple = self.get_value("""zero_optimization.stage""" , -1 ) # offload lowerCAmelCase_ :Dict = False if self.is_zeroa() or self.is_zeroa(): lowerCAmelCase_ :Optional[int] = set(["""cpu""", """nvme"""] ) lowerCAmelCase_ :Union[str, Any] = set( [ self.get_value("""zero_optimization.offload_optimizer.device""" ), self.get_value("""zero_optimization.offload_param.device""" ), ] ) if len(offload_devices & offload_devices_valid ) > 0: lowerCAmelCase_ :Optional[int] = True def __lowerCAmelCase ( self , __A ) -> Optional[Any]: lowerCAmelCase_ :str = self.config # find the config node of interest if it exists lowerCAmelCase_ :Tuple = ds_key_long.split(""".""" ) lowerCAmelCase_ :List[str] = nodes.pop() for node in nodes: lowerCAmelCase_ :Tuple = config.get(__A ) if config is None: return None, ds_key return config, ds_key def __lowerCAmelCase ( self , __A , __A=None ) -> Optional[Any]: lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.find_config_node(__A ) if config is None: return default return config.get(__A , __A ) def __lowerCAmelCase ( self , __A , __A=False ) -> Optional[Any]: lowerCAmelCase_ :Tuple = self.config # find the config node of interest if it exists lowerCAmelCase_ :Union[str, Any] = ds_key_long.split(""".""" ) for node in nodes: lowerCAmelCase_ :int = config lowerCAmelCase_ :Any = config.get(__A ) if config is None: if must_exist: raise ValueError(f"""Can't find {ds_key_long} entry in the config: {self.config}""" ) else: return # if found remove it if parent_config is not None: parent_config.pop(__A ) def __lowerCAmelCase ( self , __A ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = self.get_value(__A ) return False if value is None else bool(__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: lowerCAmelCase_ :List[str] = self.get_value(__A ) return False if value is None else not bool(__A ) def __lowerCAmelCase ( self ) -> str: return self._stage == 2 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._stage == 3 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._offload class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Optional[int]: lowerCAmelCase_ :Dict = engine def __lowerCAmelCase ( self , __A , **__A ) -> str: # runs backpropagation and handles mixed precision self.engine.backward(__A , **__A ) # Deepspeed's `engine.step` performs the following operations: # - gradient accumulation check # - gradient clipping # - optimizer step # - zero grad # - checking overflow # - lr_scheduler step (only if engine.lr_scheduler is not None) self.engine.step() # and this plugin overrides the above calls with no-ops when Accelerate runs under # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabling a simple # training loop that works transparently under many training regimes. class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A ) -> List[str]: super().__init__(__A , device_placement=__A , scaler=__A ) lowerCAmelCase_ :List[str] = hasattr(self.optimizer , """overflow""" ) def __lowerCAmelCase ( self , __A=None ) -> Optional[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed def __lowerCAmelCase ( self ) -> List[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed @property def __lowerCAmelCase ( self ) -> int: if self.__has_overflow__: return self.optimizer.overflow return False class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A , __A ) -> Optional[int]: super().__init__(__A , __A ) def __lowerCAmelCase ( self ) -> Any: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=0.0_0_1 , __A=0 , **__A ) -> List[Any]: lowerCAmelCase_ :str = params lowerCAmelCase_ :Any = lr lowerCAmelCase_ :List[Any] = weight_decay lowerCAmelCase_ :Any = kwargs class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=None , __A=0 , **__A ) -> List[str]: lowerCAmelCase_ :Optional[int] = optimizer lowerCAmelCase_ :int = total_num_steps lowerCAmelCase_ :List[Any] = warmup_num_steps lowerCAmelCase_ :int = kwargs

"""simple docstring""" import os from math import logaa def _snake_case ( lowercase__ : str = "base_exp.txt" ) -> int: '''simple docstring''' lowerCAmelCase_ :float = 0 lowerCAmelCase_ :Union[str, Any] = 0 for i, line in enumerate(open(os.path.join(os.path.dirname(lowercase__ ) , lowercase__ ) ) ): lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = list(map(lowercase__ , line.split(""",""" ) ) ) if x * logaa(lowercase__ ) > largest: lowerCAmelCase_ :Any = x * logaa(lowercase__ ) lowerCAmelCase_ :List[Any] = i + 1 return result if __name__ == "__main__": print(solution())

"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import numpy as np import torch from ..models.clipseg import CLIPSegForImageSegmentation from ..utils import is_vision_available, requires_backends from .base import PipelineTool if is_vision_available(): from PIL import Image class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Dict = ( "This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image." "It takes two arguments named `image` which should be the original image, and `label` which should be a text " "describing the elements what should be identified in the segmentation mask. The tool returns the mask." ) UpperCAmelCase_ :List[str] = "CIDAS/clipseg-rd64-refined" UpperCAmelCase_ :List[Any] = "image_segmenter" UpperCAmelCase_ :Optional[int] = CLIPSegForImageSegmentation UpperCAmelCase_ :Tuple = ["image", "text"] UpperCAmelCase_ :Dict = ["image"] def __init__( self , *__A , **__A ) -> Optional[Any]: requires_backends(self , ["""vision"""] ) super().__init__(*__A , **__A ) def __lowerCAmelCase ( self , __A , __A ) -> Any: return self.pre_processor(text=[label] , images=[image] , padding=__A , return_tensors="""pt""" ) def __lowerCAmelCase ( self , __A ) -> Tuple: with torch.no_grad(): lowerCAmelCase_ :Dict = self.model(**__A ).logits return logits def __lowerCAmelCase ( self , __A ) -> Tuple: lowerCAmelCase_ :Optional[int] = outputs.cpu().detach().numpy() lowerCAmelCase_ :List[str] = 0 lowerCAmelCase_ :str = 1 return Image.fromarray((array * 255).astype(np.uinta ) )

"""simple docstring""" import unittest import numpy as np from transformers import RoFormerConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __init__( self , __A , __A=13 , __A=7 , __A=True , __A=True , __A=True , __A=True , __A=99 , __A=32 , __A=5 , __A=4 , __A=37 , __A="gelu" , __A=0.1 , __A=0.1 , __A=512 , __A=16 , __A=2 , __A=0.0_2 , __A=4 , ) -> List[str]: lowerCAmelCase_ :Union[str, Any] = parent lowerCAmelCase_ :List[str] = batch_size lowerCAmelCase_ :List[Any] = seq_length lowerCAmelCase_ :int = is_training lowerCAmelCase_ :Optional[int] = use_attention_mask lowerCAmelCase_ :Tuple = use_token_type_ids lowerCAmelCase_ :List[Any] = use_labels lowerCAmelCase_ :Tuple = vocab_size lowerCAmelCase_ :Dict = hidden_size lowerCAmelCase_ :int = num_hidden_layers lowerCAmelCase_ :Optional[Any] = num_attention_heads lowerCAmelCase_ :Optional[int] = intermediate_size lowerCAmelCase_ :Optional[int] = hidden_act lowerCAmelCase_ :List[Any] = hidden_dropout_prob lowerCAmelCase_ :Any = attention_probs_dropout_prob lowerCAmelCase_ :int = max_position_embeddings lowerCAmelCase_ :Dict = type_vocab_size lowerCAmelCase_ :Any = type_sequence_label_size lowerCAmelCase_ :Optional[int] = initializer_range lowerCAmelCase_ :Tuple = num_choices def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCAmelCase_ :Any = None if self.use_attention_mask: lowerCAmelCase_ :Union[str, Any] = random_attention_mask([self.batch_size, self.seq_length] ) lowerCAmelCase_ :Any = None if self.use_token_type_ids: lowerCAmelCase_ :List[Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCAmelCase_ :Dict = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=__A , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Any = self.prepare_config_and_inputs() lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Tuple = config_and_inputs lowerCAmelCase_ :str = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask} return config, inputs_dict @require_flax class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :int = True UpperCAmelCase_ :int = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Tuple = FlaxRoFormerModelTester(self ) @slow def __lowerCAmelCase ( self ) -> str: for model_class_name in self.all_model_classes: lowerCAmelCase_ :Optional[int] = model_class_name.from_pretrained("""junnyu/roformer_chinese_small""" , from_pt=__A ) lowerCAmelCase_ :Union[str, Any] = model(np.ones((1, 1) ) ) self.assertIsNotNone(__A ) @require_flax class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :Any = FlaxRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base""" ) lowerCAmelCase_ :List[str] = jnp.array([[0, 1, 2, 3, 4, 5]] ) lowerCAmelCase_ :Union[str, Any] = model(__A )[0] lowerCAmelCase_ :int = 5_0000 lowerCAmelCase_ :Optional[int] = (1, 6, vocab_size) self.assertEqual(output.shape , __A ) lowerCAmelCase_ :List[str] = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]] ) self.assertTrue(jnp.allclose(output[:, :3, :3] , __A , atol=1E-4 ) )

"""simple docstring""" def _snake_case ( lowercase__ : list , lowercase__ : list , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> int: '''simple docstring''' if index == number_of_items: return 0 lowerCAmelCase_ :Any = 0 lowerCAmelCase_ :str = 0 lowerCAmelCase_ :Dict = knapsack(lowercase__ , lowercase__ , lowercase__ , lowercase__ , index + 1 ) if weights[index] <= max_weight: lowerCAmelCase_ :str = values[index] + knapsack( lowercase__ , lowercase__ , lowercase__ , max_weight - weights[index] , index + 1 ) return max(lowercase__ , lowercase__ ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" def _snake_case ( lowercase__ : Any ) -> int: '''simple docstring''' if collection == []: return [] # get some information about the collection lowerCAmelCase_ :List[str] = len(lowercase__ ) lowerCAmelCase_ :List[str] = max(lowercase__ ) lowerCAmelCase_ :int = min(lowercase__ ) # create the counting array lowerCAmelCase_ :Dict = coll_max + 1 - coll_min lowerCAmelCase_ :Optional[Any] = [0] * counting_arr_length # count how much a number appears in the collection for number in collection: counting_arr[number - coll_min] += 1 # sum each position with it's predecessors. now, counting_arr[i] tells # us how many elements <= i has in the collection for i in range(1 , lowercase__ ): lowerCAmelCase_ :Tuple = counting_arr[i] + counting_arr[i - 1] # create the output collection lowerCAmelCase_ :Tuple = [0] * coll_len # place the elements in the output, respecting the original order (stable # sort) from end to begin, updating counting_arr for i in reversed(range(0 , lowercase__ ) ): lowerCAmelCase_ :List[Any] = collection[i] counting_arr[collection[i] - coll_min] -= 1 return ordered def _snake_case ( lowercase__ : Any ) -> int: '''simple docstring''' return "".join([chr(lowercase__ ) for i in counting_sort([ord(lowercase__ ) for c in string] )] ) if __name__ == "__main__": # Test string sort assert counting_sort_string('thisisthestring') == "eghhiiinrsssttt" __UpperCAmelCase = input('Enter numbers separated by a comma:\n').strip() __UpperCAmelCase = [int(item) for item in user_input.split(',')] print(counting_sort(unsorted))

"""simple docstring""" from .imports import is_tqdm_available if is_tqdm_available(): from tqdm.auto import tqdm as _tqdm from ..state import PartialState def _snake_case ( lowercase__ : bool = True , *lowercase__ : Optional[int] , **lowercase__ : str ) -> Optional[Any]: '''simple docstring''' if not is_tqdm_available(): raise ImportError("""Accelerate's `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`.""" ) lowerCAmelCase_ :Tuple = False if main_process_only: lowerCAmelCase_ :Dict = PartialState().local_process_index == 0 return _tqdm(*lowercase__ , **lowercase__ , disable=lowercase__ )

"""simple docstring""" import os import re import shutil import sys import tempfile import unittest import black __UpperCAmelCase = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, 'utils')) import check_copies # noqa: E402 # This is the reference code that will be used in the tests. # If DDPMSchedulerOutput is changed in scheduling_ddpm.py, this code needs to be manually updated. __UpperCAmelCase = ' \"""\n Output class for the scheduler\'s step function output.\n\n Args:\n prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the\n denoising loop.\n pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):\n The predicted denoised sample (x_{0}) based on the model output from the current timestep.\n `pred_original_sample` can be used to preview progress or for guidance.\n \"""\n\n prev_sample: torch.FloatTensor\n pred_original_sample: Optional[torch.FloatTensor] = None\n' class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :int = tempfile.mkdtemp() os.makedirs(os.path.join(self.diffusers_dir , """schedulers/""" ) ) lowerCAmelCase_ :Any = self.diffusers_dir shutil.copy( os.path.join(__A , """src/diffusers/schedulers/scheduling_ddpm.py""" ) , os.path.join(self.diffusers_dir , """schedulers/scheduling_ddpm.py""" ) , ) def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Optional[Any] = """src/diffusers""" shutil.rmtree(self.diffusers_dir ) def __lowerCAmelCase ( self , __A , __A , __A , __A=None ) -> int: lowerCAmelCase_ :Optional[int] = comment + f"""\nclass {class_name}(nn.Module):\n""" + class_code if overwrite_result is not None: lowerCAmelCase_ :Optional[int] = comment + f"""\nclass {class_name}(nn.Module):\n""" + overwrite_result lowerCAmelCase_ :Optional[int] = black.Mode(target_versions={black.TargetVersion.PYaa} , line_length=119 ) lowerCAmelCase_ :List[str] = black.format_str(__A , mode=__A ) lowerCAmelCase_ :Any = os.path.join(self.diffusers_dir , """new_code.py""" ) with open(__A , """w""" , newline="""\n""" ) as f: f.write(__A ) if overwrite_result is None: self.assertTrue(len(check_copies.is_copy_consistent(__A ) ) == 0 ) else: check_copies.is_copy_consistent(f.name , overwrite=__A ) with open(__A , """r""" ) as f: self.assertTrue(f.read() , __A ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Dict = check_copies.find_code_in_diffusers("""schedulers.scheduling_ddpm.DDPMSchedulerOutput""" ) self.assertEqual(__A , __A ) def __lowerCAmelCase ( self ) -> List[Any]: # Base copy consistency self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput""" , """DDPMSchedulerOutput""" , REFERENCE_CODE + """\n""" , ) # With no empty line at the end self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput""" , """DDPMSchedulerOutput""" , __A , ) # Copy consistency with rename self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test""" , """TestSchedulerOutput""" , re.sub("""DDPM""" , """Test""" , __A ) , ) # Copy consistency with a really long name lowerCAmelCase_ :List[Any] = """TestClassWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason""" self.check_copy_consistency( f"""# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->{long_class_name}""" , f"""{long_class_name}SchedulerOutput""" , re.sub("""Bert""" , __A , __A ) , ) # Copy consistency with overwrite self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test""" , """TestSchedulerOutput""" , __A , overwrite_result=re.sub("""DDPM""" , """Test""" , __A ) , )

"""simple docstring""" import importlib import json import os import sys import tempfile import unittest from pathlib import Path import transformers import transformers.models.auto from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig from transformers.models.bert.configuration_bert import BertConfig from transformers.models.roberta.configuration_roberta import RobertaConfig from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils')) from test_module.custom_configuration import CustomConfig # noqa E402 __UpperCAmelCase = get_tests_dir('fixtures/dummy-config.json') class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = 0 def __lowerCAmelCase ( self ) -> List[str]: self.assertIsNotNone(transformers.models.auto.__spec__ ) self.assertIsNotNone(importlib.util.find_spec("""transformers.models.auto""" ) ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""bert-base-uncased""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = AutoConfig.for_model("""roberta""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Tuple: with tempfile.TemporaryDirectory() as tmp_dir: # This model name contains bert and roberta, but roberta ends up being picked. lowerCAmelCase_ :int = os.path.join(__A , """fake-roberta""" ) os.makedirs(__A , exist_ok=__A ) with open(os.path.join(__A , """config.json""" ) , """w""" ) as f: f.write(json.dumps({} ) ) lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertEqual(type(__A ) , __A ) def __lowerCAmelCase ( self ) -> Optional[int]: try: AutoConfig.register("""custom""" , __A ) # Wrong model type will raise an error with self.assertRaises(__A ): AutoConfig.register("""model""" , __A ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(__A ): AutoConfig.register("""bert""" , __A ) # Now that the config is registered, it can be used as any other config with the auto-API lowerCAmelCase_ :Union[str, Any] = CustomConfig() with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Optional[int] = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] def __lowerCAmelCase ( self ) -> Tuple: with self.assertRaisesRegex( __A , """bert-base is not a local folder and is not a valid model identifier""" ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""bert-base""" ) def __lowerCAmelCase ( self ) -> Any: with self.assertRaisesRegex( __A , r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ): lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , revision="""aaaaaa""" ) def __lowerCAmelCase ( self ) -> int: with self.assertRaisesRegex( __A , """hf-internal-testing/no-config-test-repo does not appear to have a file named config.json.""" , ): lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/no-config-test-repo""" ) def __lowerCAmelCase ( self ) -> Tuple: # If remote code is not set, we will time out when asking whether to load the model. with self.assertRaises(__A ): lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(__A ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) lowerCAmelCase_ :str = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) # Test config can be reloaded. with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , trust_remote_code=__A ) self.assertEqual(reloaded_config.__class__.__name__ , """NewModelConfig""" ) def __lowerCAmelCase ( self ) -> int: class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :int = "new-model" try: AutoConfig.register("""new-model""" , __A ) # If remote code is not set, the default is to use local lowerCAmelCase_ :Any = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote code is disabled, we load the local one. lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote is enabled, we load from the Hub lowerCAmelCase_ :Optional[Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) finally: if "new-model" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["new-model"]

"""simple docstring""" import pandas as pd from matplotlib import pyplot as plt from sklearn.linear_model import LinearRegression # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split # Fitting Polynomial Regression to the dataset from sklearn.preprocessing import PolynomialFeatures # Importing the dataset __UpperCAmelCase = pd.read_csv( 'https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/' 'position_salaries.csv' ) __UpperCAmelCase = dataset.iloc[:, 1:2].values __UpperCAmelCase = dataset.iloc[:, 2].values __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = train_test_split(X, y, test_size=0.2, random_state=0) __UpperCAmelCase = PolynomialFeatures(degree=4) __UpperCAmelCase = poly_reg.fit_transform(X) __UpperCAmelCase = LinearRegression() pol_reg.fit(X_poly, y) def _snake_case ( ) -> str: '''simple docstring''' plt.scatter(lowercase__ , lowercase__ , color="""red""" ) plt.plot(lowercase__ , pol_reg.predict(poly_reg.fit_transform(lowercase__ ) ) , color="""blue""" ) plt.title("""Truth or Bluff (Linear Regression)""" ) plt.xlabel("""Position level""" ) plt.ylabel("""Salary""" ) plt.show() if __name__ == "__main__": viz_polymonial() # Predicting a new result with Polymonial Regression pol_reg.predict(poly_reg.fit_transform([[5.5]])) # output should be 132148.43750003

"""simple docstring""" import json import os import unittest from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import ( VOCAB_FILES_NAMES, GPTSanJapaneseTokenizer, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :str = GPTSanJapaneseTokenizer UpperCAmelCase_ :Optional[int] = False UpperCAmelCase_ :Optional[int] = {"do_clean_text": False, "add_prefix_space": False} def __lowerCAmelCase ( self ) -> Tuple: super().setUp() # fmt: off lowerCAmelCase_ :Dict = ["""こん""", """こんに""", """にちは""", """ばんは""", """世界,㔺界""", """、""", """。""", """<BR>""", """<SP>""", """<TAB>""", """<URL>""", """<EMAIL>""", """<TEL>""", """<DATE>""", """<PRICE>""", """<BLOCK>""", """<KIGOU>""", """<U2000U2BFF>""", """<|emoji1|>""", """<unk>""", """<|bagoftoken|>""", """<|endoftext|>"""] # fmt: on lowerCAmelCase_ :List[str] = {"""emoji""": {"""\ud83d\ude00""": """<|emoji1|>"""}, """emoji_inv""": {"""<|emoji1|>""": """\ud83d\ude00"""}} # 😀 lowerCAmelCase_ :int = {"""unk_token""": """<unk>"""} lowerCAmelCase_ :Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) lowerCAmelCase_ :int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""emoji_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) with open(self.emoji_file , """w""" ) as emoji_writer: emoji_writer.write(json.dumps(__A ) ) def __lowerCAmelCase ( self , **__A ) -> int: kwargs.update(self.special_tokens_map ) return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname , **__A ) def __lowerCAmelCase ( self , __A ) -> Dict: lowerCAmelCase_ :List[Any] = """こんにちは、世界。 \nこんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[int] = """こんにちは、世界。 \nこんばんは、世界。😀""" return input_text, output_text def __lowerCAmelCase ( self , __A ) -> str: lowerCAmelCase_ , lowerCAmelCase_ :Tuple = self.get_input_output_texts(__A ) lowerCAmelCase_ :List[str] = tokenizer.encode(__A , add_special_tokens=__A ) lowerCAmelCase_ :str = tokenizer.decode(__A , clean_up_tokenization_spaces=__A ) return text, ids def __lowerCAmelCase ( self ) -> str: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> int: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :Union[str, Any] = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、世界。　こんばんは、㔺界。""" lowerCAmelCase_ :Any = ["""こん""", """にちは""", """、""", """世界""", """。""", """<SP>""", """こん""", """ばんは""", """、""", """㔺界""", """。"""] lowerCAmelCase_ :Tuple = tokenizer.tokenize(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids without special tokens lowerCAmelCase_ :List[Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6] lowerCAmelCase_ :List[str] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids with special tokens lowerCAmelCase_ :Any = tokens + [tokenizer.unk_token] lowerCAmelCase_ :Union[str, Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19] lowerCAmelCase_ :Union[str, Any] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。""" lowerCAmelCase_ :str = """こんにちは、、、、世界。こんばんは、、、、世界。""" lowerCAmelCase_ :str = tokenizer.encode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Tuple = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Any = """こんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。こんばんは、世界。😀""" lowerCAmelCase_ :List[Any] = tokenizer.encode(prefix_text + input_text ) lowerCAmelCase_ :List[str] = tokenizer.encode("""""" , prefix_text=prefix_text + input_text ) lowerCAmelCase_ :int = tokenizer.encode(__A , prefix_text=__A ) lowerCAmelCase_ :int = tokenizer.decode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) lowerCAmelCase_ :Tuple = tokenizer.decode(__A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :int = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :List[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Optional[int] = """こんばんは、㔺界。😀""" lowerCAmelCase_ :List[str] = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :Dict = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :int = [1] + [0] * (len_prefix + len_text + 1) lowerCAmelCase_ :List[Any] = [1] * (len_prefix + len_text + 1) + [0] lowerCAmelCase_ :Dict = [1] + [1] * (len_prefix) + [0] * (len_text + 1) lowerCAmelCase_ :List[Any] = tokenizer(prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[str] = tokenizer("""""" , prefix_text=prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[Any] = tokenizer(__A , prefix_text=__A ).token_type_ids self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Dict = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = tokenizer.encode("""あンいワ""" ) lowerCAmelCase_ :Optional[Any] = tokenizer.encode("""""" , prefix_text="""あンいワ""" ) lowerCAmelCase_ :int = tokenizer.encode("""いワ""" , prefix_text="""あン""" ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertNotEqual(__A , __A ) self.assertNotEqual(__A , __A ) self.assertEqual(x_token_a[1] , x_token_a[-1] ) # SEG token self.assertEqual(x_token_a[1] , x_token_a[3] ) # SEG token @slow def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Union[str, Any] = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = [["""武田信玄""", """は、"""], ["""織田信長""", """の配下の、"""]] lowerCAmelCase_ :Dict = tokenizer(__A , padding=__A ) lowerCAmelCase_ :Any = tokenizer.batch_encode_plus(__A , padding=__A ) # fmt: off lowerCAmelCase_ :int = [[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]] lowerCAmelCase_ :List[str] = [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]] lowerCAmelCase_ :int = [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]] # fmt: on self.assertListEqual(x_token.input_ids , __A ) self.assertListEqual(x_token.token_type_ids , __A ) self.assertListEqual(x_token.attention_mask , __A ) self.assertListEqual(x_token_a.input_ids , __A ) self.assertListEqual(x_token_a.token_type_ids , __A ) self.assertListEqual(x_token_a.attention_mask , __A ) def __lowerCAmelCase ( self ) -> Tuple: # Intentionally convert some words to accommodate character fluctuations unique to Japanese pass def __lowerCAmelCase ( self ) -> str: # tokenizer has no padding token pass

"""simple docstring""" 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: __UpperCAmelCase = None __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'} __UpperCAmelCase = { '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', }, } __UpperCAmelCase = { 'facebook/mbart-large-en-ro': 10_24, 'facebook/mbart-large-cc25': 10_24, } # fmt: off __UpperCAmelCase = ['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_ :List[str] = VOCAB_FILES_NAMES UpperCAmelCase_ :Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCAmelCase_ :Any = PRETRAINED_VOCAB_FILES_MAP UpperCAmelCase_ :str = ["input_ids", "attention_mask"] UpperCAmelCase_ :str = MBartTokenizer UpperCAmelCase_ :List[int] = [] UpperCAmelCase_ :List[int] = [] def __init__( self , __A=None , __A=None , __A="<s>" , __A="</s>" , __A="</s>" , __A="<s>" , __A="<unk>" , __A="<pad>" , __A="<mask>" , __A=None , __A=None , __A=None , **__A , ) -> int: # Mask token behave like a normal word, i.e. include the space before it lowerCAmelCase_ :List[str] = AddedToken(__A , lstrip=__A , rstrip=__A ) if isinstance(__A , __A ) else mask_token super().__init__( vocab_file=__A , tokenizer_file=__A , bos_token=__A , eos_token=__A , sep_token=__A , cls_token=__A , unk_token=__A , pad_token=__A , mask_token=__A , src_lang=__A , tgt_lang=__A , additional_special_tokens=__A , **__A , ) lowerCAmelCase_ :Any = vocab_file lowerCAmelCase_ :Any = False if not self.vocab_file else True lowerCAmelCase_ :List[Any] = 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_ :Union[str, Any] = { lang_code: self.convert_tokens_to_ids(__A ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCAmelCase_ :List[str] = src_lang if src_lang is not None else """en_XX""" lowerCAmelCase_ :Tuple = self.convert_tokens_to_ids(self._src_lang ) lowerCAmelCase_ :List[Any] = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def __lowerCAmelCase ( self ) -> str: return self._src_lang @src_lang.setter def __lowerCAmelCase ( self , __A ) -> None: lowerCAmelCase_ :int = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def __lowerCAmelCase ( self , __A , __A = None ) -> List[int]: 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 , __A , __A = None ) -> List[int]: lowerCAmelCase_ :Any = [self.sep_token_id] lowerCAmelCase_ :Tuple = [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 , __A , __A , __A , __A , **__A ) -> Tuple: 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_ :Any = src_lang lowerCAmelCase_ :Dict = self(__A , add_special_tokens=__A , return_tensors=__A , **__A ) lowerCAmelCase_ :List[Any] = self.convert_tokens_to_ids(__A ) lowerCAmelCase_ :str = tgt_lang_id return inputs def __lowerCAmelCase ( self , __A , __A = "en_XX" , __A = None , __A = "ro_RO" , **__A , ) -> BatchEncoding: lowerCAmelCase_ :str = src_lang lowerCAmelCase_ :str = tgt_lang return super().prepare_seqaseq_batch(__A , __A , **__A ) def __lowerCAmelCase ( self ) -> Any: return self.set_src_lang_special_tokens(self.src_lang ) def __lowerCAmelCase ( self ) -> List[str]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def __lowerCAmelCase ( self , __A ) -> None: lowerCAmelCase_ :Optional[Any] = self.convert_tokens_to_ids(__A ) lowerCAmelCase_ :Any = [] lowerCAmelCase_ :Union[str, Any] = [self.eos_token_id, self.cur_lang_code] lowerCAmelCase_ :Dict = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCAmelCase_ :Optional[Any] = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCAmelCase_ :int = 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 , __A ) -> None: lowerCAmelCase_ :Dict = self.convert_tokens_to_ids(__A ) lowerCAmelCase_ :Dict = [] lowerCAmelCase_ :str = [self.eos_token_id, self.cur_lang_code] lowerCAmelCase_ :str = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCAmelCase_ :int = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCAmelCase_ :Optional[int] = 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 , __A , __A = 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(__A ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory.""" ) return lowerCAmelCase_ :int = os.path.join( __A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__A ): copyfile(self.vocab_file , __A ) return (out_vocab_file,)

"""simple docstring""" import pandas as pd from matplotlib import pyplot as plt from sklearn.linear_model import LinearRegression # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split # Fitting Polynomial Regression to the dataset from sklearn.preprocessing import PolynomialFeatures # Importing the dataset __UpperCAmelCase = pd.read_csv( 'https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/' 'position_salaries.csv' ) __UpperCAmelCase = dataset.iloc[:, 1:2].values __UpperCAmelCase = dataset.iloc[:, 2].values __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = train_test_split(X, y, test_size=0.2, random_state=0) __UpperCAmelCase = PolynomialFeatures(degree=4) __UpperCAmelCase = poly_reg.fit_transform(X) __UpperCAmelCase = LinearRegression() pol_reg.fit(X_poly, y) def _snake_case ( ) -> str: '''simple docstring''' plt.scatter(lowercase__ , lowercase__ , color="""red""" ) plt.plot(lowercase__ , pol_reg.predict(poly_reg.fit_transform(lowercase__ ) ) , color="""blue""" ) plt.title("""Truth or Bluff (Linear Regression)""" ) plt.xlabel("""Position level""" ) plt.ylabel("""Salary""" ) plt.show() if __name__ == "__main__": viz_polymonial() # Predicting a new result with Polymonial Regression pol_reg.predict(poly_reg.fit_transform([[5.5]])) # output should be 132148.43750003

"""simple docstring""" import io import json import unittest from parameterized import parameterized from transformers import FSMTForConditionalGeneration, FSMTTokenizer from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device from utils import calculate_bleu __UpperCAmelCase = get_tests_dir() + '/test_data/fsmt/fsmt_val_data.json' with io.open(filename, 'r', encoding='utf-8') as f: __UpperCAmelCase = json.load(f) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self , __A ) -> List[Any]: return FSMTTokenizer.from_pretrained(__A ) def __lowerCAmelCase ( self , __A ) -> Any: lowerCAmelCase_ :Any = FSMTForConditionalGeneration.from_pretrained(__A ).to(__A ) if torch_device == "cuda": model.half() return model @parameterized.expand( [ ["""en-ru""", 2_6.0], ["""ru-en""", 2_2.0], ["""en-de""", 2_2.0], ["""de-en""", 2_9.0], ] ) @slow def __lowerCAmelCase ( self , __A , __A ) -> Dict: # note: this test is not testing the best performance since it only evals a small batch # but it should be enough to detect a regression in the output quality lowerCAmelCase_ :int = f"""facebook/wmt19-{pair}""" lowerCAmelCase_ :List[str] = self.get_tokenizer(__A ) lowerCAmelCase_ :Union[str, Any] = self.get_model(__A ) lowerCAmelCase_ :Optional[Any] = bleu_data[pair]["""src"""] lowerCAmelCase_ :List[Any] = bleu_data[pair]["""tgt"""] lowerCAmelCase_ :int = tokenizer(__A , return_tensors="""pt""" , truncation=__A , padding="""longest""" ).to(__A ) lowerCAmelCase_ :Dict = model.generate( input_ids=batch.input_ids , num_beams=8 , ) lowerCAmelCase_ :Tuple = tokenizer.batch_decode( __A , skip_special_tokens=__A , clean_up_tokenization_spaces=__A ) lowerCAmelCase_ :List[str] = calculate_bleu(__A , __A ) print(__A ) self.assertGreaterEqual(scores["""bleu"""] , __A )

"""simple docstring""" from __future__ import annotations __UpperCAmelCase = 1.6021e-19 # units = C def _snake_case ( lowercase__ : float , lowercase__ : float , lowercase__ : float , ) -> tuple[str, float]: '''simple docstring''' if (conductivity, electron_conc, mobility).count(0 ) != 1: raise ValueError("""You cannot supply more or less than 2 values""" ) elif conductivity < 0: raise ValueError("""Conductivity cannot be negative""" ) elif electron_conc < 0: raise ValueError("""Electron concentration cannot be negative""" ) elif mobility < 0: raise ValueError("""mobility cannot be negative""" ) elif conductivity == 0: return ( "conductivity", mobility * electron_conc * ELECTRON_CHARGE, ) elif electron_conc == 0: return ( "electron_conc", conductivity / (mobility * ELECTRON_CHARGE), ) else: return ( "mobility", conductivity / (electron_conc * ELECTRON_CHARGE), ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" from __future__ import annotations def _snake_case ( lowercase__ : list[int] , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> None: '''simple docstring''' if (direction == 1 and array[indexa] > array[indexa]) or ( direction == 0 and array[indexa] < array[indexa] ): lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = array[indexa], array[indexa] def _snake_case ( lowercase__ : list[int] , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> None: '''simple docstring''' if length > 1: lowerCAmelCase_ :Optional[int] = int(length / 2 ) for i in range(lowercase__ , low + middle ): comp_and_swap(lowercase__ , lowercase__ , i + middle , lowercase__ ) bitonic_merge(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) bitonic_merge(lowercase__ , low + middle , lowercase__ , lowercase__ ) def _snake_case ( lowercase__ : list[int] , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> None: '''simple docstring''' if length > 1: lowerCAmelCase_ :int = int(length / 2 ) bitonic_sort(lowercase__ , lowercase__ , lowercase__ , 1 ) bitonic_sort(lowercase__ , low + middle , lowercase__ , 0 ) bitonic_merge(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) if __name__ == "__main__": __UpperCAmelCase = input('Enter numbers separated by a comma:\n').strip() __UpperCAmelCase = [int(item.strip()) for item in user_input.split(',')] bitonic_sort(unsorted, 0, len(unsorted), 1) print('\nSorted array in ascending order is: ', end='') print(*unsorted, sep=', ') bitonic_merge(unsorted, 0, len(unsorted), 0) print('Sorted array in descending order is: ', end='') print(*unsorted, sep=', ')

"""simple docstring""" import warnings from ...utils import logging from .image_processing_clip import CLIPImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , *__A , **__A ) -> None: warnings.warn( """The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use CLIPImageProcessor instead.""" , __A , ) super().__init__(*__A , **__A )

"""simple docstring""" from typing import Optional import numpy as np import torch from torch import nn from transformers import GPTaConfig, GPTaLMHeadModel from transformers.modeling_utils import ModuleUtilsMixin from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ ): UpperCAmelCase_ :List[str] = [r"h\.\d+\.attn\.bias", r"h\.\d+\.attn\.masked_bias"] @register_to_config def __init__( self , __A , __A , __A = None , __A = 5_0257 , __A = 1024 , __A = 768 , __A = 12 , __A = 12 , __A = None , __A = "gelu_new" , __A = 0.1 , __A = 0.1 , __A = 0.1 , __A = 1E-5 , __A = 0.0_2 , __A = True , __A = True , __A = False , __A = False , ) -> Optional[Any]: super().__init__() lowerCAmelCase_ :List[str] = prefix_length if prefix_inner_dim != n_embd and prefix_hidden_dim is None: raise ValueError( f"""`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and""" f""" `n_embd`: {n_embd} are not equal.""" ) lowerCAmelCase_ :Union[str, Any] = prefix_inner_dim lowerCAmelCase_ :str = prefix_hidden_dim lowerCAmelCase_ :str = ( nn.Linear(self.prefix_inner_dim , self.prefix_hidden_dim ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :List[Any] = ( nn.Linear(self.prefix_hidden_dim , __A ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :Any = GPTaConfig( vocab_size=__A , n_positions=__A , n_embd=__A , n_layer=__A , n_head=__A , n_inner=__A , activation_function=__A , resid_pdrop=__A , embd_pdrop=__A , attn_pdrop=__A , layer_norm_epsilon=__A , initializer_range=__A , scale_attn_weights=__A , use_cache=__A , scale_attn_by_inverse_layer_idx=__A , reorder_and_upcast_attn=__A , ) lowerCAmelCase_ :Any = GPTaLMHeadModel(__A ) def __lowerCAmelCase ( self , __A , __A , __A = None , __A = None , ) -> List[str]: lowerCAmelCase_ :str = self.transformer.transformer.wte(__A ) lowerCAmelCase_ :Any = self.encode_prefix(__A ) lowerCAmelCase_ :Optional[Any] = self.decode_prefix(__A ) lowerCAmelCase_ :Optional[int] = torch.cat((prefix_embeds, embedding_text) , dim=1 ) if labels is not None: lowerCAmelCase_ :int = self.get_dummy_token(input_ids.shape[0] , input_ids.device ) lowerCAmelCase_ :Optional[Any] = torch.cat((dummy_token, input_ids) , dim=1 ) lowerCAmelCase_ :Tuple = self.transformer(inputs_embeds=__A , labels=__A , attention_mask=__A ) if self.prefix_hidden_dim is not None: return out, hidden else: return out def __lowerCAmelCase ( self , __A , __A ) -> torch.Tensor: return torch.zeros(__A , self.prefix_length , dtype=torch.intaa , device=__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: return self.encode_prefix(__A ) @torch.no_grad() def __lowerCAmelCase ( self , __A , __A , __A ) -> Optional[int]: lowerCAmelCase_ :Tuple = torch.split(__A , 1 , dim=0 ) lowerCAmelCase_ :Optional[int] = [] lowerCAmelCase_ :List[str] = [] for feature in features: lowerCAmelCase_ :Tuple = self.decode_prefix(feature.to(__A ) ) # back to the clip feature # Only support beam search for now lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.generate_beam( input_embeds=__A , device=__A , eos_token_id=__A ) generated_tokens.append(output_tokens[0] ) generated_seq_lengths.append(seq_lengths[0] ) lowerCAmelCase_ :Tuple = torch.stack(__A ) lowerCAmelCase_ :int = torch.stack(__A ) return generated_tokens, generated_seq_lengths @torch.no_grad() def __lowerCAmelCase ( self , __A=None , __A=None , __A=None , __A = 5 , __A = 67 , __A = 1.0 , __A = None , ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = eos_token_id lowerCAmelCase_ :Optional[int] = None lowerCAmelCase_ :Any = None lowerCAmelCase_ :int = torch.ones(__A , device=__A , dtype=torch.int ) lowerCAmelCase_ :Optional[int] = torch.zeros(__A , device=__A , dtype=torch.bool ) if input_embeds is not None: lowerCAmelCase_ :List[str] = input_embeds else: lowerCAmelCase_ :Union[str, Any] = self.transformer.transformer.wte(__A ) for i in range(__A ): lowerCAmelCase_ :Optional[int] = self.transformer(inputs_embeds=__A ) lowerCAmelCase_ :str = outputs.logits lowerCAmelCase_ :str = logits[:, -1, :] / (temperature if temperature > 0 else 1.0) lowerCAmelCase_ :Dict = logits.softmax(-1 ).log() if scores is None: lowerCAmelCase_ , lowerCAmelCase_ :Any = logits.topk(__A , -1 ) lowerCAmelCase_ :Union[str, Any] = generated.expand(__A , *generated.shape[1:] ) lowerCAmelCase_ , lowerCAmelCase_ :List[str] = next_tokens.permute(1 , 0 ), scores.squeeze(0 ) if tokens is None: lowerCAmelCase_ :List[str] = next_tokens else: lowerCAmelCase_ :List[Any] = tokens.expand(__A , *tokens.shape[1:] ) lowerCAmelCase_ :Any = torch.cat((tokens, next_tokens) , dim=1 ) else: lowerCAmelCase_ :List[Any] = -float(np.inf ) lowerCAmelCase_ :int = 0 lowerCAmelCase_ :Optional[int] = scores[:, None] + logits seq_lengths[~is_stopped] += 1 lowerCAmelCase_ :List[Any] = scores_sum / seq_lengths[:, None] lowerCAmelCase_ , lowerCAmelCase_ :Tuple = scores_sum_average.view(-1 ).topk(__A , -1 ) lowerCAmelCase_ :Optional[Any] = next_tokens // scores_sum.shape[1] lowerCAmelCase_ :Dict = seq_lengths[next_tokens_source] lowerCAmelCase_ :Tuple = next_tokens % scores_sum.shape[1] lowerCAmelCase_ :Optional[Any] = next_tokens.unsqueeze(1 ) lowerCAmelCase_ :str = tokens[next_tokens_source] lowerCAmelCase_ :List[Any] = torch.cat((tokens, next_tokens) , dim=1 ) lowerCAmelCase_ :Dict = generated[next_tokens_source] lowerCAmelCase_ :Dict = scores_sum_average * seq_lengths lowerCAmelCase_ :Tuple = is_stopped[next_tokens_source] lowerCAmelCase_ :str = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] , 1 , -1 ) lowerCAmelCase_ :List[Any] = torch.cat((generated, next_token_embed) , dim=1 ) lowerCAmelCase_ :Optional[int] = is_stopped + next_tokens.eq(__A ).squeeze() if is_stopped.all(): break lowerCAmelCase_ :str = scores / seq_lengths lowerCAmelCase_ :Optional[int] = scores.argsort(descending=__A ) # tokens tensors are already padded to max_seq_length lowerCAmelCase_ :Optional[Any] = [tokens[i] for i in order] lowerCAmelCase_ :Dict = torch.stack(__A , dim=0 ) lowerCAmelCase_ :Tuple = torch.tensor([seq_lengths[i] for i in order] , dtype=seq_lengths.dtype ) return output_texts, seq_lengths

"""simple docstring""" from itertools import zip_longest import requests from bsa import BeautifulSoup from pandas import DataFrame def _snake_case ( lowercase__ : str = "laptop" ) -> DataFrame: '''simple docstring''' lowerCAmelCase_ :Dict = f"""https://www.amazon.in/laptop/s?k={product}""" lowerCAmelCase_ :List[str] = { """User-Agent""": """Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/44.0.2403.157 Safari/537.36""", """Accept-Language""": """en-US, en;q=0.5""", } lowerCAmelCase_ :List[Any] = BeautifulSoup(requests.get(lowercase__ , headers=lowercase__ ).text ) # Initialize a Pandas dataframe with the column titles lowerCAmelCase_ :Union[str, Any] = DataFrame( columns=[ """Product Title""", """Product Link""", """Current Price of the product""", """Product Rating""", """MRP of the product""", """Discount""", ] ) # Loop through each entry and store them in the dataframe for item, _ in zip_longest( soup.find_all( """div""" , attrs={"""class""": """s-result-item""", """data-component-type""": """s-search-result"""} , ) , soup.find_all("""div""" , attrs={"""class""": """a-row a-size-base a-color-base"""} ) , ): try: lowerCAmelCase_ :str = item.ha.text lowerCAmelCase_ :Dict = """https://www.amazon.in/""" + item.ha.a["""href"""] lowerCAmelCase_ :int = item.find("""span""" , attrs={"""class""": """a-offscreen"""} ).text try: lowerCAmelCase_ :Dict = item.find("""span""" , attrs={"""class""": """a-icon-alt"""} ).text except AttributeError: lowerCAmelCase_ :int = """Not available""" try: lowerCAmelCase_ :str = ( """₹""" + item.find( """span""" , attrs={"""class""": """a-price a-text-price"""} ).text.split("""₹""" )[1] ) except AttributeError: lowerCAmelCase_ :Optional[Any] = """""" try: lowerCAmelCase_ :str = float( ( ( float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) - float(product_price.strip("""₹""" ).replace(""",""" , """""" ) ) ) / float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) ) * 1_0_0 ) except ValueError: lowerCAmelCase_ :Union[str, Any] = float("""nan""" ) except AttributeError: pass lowerCAmelCase_ :Any = [ product_title, product_link, product_price, product_rating, product_mrp, discount, ] lowerCAmelCase_ :List[Any] = """ """ lowerCAmelCase_ :Tuple = """ """ data_frame.index += 1 return data_frame if __name__ == "__main__": __UpperCAmelCase = 'headphones' get_amazon_product_data(product).to_csv(F"""Amazon Product Data for {product}.csv""")

"""simple docstring""" import math import sys def _snake_case ( lowercase__ : int ) -> int: '''simple docstring''' if number != int(lowercase__ ): raise ValueError("""the value of input must be a natural number""" ) if number < 0: raise ValueError("""the value of input must not be a negative number""" ) if number == 0: return 1 lowerCAmelCase_ :Any = [-1] * (number + 1) lowerCAmelCase_ :Dict = 0 for i in range(1 , number + 1 ): lowerCAmelCase_ :Union[str, Any] = sys.maxsize lowerCAmelCase_ :List[Any] = int(math.sqrt(lowercase__ ) ) for j in range(1 , root + 1 ): lowerCAmelCase_ :List[str] = 1 + answers[i - (j**2)] lowerCAmelCase_ :Any = min(lowercase__ , lowercase__ ) lowerCAmelCase_ :Tuple = answer return answers[number] if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" import shutil import tempfile import unittest from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast from transformers.testing_utils import require_sentencepiece, require_torchaudio from .test_feature_extraction_clap import floats_list @require_torchaudio @require_sentencepiece class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Any = """laion/clap-htsat-unfused""" lowerCAmelCase_ :Optional[Any] = tempfile.mkdtemp() def __lowerCAmelCase ( self , **__A ) -> List[Any]: return RobertaTokenizer.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self , **__A ) -> Tuple: return ClapFeatureExtractor.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self ) -> int: shutil.rmtree(self.tmpdirname ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Optional[Any] = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :Optional[Any] = ClapProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Dict = ClapProcessor(tokenizer=self.get_tokenizer() , feature_extractor=self.get_feature_extractor() ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :str = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) lowerCAmelCase_ :Dict = self.get_feature_extractor(do_normalize=__A , padding_value=1.0 ) lowerCAmelCase_ :Union[str, Any] = ClapProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=__A , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Dict = self.get_feature_extractor() lowerCAmelCase_ :str = self.get_tokenizer() lowerCAmelCase_ :List[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :Optional[Any] = floats_list((3, 1000) ) lowerCAmelCase_ :Optional[Any] = feature_extractor(__A , return_tensors="""np""" ) lowerCAmelCase_ :str = processor(audios=__A , return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :List[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :List[Any] = """This is a test string""" lowerCAmelCase_ :Dict = processor(text=__A ) lowerCAmelCase_ :List[str] = tokenizer(__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :int = self.get_feature_extractor() lowerCAmelCase_ :Tuple = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] lowerCAmelCase_ :Tuple = processor.batch_decode(__A ) lowerCAmelCase_ :Optional[Any] = tokenizer.batch_decode(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) self.assertListEqual( processor.model_input_names[2:] , feature_extractor.model_input_names , msg="""`processor` and `feature_extractor` model input names do not match""" , )

"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer from .base import PipelineTool class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Any = "philschmid/bart-large-cnn-samsum" UpperCAmelCase_ :Tuple = ( "This is a tool that summarizes an English text. It takes an input `text` containing the text to summarize, " "and returns a summary of the text." ) UpperCAmelCase_ :Union[str, Any] = "summarizer" UpperCAmelCase_ :str = AutoTokenizer UpperCAmelCase_ :str = AutoModelForSeqaSeqLM UpperCAmelCase_ :Tuple = ["text"] UpperCAmelCase_ :Tuple = ["text"] def __lowerCAmelCase ( self , __A ) -> Optional[Any]: return self.pre_processor(__A , return_tensors="""pt""" , truncation=__A ) def __lowerCAmelCase ( self , __A ) -> Optional[Any]: return self.model.generate(**__A )[0] def __lowerCAmelCase ( self , __A ) -> Tuple: return self.pre_processor.decode(__A , skip_special_tokens=__A , clean_up_tokenization_spaces=__A )

"""simple docstring""" import os from math import logaa def _snake_case ( lowercase__ : str = "base_exp.txt" ) -> int: '''simple docstring''' lowerCAmelCase_ :float = 0 lowerCAmelCase_ :Union[str, Any] = 0 for i, line in enumerate(open(os.path.join(os.path.dirname(lowercase__ ) , lowercase__ ) ) ): lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = list(map(lowercase__ , line.split(""",""" ) ) ) if x * logaa(lowercase__ ) > largest: lowerCAmelCase_ :Any = x * logaa(lowercase__ ) lowerCAmelCase_ :List[Any] = i + 1 return result if __name__ == "__main__": print(solution())

"""simple docstring""" import json import logging import os import sys from pathlib import Path import finetune_rag from transformers.file_utils import is_apex_available from transformers.testing_utils import ( TestCasePlus, execute_subprocess_async, require_ray, require_torch_gpu, require_torch_multi_gpu, ) logging.basicConfig(level=logging.DEBUG) __UpperCAmelCase = logging.getLogger() __UpperCAmelCase = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class _SCREAMING_SNAKE_CASE ( A__ ): def __lowerCAmelCase ( self , __A ) -> Optional[Any]: os.makedirs(__A , exist_ok=__A ) lowerCAmelCase_ :Union[str, Any] = {"""source""": """What is love ?""", """target""": """life"""} lowerCAmelCase_ :Optional[Any] = {"""train""": 12, """val""": 2, """test""": 2} for split in ["train", "test", "val"]: for field in ["source", "target"]: lowerCAmelCase_ :Optional[Any] = """\n""".join([contents[field]] * n_lines[split] ) with open(os.path.join(__A , f"""{split}.{field}""" ) , """w""" ) as f: f.write(__A ) def __lowerCAmelCase ( self , __A , __A = "pytorch" ) -> Optional[Any]: lowerCAmelCase_ :Dict = self.get_auto_remove_tmp_dir() lowerCAmelCase_ :Optional[Any] = os.path.join(__A , """output""" ) lowerCAmelCase_ :str = os.path.join(__A , """data""" ) self._create_dummy_data(data_dir=__A ) lowerCAmelCase_ :Optional[Any] = f""" --data_dir {data_dir} \ --output_dir {output_dir} \ --model_name_or_path facebook/rag-sequence-base \ --model_type rag_sequence \ --do_train \ --do_predict \ --n_val -1 \ --val_check_interval 1.0 \ --train_batch_size 2 \ --eval_batch_size 1 \ --max_source_length 25 \ --max_target_length 25 \ --val_max_target_length 25 \ --test_max_target_length 25 \ --label_smoothing 0.1 \ --dropout 0.1 \ --attention_dropout 0.1 \ --weight_decay 0.001 \ --adam_epsilon 1e-08 \ --max_grad_norm 0.1 \ --lr_scheduler polynomial \ --learning_rate 3e-04 \ --num_train_epochs 1 \ --warmup_steps 4 \ --gradient_accumulation_steps 1 \ --distributed-port 8787 \ --use_dummy_dataset 1 \ --distributed_retriever {distributed_retriever} \ """.split() if gpus > 0: testargs.append(f"""--gpus={gpus}""" ) if is_apex_available(): testargs.append("""--fp16""" ) else: testargs.append("""--gpus=0""" ) testargs.append("""--distributed_backend=ddp_cpu""" ) testargs.append("""--num_processes=2""" ) lowerCAmelCase_ :List[Any] = [sys.executable, str(Path(finetune_rag.__file__ ).resolve() )] + testargs execute_subprocess_async(__A , env=self.get_env() ) lowerCAmelCase_ :str = os.path.join(__A , """metrics.json""" ) with open(__A ) as f: lowerCAmelCase_ :List[Any] = json.load(__A ) return result @require_torch_gpu def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Tuple = self._run_finetune(gpus=1 ) self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""] , 0.2 ) @require_torch_multi_gpu def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :str = self._run_finetune(gpus=2 ) self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""] , 0.2 ) @require_torch_gpu @require_ray def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Optional[Any] = self._run_finetune(gpus=1 , distributed_retriever="""ray""" ) self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""] , 0.2 ) @require_torch_multi_gpu @require_ray def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :int = self._run_finetune(gpus=1 , distributed_retriever="""ray""" ) self.assertGreaterEqual(result["""test"""][0]["""test_avg_em"""] , 0.2 )

"""simple docstring""" import itertools import math def _snake_case ( lowercase__ : int ) -> bool: '''simple docstring''' if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(lowercase__ ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def _snake_case ( ) -> Dict: '''simple docstring''' lowerCAmelCase_ :List[Any] = 2 while True: if is_prime(lowercase__ ): yield num num += 1 def _snake_case ( lowercase__ : int = 1_0_0_0_1 ) -> int: '''simple docstring''' return next(itertools.islice(prime_generator() , nth - 1 , lowercase__ ) ) if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING import numpy as np import pyarrow as pa from .. import config from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import torch class _SCREAMING_SNAKE_CASE ( TensorFormatter[Mapping, "torch.Tensor", Mapping] ): def __init__( self , __A=None , **__A ) -> List[Any]: super().__init__(features=__A ) lowerCAmelCase_ :List[Any] = torch_tensor_kwargs import torch # noqa import torch at initialization def __lowerCAmelCase ( self , __A ) -> str: import torch if isinstance(__A , __A ) and column: if all( isinstance(__A , torch.Tensor ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return torch.stack(__A ) return column def __lowerCAmelCase ( self , __A ) -> List[str]: import torch if isinstance(__A , (str, bytes, type(__A )) ): return value elif isinstance(__A , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() lowerCAmelCase_ :str = {} if isinstance(__A , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): lowerCAmelCase_ :str = {"""dtype""": torch.intaa} elif isinstance(__A , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): lowerCAmelCase_ :Tuple = {"""dtype""": torch.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__A , PIL.Image.Image ): lowerCAmelCase_ :Optional[Any] = np.asarray(__A ) return torch.tensor(__A , **{**default_dtype, **self.torch_tensor_kwargs} ) def __lowerCAmelCase ( self , __A ) -> Union[str, Any]: import torch # support for torch, tf, jax etc. if hasattr(__A , """__array__""" ) and not isinstance(__A , torch.Tensor ): lowerCAmelCase_ :Tuple = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__A , np.ndarray ): if data_struct.dtype == object: # torch tensors cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__A ) for substruct in data_struct] ) elif isinstance(__A , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__A ) for substruct in data_struct] ) return self._tensorize(__A ) def __lowerCAmelCase ( self , __A ) -> Optional[Any]: return map_nested(self._recursive_tensorize , __A , map_list=__A ) def __lowerCAmelCase ( self , __A ) -> Mapping: lowerCAmelCase_ :Optional[Any] = self.numpy_arrow_extractor().extract_row(__A ) lowerCAmelCase_ :List[str] = self.python_features_decoder.decode_row(__A ) return self.recursive_tensorize(__A ) def __lowerCAmelCase ( self , __A ) -> "torch.Tensor": lowerCAmelCase_ :Union[str, Any] = self.numpy_arrow_extractor().extract_column(__A ) lowerCAmelCase_ :Union[str, Any] = self.python_features_decoder.decode_column(__A , pa_table.column_names[0] ) lowerCAmelCase_ :Optional[int] = self.recursive_tensorize(__A ) lowerCAmelCase_ :List[Any] = self._consolidate(__A ) return column def __lowerCAmelCase ( self , __A ) -> Mapping: lowerCAmelCase_ :int = self.numpy_arrow_extractor().extract_batch(__A ) lowerCAmelCase_ :str = self.python_features_decoder.decode_batch(__A ) lowerCAmelCase_ :List[str] = self.recursive_tensorize(__A ) for column_name in batch: lowerCAmelCase_ :int = self._consolidate(batch[column_name] ) return batch

"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :int = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __UpperCAmelCase = logging.get_logger(__name__) class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :str UpperCAmelCase_ :str = None @staticmethod def __lowerCAmelCase ( ) -> Optional[int]: raise NotImplementedError def __lowerCAmelCase ( self , __A , __A , __A , **__A ) -> Dict: raise NotImplementedError def __lowerCAmelCase ( self , __A ) -> Optional[int]: raise NotImplementedError def __lowerCAmelCase ( self ) -> Optional[Any]: if not self.is_available(): raise RuntimeError( f"""You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.""" ) @classmethod def __lowerCAmelCase ( cls ) -> Dict: return f"""`pip install {cls.pip_package or cls.name}`""" class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[Any] = "optuna" @staticmethod def __lowerCAmelCase ( ) -> Any: return is_optuna_available() def __lowerCAmelCase ( self , __A , __A , __A , **__A ) -> List[Any]: return run_hp_search_optuna(__A , __A , __A , **__A ) def __lowerCAmelCase ( self , __A ) -> Tuple: return default_hp_space_optuna(__A ) class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Optional[int] = "ray" UpperCAmelCase_ :Any = "'ray[tune]'" @staticmethod def __lowerCAmelCase ( ) -> Optional[Any]: return is_ray_available() def __lowerCAmelCase ( self , __A , __A , __A , **__A ) -> Optional[Any]: return run_hp_search_ray(__A , __A , __A , **__A ) def __lowerCAmelCase ( self , __A ) -> str: return default_hp_space_ray(__A ) class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[str] = "sigopt" @staticmethod def __lowerCAmelCase ( ) -> Optional[int]: return is_sigopt_available() def __lowerCAmelCase ( self , __A , __A , __A , **__A ) -> List[Any]: return run_hp_search_sigopt(__A , __A , __A , **__A ) def __lowerCAmelCase ( self , __A ) -> Any: return default_hp_space_sigopt(__A ) class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Optional[Any] = "wandb" @staticmethod def __lowerCAmelCase ( ) -> List[Any]: return is_wandb_available() def __lowerCAmelCase ( self , __A , __A , __A , **__A ) -> Dict: return run_hp_search_wandb(__A , __A , __A , **__A ) def __lowerCAmelCase ( self , __A ) -> Any: return default_hp_space_wandb(__A ) __UpperCAmelCase = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def _snake_case ( ) -> str: '''simple docstring''' lowerCAmelCase_ :Union[str, Any] = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(lowercase__ ) > 0: lowerCAmelCase_ :Any = available_backends[0].name if len(lowercase__ ) > 1: logger.info( f"""{len(lowercase__ )} hyperparameter search backends available. Using {name} as the default.""" ) return name raise RuntimeError( """No hyperparameter search backend available.\n""" + """\n""".join( f""" - To install {backend.name} run {backend.pip_install()}""" for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )

"""simple docstring""" # This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/ 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, ControlNetModel, DDIMScheduler, StableDiffusionControlNetImgaImgPipeline, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import ( IMAGE_TO_IMAGE_IMAGE_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS, ) from ..test_pipelines_common import ( PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin, ) enable_full_determinism() class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :Tuple = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :List[str] = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"} ) UpperCAmelCase_ :Optional[Any] = IMAGE_TO_IMAGE_IMAGE_PARAMS def __lowerCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) lowerCAmelCase_ :Tuple = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[str] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Union[str, Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :List[Any] = CLIPTextModel(__A ) lowerCAmelCase_ :int = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Union[str, Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> List[str]: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Tuple = torch.manual_seed(__A ) else: lowerCAmelCase_ :Optional[int] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :List[Any] = 2 lowerCAmelCase_ :int = randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ) lowerCAmelCase_ :Optional[int] = floats_tensor(control_image.shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Tuple = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :Union[str, Any] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> int: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Union[str, Any]: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) class _SCREAMING_SNAKE_CASE ( A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :List[str] = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :int = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :int = frozenset([] ) # TO_DO: add image_params once refactored VaeImageProcessor.preprocess def __lowerCAmelCase ( self ) -> Optional[int]: torch.manual_seed(0 ) lowerCAmelCase_ :Dict = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) def init_weights(__A ): if isinstance(__A , torch.nn.Convad ): torch.nn.init.normal(m.weight ) m.bias.data.fill_(1.0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[int] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :str = CLIPTextModel(__A ) lowerCAmelCase_ :str = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Optional[Any] = MultiControlNetModel([controlneta, controlneta] ) lowerCAmelCase_ :List[Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> str: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Optional[Any] = torch.manual_seed(__A ) else: lowerCAmelCase_ :List[Any] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :Optional[Any] = 2 lowerCAmelCase_ :Optional[int] = [ randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), ] lowerCAmelCase_ :int = floats_tensor(control_image[0].shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Optional[Any] = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :List[str] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) lowerCAmelCase_ :Union[str, Any] = 1_0.0 lowerCAmelCase_ :Union[str, Any] = 4 lowerCAmelCase_ :Tuple = self.get_dummy_inputs(__A ) lowerCAmelCase_ :List[str] = steps lowerCAmelCase_ :int = scale lowerCAmelCase_ :Union[str, Any] = pipe(**__A )[0] lowerCAmelCase_ :Any = self.get_dummy_inputs(__A ) lowerCAmelCase_ :str = steps lowerCAmelCase_ :str = scale lowerCAmelCase_ :Tuple = pipe(**__A , control_guidance_start=0.1 , control_guidance_end=0.2 )[0] lowerCAmelCase_ :Optional[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Union[str, Any] = steps lowerCAmelCase_ :Union[str, Any] = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=[0.1, 0.3] , control_guidance_end=[0.2, 0.7] )[0] lowerCAmelCase_ :List[str] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Optional[int] = steps lowerCAmelCase_ :Tuple = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=0.4 , control_guidance_end=[0.5, 0.8] )[0] # make sure that all outputs are different assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 def __lowerCAmelCase ( self ) -> Dict: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Tuple: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> Optional[int]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :str = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) with tempfile.TemporaryDirectory() as tmpdir: try: # save_pretrained is not implemented for Multi-ControlNet pipe.save_pretrained(__A ) except NotImplementedError: pass @slow @require_torch_gpu class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> int: super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Any = ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny""" ) lowerCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline.from_pretrained( """runwayml/stable-diffusion-v1-5""" , safety_checker=__A , controlnet=__A ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[str] = torch.Generator(device="""cpu""" ).manual_seed(0 ) lowerCAmelCase_ :List[Any] = """evil space-punk bird""" lowerCAmelCase_ :List[Any] = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png""" ).resize((512, 512) ) lowerCAmelCase_ :int = load_image( """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png""" ).resize((512, 512) ) lowerCAmelCase_ :Union[str, Any] = pipe( __A , __A , control_image=__A , generator=__A , output_type="""np""" , num_inference_steps=50 , strength=0.6 , ) lowerCAmelCase_ :Tuple = output.images[0] assert image.shape == (512, 512, 3) lowerCAmelCase_ :Tuple = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy""" ) assert np.abs(expected_image - image ).max() < 9E-2

"""simple docstring""" import argparse import json from pathlib import Path import requests import torch from huggingface_hub import cached_download, hf_hub_download, hf_hub_url from PIL import Image from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig from transformers.utils import logging logging.set_verbosity_info() __UpperCAmelCase = logging.get_logger(__name__) def _snake_case ( lowercase__ : str ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :Any = SwinConfig( embed_dim=1_9_2 , depths=(2, 2, 1_8, 2) , num_heads=(6, 1_2, 2_4, 4_8) , window_size=1_2 , out_features=["""stage2""", """stage3""", """stage4"""] , ) lowerCAmelCase_ :str = DetaConfig( backbone_config=lowercase__ , num_queries=9_0_0 , encoder_ffn_dim=2_0_4_8 , decoder_ffn_dim=2_0_4_8 , num_feature_levels=5 , assign_first_stage=lowercase__ , with_box_refine=lowercase__ , two_stage=lowercase__ , ) # set labels lowerCAmelCase_ :List[Any] = """huggingface/label-files""" if "o365" in model_name: lowerCAmelCase_ :Union[str, Any] = 3_6_6 lowerCAmelCase_ :Union[str, Any] = """object365-id2label.json""" else: lowerCAmelCase_ :Any = 9_1 lowerCAmelCase_ :Optional[Any] = """coco-detection-id2label.json""" lowerCAmelCase_ :str = num_labels lowerCAmelCase_ :List[str] = json.load(open(cached_download(hf_hub_url(lowercase__ , lowercase__ , repo_type="""dataset""" ) ) , """r""" ) ) lowerCAmelCase_ :Union[str, Any] = {int(lowercase__ ): v for k, v in idalabel.items()} lowerCAmelCase_ :str = idalabel lowerCAmelCase_ :Optional[Any] = {v: k for k, v in idalabel.items()} return config def _snake_case ( lowercase__ : Optional[int] ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase_ :Dict = [] # stem # fmt: off rename_keys.append(("""backbone.0.body.patch_embed.proj.weight""", """model.backbone.model.embeddings.patch_embeddings.projection.weight""") ) rename_keys.append(("""backbone.0.body.patch_embed.proj.bias""", """model.backbone.model.embeddings.patch_embeddings.projection.bias""") ) rename_keys.append(("""backbone.0.body.patch_embed.norm.weight""", """model.backbone.model.embeddings.norm.weight""") ) rename_keys.append(("""backbone.0.body.patch_embed.norm.bias""", """model.backbone.model.embeddings.norm.bias""") ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""") ) if i < 3: rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.reduction.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""") ) rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.bias""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""") ) rename_keys.append(("""backbone.0.body.norm1.weight""", """model.backbone.model.hidden_states_norms.stage2.weight""") ) rename_keys.append(("""backbone.0.body.norm1.bias""", """model.backbone.model.hidden_states_norms.stage2.bias""") ) rename_keys.append(("""backbone.0.body.norm2.weight""", """model.backbone.model.hidden_states_norms.stage3.weight""") ) rename_keys.append(("""backbone.0.body.norm2.bias""", """model.backbone.model.hidden_states_norms.stage3.bias""") ) rename_keys.append(("""backbone.0.body.norm3.weight""", """model.backbone.model.hidden_states_norms.stage4.weight""") ) rename_keys.append(("""backbone.0.body.norm3.bias""", """model.backbone.model.hidden_states_norms.stage4.bias""") ) # transformer encoder for i in range(config.encoder_layers ): rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", f"""model.encoder.layers.{i}.self_attn.attention_weights.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", f"""model.encoder.layers.{i}.self_attn.attention_weights.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", f"""model.encoder.layers.{i}.self_attn.value_proj.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", f"""model.encoder.layers.{i}.self_attn.value_proj.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", f"""model.encoder.layers.{i}.self_attn.output_proj.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", f"""model.encoder.layers.{i}.self_attn.output_proj.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.weight""", f"""model.encoder.layers.{i}.self_attn_layer_norm.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.bias""", f"""model.encoder.layers.{i}.self_attn_layer_norm.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""model.encoder.layers.{i}.fc1.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""model.encoder.layers.{i}.fc1.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""model.encoder.layers.{i}.fc2.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""model.encoder.layers.{i}.fc2.bias""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.weight""", f"""model.encoder.layers.{i}.final_layer_norm.weight""") ) rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""model.encoder.layers.{i}.final_layer_norm.bias""") ) # transformer decoder for i in range(config.decoder_layers ): rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.weight""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.bias""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""model.decoder.layers.{i}.self_attn.out_proj.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""model.decoder.layers.{i}.self_attn.out_proj.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.weight""", f"""model.decoder.layers.{i}.self_attn_layer_norm.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.bias""", f"""model.decoder.layers.{i}.self_attn_layer_norm.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""model.decoder.layers.{i}.fc1.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""model.decoder.layers.{i}.fc1.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""model.decoder.layers.{i}.fc2.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""model.decoder.layers.{i}.fc2.bias""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.weight""", f"""model.decoder.layers.{i}.final_layer_norm.weight""") ) rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""model.decoder.layers.{i}.final_layer_norm.bias""") ) # fmt: on return rename_keys def _snake_case ( lowercase__ : int , lowercase__ : Union[str, Any] , lowercase__ : List[Any] ) -> Dict: '''simple docstring''' lowerCAmelCase_ :str = dct.pop(lowercase__ ) lowerCAmelCase_ :int = val def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : Union[str, Any] ) -> str: '''simple docstring''' lowerCAmelCase_ :int = [int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )] for i in range(len(backbone_config.depths ) ): lowerCAmelCase_ :Optional[int] = num_features[i] for j in range(backbone_config.depths[i] ): # fmt: off # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias) lowerCAmelCase_ :Tuple = state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight""" ) lowerCAmelCase_ :Any = state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict lowerCAmelCase_ :Optional[Any] = in_proj_weight[:dim, :] lowerCAmelCase_ :Dict = in_proj_bias[: dim] lowerCAmelCase_ :Optional[Any] = in_proj_weight[ dim : dim * 2, : ] lowerCAmelCase_ :List[Any] = in_proj_bias[ dim : dim * 2 ] lowerCAmelCase_ :List[str] = in_proj_weight[ -dim :, : ] lowerCAmelCase_ :List[Any] = in_proj_bias[-dim :] # fmt: on def _snake_case ( lowercase__ : str , lowercase__ : int ) -> Any: '''simple docstring''' lowerCAmelCase_ :Any = config.d_model for i in range(config.decoder_layers ): # read in weights + bias of input projection layer of self-attention lowerCAmelCase_ :List[Any] = state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_weight""" ) lowerCAmelCase_ :Union[str, Any] = state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_bias""" ) # next, add query, keys and values (in that order) to the state dict lowerCAmelCase_ :List[str] = in_proj_weight[:hidden_size, :] lowerCAmelCase_ :Optional[int] = in_proj_bias[:hidden_size] lowerCAmelCase_ :Optional[int] = in_proj_weight[ hidden_size : hidden_size * 2, : ] lowerCAmelCase_ :int = in_proj_bias[hidden_size : hidden_size * 2] lowerCAmelCase_ :Dict = in_proj_weight[-hidden_size:, :] lowerCAmelCase_ :List[Any] = in_proj_bias[-hidden_size:] def _snake_case ( ) -> Optional[int]: '''simple docstring''' lowerCAmelCase_ :Any = """http://images.cocodataset.org/val2017/000000039769.jpg""" lowerCAmelCase_ :Tuple = Image.open(requests.get(lowercase__ , stream=lowercase__ ).raw ) return im @torch.no_grad() def _snake_case ( lowercase__ : Dict , lowercase__ : Optional[Any] , lowercase__ : List[str] ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :str = get_deta_config(lowercase__ ) # load original state dict if model_name == "deta-swin-large": lowerCAmelCase_ :str = hf_hub_download(repo_id="""nielsr/deta-checkpoints""" , filename="""adet_swin_ft.pth""" ) elif model_name == "deta-swin-large-o365": lowerCAmelCase_ :Union[str, Any] = hf_hub_download(repo_id="""jozhang97/deta-swin-l-o365""" , filename="""deta_swin_pt_o365.pth""" ) else: raise ValueError(f"""Model name {model_name} not supported""" ) lowerCAmelCase_ :int = torch.load(lowercase__ , map_location="""cpu""" )["""model"""] # original state dict for name, param in state_dict.items(): print(lowercase__ , param.shape ) # rename keys lowerCAmelCase_ :Any = create_rename_keys(lowercase__ ) for src, dest in rename_keys: rename_key(lowercase__ , lowercase__ , lowercase__ ) read_in_swin_q_k_v(lowercase__ , config.backbone_config ) read_in_decoder_q_k_v(lowercase__ , lowercase__ ) # fix some prefixes for key in state_dict.copy().keys(): if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key: lowerCAmelCase_ :List[str] = state_dict.pop(lowercase__ ) lowerCAmelCase_ :Optional[int] = val if "input_proj" in key: lowerCAmelCase_ :str = state_dict.pop(lowercase__ ) lowerCAmelCase_ :List[str] = val if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key: lowerCAmelCase_ :List[str] = state_dict.pop(lowercase__ ) lowerCAmelCase_ :Tuple = val # finally, create HuggingFace model and load state dict lowerCAmelCase_ :Any = DetaForObjectDetection(lowercase__ ) model.load_state_dict(lowercase__ ) model.eval() lowerCAmelCase_ :Optional[int] = """cuda""" if torch.cuda.is_available() else """cpu""" model.to(lowercase__ ) # load image processor lowerCAmelCase_ :Any = DetaImageProcessor(format="""coco_detection""" ) # verify our conversion on image lowerCAmelCase_ :str = prepare_img() lowerCAmelCase_ :int = processor(images=lowercase__ , return_tensors="""pt""" ) lowerCAmelCase_ :int = encoding["""pixel_values"""] lowerCAmelCase_ :Tuple = model(pixel_values.to(lowercase__ ) ) # verify logits print("""Logits:""" , outputs.logits[0, :3, :3] ) print("""Boxes:""" , outputs.pred_boxes[0, :3, :3] ) if model_name == "deta-swin-large": lowerCAmelCase_ :Optional[int] = torch.tensor( [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]] ) lowerCAmelCase_ :Union[str, Any] = torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]] ) elif model_name == "deta-swin-large-o365": lowerCAmelCase_ :Union[str, Any] = torch.tensor( [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]] ) lowerCAmelCase_ :Optional[int] = torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]] ) assert torch.allclose(outputs.logits[0, :3, :3] , expected_logits.to(lowercase__ ) , atol=1E-4 ) assert torch.allclose(outputs.pred_boxes[0, :3, :3] , expected_boxes.to(lowercase__ ) , atol=1E-4 ) print("""Everything ok!""" ) if pytorch_dump_folder_path: # Save model and processor logger.info(f"""Saving PyTorch model and processor to {pytorch_dump_folder_path}...""" ) Path(lowercase__ ).mkdir(exist_ok=lowercase__ ) model.save_pretrained(lowercase__ ) processor.save_pretrained(lowercase__ ) # Push to hub if push_to_hub: print("""Pushing model and processor to hub...""" ) model.push_to_hub(f"""jozhang97/{model_name}""" ) processor.push_to_hub(f"""jozhang97/{model_name}""" ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() parser.add_argument( '--model_name', type=str, default='deta-swin-large', choices=['deta-swin-large', 'deta-swin-large-o365'], help='Name of the model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.', ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) __UpperCAmelCase = parser.parse_args() convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

"""simple docstring""" from typing import Optional import numpy as np import torch from torch import nn from transformers import GPTaConfig, GPTaLMHeadModel from transformers.modeling_utils import ModuleUtilsMixin from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ ): UpperCAmelCase_ :List[str] = [r"h\.\d+\.attn\.bias", r"h\.\d+\.attn\.masked_bias"] @register_to_config def __init__( self , __A , __A , __A = None , __A = 5_0257 , __A = 1024 , __A = 768 , __A = 12 , __A = 12 , __A = None , __A = "gelu_new" , __A = 0.1 , __A = 0.1 , __A = 0.1 , __A = 1E-5 , __A = 0.0_2 , __A = True , __A = True , __A = False , __A = False , ) -> Optional[Any]: super().__init__() lowerCAmelCase_ :List[str] = prefix_length if prefix_inner_dim != n_embd and prefix_hidden_dim is None: raise ValueError( f"""`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and""" f""" `n_embd`: {n_embd} are not equal.""" ) lowerCAmelCase_ :Union[str, Any] = prefix_inner_dim lowerCAmelCase_ :str = prefix_hidden_dim lowerCAmelCase_ :str = ( nn.Linear(self.prefix_inner_dim , self.prefix_hidden_dim ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :List[Any] = ( nn.Linear(self.prefix_hidden_dim , __A ) if self.prefix_hidden_dim is not None else nn.Identity() ) lowerCAmelCase_ :Any = GPTaConfig( vocab_size=__A , n_positions=__A , n_embd=__A , n_layer=__A , n_head=__A , n_inner=__A , activation_function=__A , resid_pdrop=__A , embd_pdrop=__A , attn_pdrop=__A , layer_norm_epsilon=__A , initializer_range=__A , scale_attn_weights=__A , use_cache=__A , scale_attn_by_inverse_layer_idx=__A , reorder_and_upcast_attn=__A , ) lowerCAmelCase_ :Any = GPTaLMHeadModel(__A ) def __lowerCAmelCase ( self , __A , __A , __A = None , __A = None , ) -> List[str]: lowerCAmelCase_ :str = self.transformer.transformer.wte(__A ) lowerCAmelCase_ :Any = self.encode_prefix(__A ) lowerCAmelCase_ :Optional[Any] = self.decode_prefix(__A ) lowerCAmelCase_ :Optional[int] = torch.cat((prefix_embeds, embedding_text) , dim=1 ) if labels is not None: lowerCAmelCase_ :int = self.get_dummy_token(input_ids.shape[0] , input_ids.device ) lowerCAmelCase_ :Optional[Any] = torch.cat((dummy_token, input_ids) , dim=1 ) lowerCAmelCase_ :Tuple = self.transformer(inputs_embeds=__A , labels=__A , attention_mask=__A ) if self.prefix_hidden_dim is not None: return out, hidden else: return out def __lowerCAmelCase ( self , __A , __A ) -> torch.Tensor: return torch.zeros(__A , self.prefix_length , dtype=torch.intaa , device=__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: return self.encode_prefix(__A ) @torch.no_grad() def __lowerCAmelCase ( self , __A , __A , __A ) -> Optional[int]: lowerCAmelCase_ :Tuple = torch.split(__A , 1 , dim=0 ) lowerCAmelCase_ :Optional[int] = [] lowerCAmelCase_ :List[str] = [] for feature in features: lowerCAmelCase_ :Tuple = self.decode_prefix(feature.to(__A ) ) # back to the clip feature # Only support beam search for now lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.generate_beam( input_embeds=__A , device=__A , eos_token_id=__A ) generated_tokens.append(output_tokens[0] ) generated_seq_lengths.append(seq_lengths[0] ) lowerCAmelCase_ :Tuple = torch.stack(__A ) lowerCAmelCase_ :int = torch.stack(__A ) return generated_tokens, generated_seq_lengths @torch.no_grad() def __lowerCAmelCase ( self , __A=None , __A=None , __A=None , __A = 5 , __A = 67 , __A = 1.0 , __A = None , ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = eos_token_id lowerCAmelCase_ :Optional[int] = None lowerCAmelCase_ :Any = None lowerCAmelCase_ :int = torch.ones(__A , device=__A , dtype=torch.int ) lowerCAmelCase_ :Optional[int] = torch.zeros(__A , device=__A , dtype=torch.bool ) if input_embeds is not None: lowerCAmelCase_ :List[str] = input_embeds else: lowerCAmelCase_ :Union[str, Any] = self.transformer.transformer.wte(__A ) for i in range(__A ): lowerCAmelCase_ :Optional[int] = self.transformer(inputs_embeds=__A ) lowerCAmelCase_ :str = outputs.logits lowerCAmelCase_ :str = logits[:, -1, :] / (temperature if temperature > 0 else 1.0) lowerCAmelCase_ :Dict = logits.softmax(-1 ).log() if scores is None: lowerCAmelCase_ , lowerCAmelCase_ :Any = logits.topk(__A , -1 ) lowerCAmelCase_ :Union[str, Any] = generated.expand(__A , *generated.shape[1:] ) lowerCAmelCase_ , lowerCAmelCase_ :List[str] = next_tokens.permute(1 , 0 ), scores.squeeze(0 ) if tokens is None: lowerCAmelCase_ :List[str] = next_tokens else: lowerCAmelCase_ :List[Any] = tokens.expand(__A , *tokens.shape[1:] ) lowerCAmelCase_ :Any = torch.cat((tokens, next_tokens) , dim=1 ) else: lowerCAmelCase_ :List[Any] = -float(np.inf ) lowerCAmelCase_ :int = 0 lowerCAmelCase_ :Optional[int] = scores[:, None] + logits seq_lengths[~is_stopped] += 1 lowerCAmelCase_ :List[Any] = scores_sum / seq_lengths[:, None] lowerCAmelCase_ , lowerCAmelCase_ :Tuple = scores_sum_average.view(-1 ).topk(__A , -1 ) lowerCAmelCase_ :Optional[Any] = next_tokens // scores_sum.shape[1] lowerCAmelCase_ :Dict = seq_lengths[next_tokens_source] lowerCAmelCase_ :Tuple = next_tokens % scores_sum.shape[1] lowerCAmelCase_ :Optional[Any] = next_tokens.unsqueeze(1 ) lowerCAmelCase_ :str = tokens[next_tokens_source] lowerCAmelCase_ :List[Any] = torch.cat((tokens, next_tokens) , dim=1 ) lowerCAmelCase_ :Dict = generated[next_tokens_source] lowerCAmelCase_ :Dict = scores_sum_average * seq_lengths lowerCAmelCase_ :Tuple = is_stopped[next_tokens_source] lowerCAmelCase_ :str = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] , 1 , -1 ) lowerCAmelCase_ :List[Any] = torch.cat((generated, next_token_embed) , dim=1 ) lowerCAmelCase_ :Optional[int] = is_stopped + next_tokens.eq(__A ).squeeze() if is_stopped.all(): break lowerCAmelCase_ :str = scores / seq_lengths lowerCAmelCase_ :Optional[int] = scores.argsort(descending=__A ) # tokens tensors are already padded to max_seq_length lowerCAmelCase_ :Optional[Any] = [tokens[i] for i in order] lowerCAmelCase_ :Dict = torch.stack(__A , dim=0 ) lowerCAmelCase_ :Tuple = torch.tensor([seq_lengths[i] for i in order] , dtype=seq_lengths.dtype ) return output_texts, seq_lengths

"""simple docstring""" from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxSeqaSeqConfigWithPast from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'google/umt5-small': 'https://huggingface.co/google/umt5-small/resolve/main/config.json', # See all umt5 models at https://huggingface.co/models?filter=umt5 } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :str = "umt5" UpperCAmelCase_ :Union[str, Any] = ["past_key_values"] def __init__( self , __A=25_0112 , __A=512 , __A=64 , __A=1024 , __A=8 , __A=None , __A=6 , __A=32 , __A=128 , __A=0.1 , __A=1E-6 , __A=1.0 , __A="gated-gelu" , __A=True , __A=True , __A="T5Tokenizer" , __A=True , __A=0 , __A=1 , __A=0 , **__A , ) -> Tuple: super().__init__( is_encoder_decoder=__A , tokenizer_class=__A , tie_word_embeddings=__A , pad_token_id=__A , eos_token_id=__A , decoder_start_token_id=__A , **__A , ) lowerCAmelCase_ :Optional[Any] = vocab_size lowerCAmelCase_ :List[Any] = d_model lowerCAmelCase_ :Dict = d_kv lowerCAmelCase_ :List[Any] = d_ff lowerCAmelCase_ :str = num_layers lowerCAmelCase_ :List[str] = ( num_decoder_layers if num_decoder_layers is not None else self.num_layers ) # default = symmetry lowerCAmelCase_ :Tuple = num_heads lowerCAmelCase_ :List[Any] = relative_attention_num_buckets lowerCAmelCase_ :Tuple = relative_attention_max_distance lowerCAmelCase_ :Optional[Any] = dropout_rate lowerCAmelCase_ :Optional[Any] = layer_norm_epsilon lowerCAmelCase_ :Tuple = initializer_factor lowerCAmelCase_ :Optional[Any] = feed_forward_proj lowerCAmelCase_ :List[str] = use_cache lowerCAmelCase_ :List[Any] = self.feed_forward_proj.split("""-""" ) lowerCAmelCase_ :Optional[Any] = act_info[-1] lowerCAmelCase_ :Any = act_info[0] == """gated""" if len(__A ) > 1 and act_info[0] != "gated" or len(__A ) > 2: raise ValueError( f"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.""" """Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. """ """'gated-gelu' or 'relu'""" ) if feed_forward_proj == "gated-gelu": lowerCAmelCase_ :List[Any] = """gelu_new""" @property def __lowerCAmelCase ( self ) -> int: return self.d_model @property def __lowerCAmelCase ( self ) -> List[str]: return self.num_heads @property def __lowerCAmelCase ( self ) -> str: return self.num_layers class _SCREAMING_SNAKE_CASE ( A__ ): @property # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs def __lowerCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: lowerCAmelCase_ :List[Any] = { """input_ids""": {0: """batch""", 1: """encoder_sequence"""}, """attention_mask""": {0: """batch""", 1: """encoder_sequence"""}, } if self.use_past: lowerCAmelCase_ :Optional[int] = """past_encoder_sequence + sequence""" lowerCAmelCase_ :List[Any] = {0: """batch"""} lowerCAmelCase_ :List[str] = {0: """batch""", 1: """past_decoder_sequence + sequence"""} else: lowerCAmelCase_ :List[str] = {0: """batch""", 1: """decoder_sequence"""} lowerCAmelCase_ :Optional[int] = {0: """batch""", 1: """decoder_sequence"""} if self.use_past: self.fill_with_past_key_values_(__A , direction="""inputs""" ) return common_inputs @property # Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset def __lowerCAmelCase ( self ) -> int: return 13 @property def __lowerCAmelCase ( self ) -> float: return 5E-4

"""simple docstring""" import copy from collections import OrderedDict from typing import Dict, Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto import CONFIG_MAPPING __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = { 'facebook/detr-resnet-50': 'https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json', # See all DETR models at https://huggingface.co/models?filter=detr } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :str = "detr" UpperCAmelCase_ :str = ["past_key_values"] UpperCAmelCase_ :Tuple = { "hidden_size": "d_model", "num_attention_heads": "encoder_attention_heads", } def __init__( self , __A=True , __A=None , __A=3 , __A=100 , __A=6 , __A=2048 , __A=8 , __A=6 , __A=2048 , __A=8 , __A=0.0 , __A=0.0 , __A=True , __A="relu" , __A=256 , __A=0.1 , __A=0.0 , __A=0.0 , __A=0.0_2 , __A=1.0 , __A=False , __A="sine" , __A="resnet50" , __A=True , __A=False , __A=1 , __A=5 , __A=2 , __A=1 , __A=1 , __A=5 , __A=2 , __A=0.1 , **__A , ) -> List[Any]: if backbone_config is not None and use_timm_backbone: raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`.""" ) if not use_timm_backbone: if backbone_config is None: logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.""" ) lowerCAmelCase_ :int = CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""] ) elif isinstance(__A , __A ): lowerCAmelCase_ :str = backbone_config.get("""model_type""" ) lowerCAmelCase_ :List[Any] = CONFIG_MAPPING[backbone_model_type] lowerCAmelCase_ :Optional[Any] = config_class.from_dict(__A ) # set timm attributes to None lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = None, None, None lowerCAmelCase_ :Tuple = use_timm_backbone lowerCAmelCase_ :Optional[int] = backbone_config lowerCAmelCase_ :Optional[int] = num_channels lowerCAmelCase_ :int = num_queries lowerCAmelCase_ :List[Any] = d_model lowerCAmelCase_ :Optional[int] = encoder_ffn_dim lowerCAmelCase_ :Tuple = encoder_layers lowerCAmelCase_ :int = encoder_attention_heads lowerCAmelCase_ :Optional[Any] = decoder_ffn_dim lowerCAmelCase_ :List[str] = decoder_layers lowerCAmelCase_ :Dict = decoder_attention_heads lowerCAmelCase_ :Dict = dropout lowerCAmelCase_ :Tuple = attention_dropout lowerCAmelCase_ :Union[str, Any] = activation_dropout lowerCAmelCase_ :Any = activation_function lowerCAmelCase_ :List[str] = init_std lowerCAmelCase_ :Optional[int] = init_xavier_std lowerCAmelCase_ :int = encoder_layerdrop lowerCAmelCase_ :Union[str, Any] = decoder_layerdrop lowerCAmelCase_ :List[str] = encoder_layers lowerCAmelCase_ :Union[str, Any] = auxiliary_loss lowerCAmelCase_ :str = position_embedding_type lowerCAmelCase_ :List[Any] = backbone lowerCAmelCase_ :str = use_pretrained_backbone lowerCAmelCase_ :str = dilation # Hungarian matcher lowerCAmelCase_ :List[Any] = class_cost lowerCAmelCase_ :Union[str, Any] = bbox_cost lowerCAmelCase_ :Tuple = giou_cost # Loss coefficients lowerCAmelCase_ :Optional[int] = mask_loss_coefficient lowerCAmelCase_ :Union[str, Any] = dice_loss_coefficient lowerCAmelCase_ :Tuple = bbox_loss_coefficient lowerCAmelCase_ :Tuple = giou_loss_coefficient lowerCAmelCase_ :Dict = eos_coefficient super().__init__(is_encoder_decoder=__A , **__A ) @property def __lowerCAmelCase ( self ) -> int: return self.encoder_attention_heads @property def __lowerCAmelCase ( self ) -> int: return self.d_model @classmethod def __lowerCAmelCase ( cls , __A , **__A ) -> Any: return cls(backbone_config=__A , **__A ) def __lowerCAmelCase ( self ) -> Dict[str, any]: lowerCAmelCase_ :List[str] = copy.deepcopy(self.__dict__ ) if output["backbone_config"] is not None: lowerCAmelCase_ :Dict = self.backbone_config.to_dict() lowerCAmelCase_ :str = self.__class__.model_type return output class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[Any] = version.parse("1.11" ) @property def __lowerCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ("""pixel_mask""", {0: """batch"""}), ] ) @property def __lowerCAmelCase ( self ) -> float: return 1E-5 @property def __lowerCAmelCase ( self ) -> int: return 12

"""simple docstring""" from __future__ import annotations from math import pow, sqrt def _snake_case ( lowercase__ : float , lowercase__ : float , lowercase__ : float ) -> dict[str, float]: '''simple docstring''' if (resistance, reactance, impedance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if resistance == 0: return {"resistance": sqrt(pow(lowercase__ , 2 ) - pow(lowercase__ , 2 ) )} elif reactance == 0: return {"reactance": sqrt(pow(lowercase__ , 2 ) - pow(lowercase__ , 2 ) )} elif impedance == 0: return {"impedance": sqrt(pow(lowercase__ , 2 ) + pow(lowercase__ , 2 ) )} else: raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available, is_vision_available, ) __UpperCAmelCase = {'configuration_deit': ['DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeiTConfig', 'DeiTOnnxConfig']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['DeiTFeatureExtractor'] __UpperCAmelCase = ['DeiTImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'DEIT_PRETRAINED_MODEL_ARCHIVE_LIST', 'DeiTForImageClassification', 'DeiTForImageClassificationWithTeacher', 'DeiTForMaskedImageModeling', 'DeiTModel', 'DeiTPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFDeiTForImageClassification', 'TFDeiTForImageClassificationWithTeacher', 'TFDeiTForMaskedImageModeling', 'TFDeiTModel', 'TFDeiTPreTrainedModel', ] if TYPE_CHECKING: from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_deit import DeiTFeatureExtractor from .image_processing_deit import DeiTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_deit import ( DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, DeiTModel, DeiTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_deit import ( TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher, TFDeiTForMaskedImageModeling, TFDeiTModel, TFDeiTPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

"""simple docstring""" import warnings from ...utils import logging from .image_processing_owlvit import OwlViTImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , *__A , **__A ) -> None: warnings.warn( """The class OwlViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use OwlViTImageProcessor instead.""" , __A , ) super().__init__(*__A , **__A )

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __UpperCAmelCase = { 'configuration_squeezebert': [ 'SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SqueezeBertConfig', 'SqueezeBertOnnxConfig', ], 'tokenization_squeezebert': ['SqueezeBertTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['SqueezeBertTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'SqueezeBertForMaskedLM', 'SqueezeBertForMultipleChoice', 'SqueezeBertForQuestionAnswering', 'SqueezeBertForSequenceClassification', 'SqueezeBertForTokenClassification', 'SqueezeBertModel', 'SqueezeBertModule', 'SqueezeBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_squeezebert import ( SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, SqueezeBertConfig, SqueezeBertOnnxConfig, ) from .tokenization_squeezebert import SqueezeBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_squeezebert_fast import SqueezeBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_squeezebert import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, SqueezeBertModule, SqueezeBertPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

"""simple docstring""" import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'} __UpperCAmelCase = { 'vocab_file': { 'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json', }, 'merges_file': { 'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt', }, 'tokenizer_file': { 'allenai/led-base-16384': 'https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json', }, } __UpperCAmelCase = { 'allenai/led-base-16384': 1_63_84, } class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Any = VOCAB_FILES_NAMES UpperCAmelCase_ :Optional[Any] = PRETRAINED_VOCAB_FILES_MAP UpperCAmelCase_ :Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCAmelCase_ :Tuple = LEDTokenizer UpperCAmelCase_ :Union[str, Any] = ["input_ids", "attention_mask"] def __init__( self , __A=None , __A=None , __A=None , __A="replace" , __A="<s>" , __A="</s>" , __A="</s>" , __A="<s>" , __A="<unk>" , __A="<pad>" , __A="<mask>" , __A=False , __A=True , **__A , ) -> int: super().__init__( __A , __A , tokenizer_file=__A , errors=__A , bos_token=__A , eos_token=__A , sep_token=__A , cls_token=__A , unk_token=__A , pad_token=__A , mask_token=__A , add_prefix_space=__A , trim_offsets=__A , **__A , ) lowerCAmelCase_ :str = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get("""add_prefix_space""" , __A ) != add_prefix_space: lowerCAmelCase_ :Union[str, Any] = getattr(__A , pre_tok_state.pop("""type""" ) ) lowerCAmelCase_ :Any = add_prefix_space lowerCAmelCase_ :Dict = pre_tok_class(**__A ) lowerCAmelCase_ :Optional[Any] = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` lowerCAmelCase_ :int = """post_processor""" lowerCAmelCase_ :Dict = getattr(self.backend_tokenizer , __A , __A ) if tokenizer_component_instance: lowerCAmelCase_ :Tuple = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: lowerCAmelCase_ :Tuple = tuple(state["""sep"""] ) if "cls" in state: lowerCAmelCase_ :Dict = tuple(state["""cls"""] ) lowerCAmelCase_ :Dict = False if state.get("""add_prefix_space""" , __A ) != add_prefix_space: lowerCAmelCase_ :str = add_prefix_space lowerCAmelCase_ :str = True if state.get("""trim_offsets""" , __A ) != trim_offsets: lowerCAmelCase_ :Tuple = trim_offsets lowerCAmelCase_ :Tuple = True if changes_to_apply: lowerCAmelCase_ :Tuple = getattr(__A , state.pop("""type""" ) ) lowerCAmelCase_ :List[str] = component_class(**__A ) setattr(self.backend_tokenizer , __A , __A ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def __lowerCAmelCase ( self ) -> str: if self._mask_token is None: if self.verbose: logger.error("""Using mask_token, but it is not set yet.""" ) return None return str(self._mask_token ) @mask_token.setter def __lowerCAmelCase ( self , __A ) -> Any: lowerCAmelCase_ :Dict = AddedToken(__A , lstrip=__A , rstrip=__A ) if isinstance(__A , __A ) else value lowerCAmelCase_ :int = value def __lowerCAmelCase ( self , *__A , **__A ) -> BatchEncoding: lowerCAmelCase_ :Optional[Any] = kwargs.get("""is_split_into_words""" , __A ) if is_split_into_words and not self.add_prefix_space: raise ValueError( f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ """to use it with pretokenized inputs.""" ) return super()._batch_encode_plus(*__A , **__A ) def __lowerCAmelCase ( self , *__A , **__A ) -> BatchEncoding: lowerCAmelCase_ :str = kwargs.get("""is_split_into_words""" , __A ) if is_split_into_words and not self.add_prefix_space: raise ValueError( f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ """to use it with pretokenized inputs.""" ) return super()._encode_plus(*__A , **__A ) def __lowerCAmelCase ( self , __A , __A = None ) -> Tuple[str]: lowerCAmelCase_ :Tuple = self._tokenizer.model.save(__A , name=__A ) return tuple(__A ) def __lowerCAmelCase ( self , __A , __A=None ) -> Tuple: lowerCAmelCase_ :List[Any] = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def __lowerCAmelCase ( self , __A , __A = None ) -> List[int]: lowerCAmelCase_ :Any = [self.sep_token_id] lowerCAmelCase_ :Optional[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 , __A , __A = None , __A = PaddingStrategy.DO_NOT_PAD , __A = None , __A = None , ) -> dict: lowerCAmelCase_ :Tuple = super()._pad( encoded_inputs=__A , max_length=__A , padding_strategy=__A , pad_to_multiple_of=__A , return_attention_mask=__A , ) # Load from model defaults if return_attention_mask is None: lowerCAmelCase_ :List[str] = """attention_mask""" in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: lowerCAmelCase_ :List[str] = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. lowerCAmelCase_ :Dict = len(encoded_inputs["""global_attention_mask"""] ) != len(__A ) if needs_to_be_padded: lowerCAmelCase_ :Any = len(__A ) - len(encoded_inputs["""global_attention_mask"""] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` lowerCAmelCase_ :Tuple = ( encoded_inputs["""global_attention_mask"""] + [-1] * difference ) elif self.padding_side == "left": lowerCAmelCase_ :Optional[int] = [-1] * difference + encoded_inputs[ """global_attention_mask""" ] else: raise ValueError("""Invalid padding strategy:""" + str(self.padding_side ) ) return encoded_inputs

"""simple docstring""" __UpperCAmelCase = 2_56 # Modulus to hash a string __UpperCAmelCase = 1_00_00_03 def _snake_case ( lowercase__ : str , lowercase__ : str ) -> bool: '''simple docstring''' lowerCAmelCase_ :Tuple = len(lowercase__ ) lowerCAmelCase_ :List[str] = len(lowercase__ ) if p_len > t_len: return False lowerCAmelCase_ :List[str] = 0 lowerCAmelCase_ :Optional[int] = 0 lowerCAmelCase_ :Any = 1 # Calculating the hash of pattern and substring of text for i in range(lowercase__ ): lowerCAmelCase_ :int = (ord(pattern[i] ) + p_hash * alphabet_size) % modulus lowerCAmelCase_ :Any = (ord(text[i] ) + text_hash * alphabet_size) % modulus if i == p_len - 1: continue lowerCAmelCase_ :Optional[Any] = (modulus_power * alphabet_size) % modulus for i in range(0 , t_len - p_len + 1 ): if text_hash == p_hash and text[i : i + p_len] == pattern: return True if i == t_len - p_len: continue # Calculate the https://en.wikipedia.org/wiki/Rolling_hash lowerCAmelCase_ :Any = ( (text_hash - ord(text[i] ) * modulus_power) * alphabet_size + ord(text[i + p_len] ) ) % modulus return False def _snake_case ( ) -> None: '''simple docstring''' lowerCAmelCase_ :int = """abc1abc12""" lowerCAmelCase_ :Dict = """alskfjaldsabc1abc1abc12k23adsfabcabc""" lowerCAmelCase_ :int = """alskfjaldsk23adsfabcabc""" assert rabin_karp(lowercase__ , lowercase__ ) and not rabin_karp(lowercase__ , lowercase__ ) # Test 2) lowerCAmelCase_ :Dict = """ABABX""" lowerCAmelCase_ :int = """ABABZABABYABABX""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 3) lowerCAmelCase_ :Union[str, Any] = """AAAB""" lowerCAmelCase_ :List[str] = """ABAAAAAB""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 4) lowerCAmelCase_ :Dict = """abcdabcy""" lowerCAmelCase_ :Union[str, Any] = """abcxabcdabxabcdabcdabcy""" assert rabin_karp(lowercase__ , lowercase__ ) # Test 5) lowerCAmelCase_ :Optional[int] = """Lü""" lowerCAmelCase_ :Optional[int] = """Lüsai""" assert rabin_karp(lowercase__ , lowercase__ ) lowerCAmelCase_ :Optional[int] = """Lue""" assert not rabin_karp(lowercase__ , lowercase__ ) print("""Success.""" ) if __name__ == "__main__": test_rabin_karp()

"""simple docstring""" # XXX: we want transformers master here - in the absense of conftest manipulating sys.path: # hack it in for now: import sys from pathlib import Path __UpperCAmelCase = Path(__file__).resolve().parents[3] / 'src' sys.path.insert(1, str(git_repo_path)) import dataclasses # noqa import io # noqa import itertools # noqa import json # noqa import os # noqa import unittest # noqa from copy import deepcopy # noqa from parameterized import parameterized # noqa from transformers import TrainingArguments, is_torch_available # noqa from transformers.deepspeed import is_deepspeed_available # noqa from transformers.file_utils import WEIGHTS_NAME # noqa from transformers.testing_utils import ( # noqa CaptureLogger, ExtendSysPath, TestCasePlus, execute_subprocess_async, get_gpu_count, mockenv_context, require_deepspeed, require_torch_gpu, require_torch_multi_gpu, slow, ) from transformers.trainer_utils import set_seed # noqa set_seed(42) __UpperCAmelCase = {'base': 'patrickvonplaten/wav2vec2_tiny_random', 'robust': 'patrickvonplaten/wav2vec2_tiny_random_robust'} __UpperCAmelCase = 'zero2' __UpperCAmelCase = 'zero3' __UpperCAmelCase = [ZEROa, ZEROa] def _snake_case ( lowercase__ : str , lowercase__ : Optional[int] , lowercase__ : Tuple ) -> List[str]: '''simple docstring''' lowerCAmelCase_ :str = parameterized.to_safe_name("""_""".join(str(lowercase__ ) for x in param.args ) ) return f"""{func.__name__}_{param_based_name}""" # Cartesian-product of zero stages with models to test __UpperCAmelCase = list(itertools.product(stages, models.keys())) @slow @require_deepspeed @require_torch_gpu class _SCREAMING_SNAKE_CASE ( A__ ): @parameterized.expand(__A , name_func=__A ) def __lowerCAmelCase ( self , __A , __A ) -> str: self.run_and_check( stage=__A , model=__A , distributed=__A , fpaa=__A , ) @require_torch_multi_gpu @parameterized.expand(__A , name_func=__A ) def __lowerCAmelCase ( self , __A , __A ) -> List[Any]: self.run_and_check( stage=__A , model=__A , distributed=__A , fpaa=__A , ) @parameterized.expand(__A , name_func=__A ) def __lowerCAmelCase ( self , __A , __A ) -> str: self.run_and_check( stage=__A , model=__A , distributed=__A , fpaa=__A , ) @require_torch_multi_gpu @parameterized.expand(__A , name_func=__A ) def __lowerCAmelCase ( self , __A , __A ) -> Tuple: self.run_and_check( stage=__A , model=__A , distributed=__A , fpaa=__A , ) def __lowerCAmelCase ( self , __A ) -> List[str]: # XXX: run_asr is premature and doesn't save any results # so all we check for now is that the process didn't fail pass def __lowerCAmelCase ( self , __A , __A , __A = 10 , __A = True , __A = True , __A = True , ) -> Tuple: lowerCAmelCase_ :Optional[Any] = models[model] lowerCAmelCase_ :Tuple = self.run_trainer( stage=__A , model_name=__A , eval_steps=__A , num_train_epochs=1 , distributed=__A , fpaa=__A , ) self.do_checks(__A ) return output_dir def __lowerCAmelCase ( self , __A , __A , __A = 10 , __A = 1 , __A = True , __A = True , ) -> List[str]: lowerCAmelCase_ :Optional[int] = self.get_auto_remove_tmp_dir("""./xxx""" , after=__A ) lowerCAmelCase_ :Tuple = f""" --model_name_or_path {model_name} --dataset_name hf-internal-testing/librispeech_asr_dummy --dataset_config_name clean --train_split_name validation --validation_split_name validation --output_dir {output_dir} --num_train_epochs {str(__A )} --per_device_train_batch_size 2 --per_device_eval_batch_size 2 --evaluation_strategy steps --learning_rate 5e-4 --warmup_steps 8 --orthography timit --preprocessing_num_workers 1 --group_by_length --freeze_feature_extractor --report_to none --save_steps 0 --eval_steps {eval_steps} --report_to none """.split() if fpaa: args.extend(["""--fp16"""] ) # currently ds_config_wav2vec2_zero.json requires "zero_optimization.find_unused_parameters": true, # hence the separate config files lowerCAmelCase_ :Tuple = f"""--deepspeed {self.test_file_dir_str}/ds_config_wav2vec2_{stage}.json""".split() lowerCAmelCase_ :List[str] = [f"""{self.examples_dir_str}/research_projects/wav2vec2/run_asr.py"""] lowerCAmelCase_ :List[Any] = self.get_launcher(__A ) lowerCAmelCase_ :Union[str, Any] = launcher + script + args + ds_args # keep for quick debug # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die execute_subprocess_async(__A , env=self.get_env() ) return output_dir def __lowerCAmelCase ( self , __A=False ) -> str: # 1. explicitly set --num_nodes=1 just in case these tests end up run on a multi-node setup # - it won't be able to handle that # 2. for now testing with just 2 gpus max (since some quality tests may give different # results with mode gpus because we use very little data) lowerCAmelCase_ :Any = min(2 , get_gpu_count() ) if distributed else 1 return f"""deepspeed --num_nodes 1 --num_gpus {num_gpus}""".split()

"""simple docstring""" import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.local_sgd import LocalSGD ######################################################################## # This is a fully working simple example to use Accelerate # with LocalSGD, which is a method to synchronize model # parameters every K batches. It is different, but complementary # to gradient accumulation. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 ) -> str: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained("""bert-base-cased""" ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : int ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :Optional[int] = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): lowerCAmelCase_ :Optional[Any] = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :str = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Dict ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCAmelCase_ :int = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCAmelCase_ :List[Any] = 1_6 elif accelerator.mixed_precision != "no": lowerCAmelCase_ :List[str] = 8 else: lowerCAmelCase_ :Optional[int] = None return tokenizer.pad( lowercase__ , padding="""longest""" , max_length=lowercase__ , pad_to_multiple_of=lowercase__ , return_tensors="""pt""" , ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[Any] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :List[Any] = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS', None) == "1": from accelerate.test_utils.training import mocked_dataloaders __UpperCAmelCase = mocked_dataloaders # noqa: F811 def _snake_case ( lowercase__ : List[Any] , lowercase__ : Optional[int] ) -> Optional[Any]: '''simple docstring''' if os.environ.get("""TESTING_MOCKED_DATALOADERS""" , lowercase__ ) == "1": lowerCAmelCase_ :Optional[Any] = 2 # New Code # lowerCAmelCase_ :List[str] = int(args.gradient_accumulation_steps ) lowerCAmelCase_ :int = int(args.local_sgd_steps ) # Initialize accelerator lowerCAmelCase_ :str = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=lowercase__ ) if accelerator.distributed_type not in [DistributedType.NO, DistributedType.MULTI_CPU, DistributedType.MULTI_GPU]: raise NotImplementedError("""LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)""" ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :int = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Union[str, Any] = evaluate.load("""glue""" , """mrpc""" ) set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = get_dataloaders(lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :Optional[int] = AutoModelForSequenceClassification.from_pretrained("""bert-base-cased""" , return_dict=lowercase__ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). lowerCAmelCase_ :Union[str, Any] = model.to(accelerator.device ) # Instantiate optimizer lowerCAmelCase_ :Optional[Any] = AdamW(params=model.parameters() , lr=lowercase__ ) # Instantiate scheduler lowerCAmelCase_ :Union[str, Any] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowercase__ ) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Now we train the model for epoch in range(lowercase__ ): model.train() with LocalSGD( accelerator=lowercase__ , model=lowercase__ , local_sgd_steps=lowercase__ , enabled=local_sgd_steps is not None ) as local_sgd: for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(lowercase__ ): lowerCAmelCase_ :str = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = output.loss accelerator.backward(lowercase__ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() # LocalSGD-specific line local_sgd.step() model.eval() for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.gather_for_metrics((predictions, batch["""labels"""]) ) metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Any = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :str = argparse.ArgumentParser(description="""Simple example of training script.""" ) parser.add_argument( """--mixed_precision""" , type=lowercase__ , default=lowercase__ , choices=["""no""", """fp16""", """bf16""", """fp8"""] , help="""Whether to use mixed precision. Choose""" """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.""" """and an Nvidia Ampere GPU.""" , ) # New Code # parser.add_argument( """--gradient_accumulation_steps""" , type=lowercase__ , default=1 , help="""The number of minibatches to be ran before gradients are accumulated.""" , ) parser.add_argument( """--local_sgd_steps""" , type=lowercase__ , default=8 , help="""Number of local SGD steps or None to disable local SGD""" ) parser.add_argument("""--cpu""" , action="""store_true""" , help="""If passed, will train on the CPU.""" ) lowerCAmelCase_ :Optional[Any] = parser.parse_args() lowerCAmelCase_ :Tuple = {"""lr""": 2E-5, """num_epochs""": 3, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) __UpperCAmelCase = { 'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig'] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'ResNetForImageClassification', 'ResNetModel', 'ResNetPreTrainedModel', 'ResNetBackbone', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFResNetForImageClassification', 'TFResNetModel', 'TFResNetPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'FlaxResNetForImageClassification', 'FlaxResNetModel', 'FlaxResNetPreTrainedModel', ] if TYPE_CHECKING: from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_resnet import ( RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, ResNetBackbone, ResNetForImageClassification, ResNetModel, ResNetPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_resnet import ( TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFResNetForImageClassification, TFResNetModel, TFResNetPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure)

"""simple docstring""" import argparse import json import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 , lowercase__ : str = "bert-base-cased" ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained(lowercase__ ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : List[str] ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :str = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset lowerCAmelCase_ :str = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , load_from_cache_file=lowercase__ ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :List[str] = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Union[str, Any] ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(lowercase__ , padding="""max_length""" , max_length=1_2_8 , return_tensors="""pt""" ) return tokenizer.pad(lowercase__ , padding="""longest""" , return_tensors="""pt""" ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[int] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :Any = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : Union[str, Any] , lowercase__ : Tuple , lowercase__ : int ) -> List[str]: '''simple docstring''' model.eval() lowerCAmelCase_ :Dict = 0 for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) # It is slightly faster to call this once, than multiple times lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.gather( (predictions, batch["""labels"""]) ) # If we are in a multiprocess environment, the last batch has duplicates if accelerator.use_distributed: if step == len(lowercase__ ) - 1: lowerCAmelCase_ :Optional[Any] = predictions[: len(eval_dataloader.dataset ) - samples_seen] lowerCAmelCase_ :Any = references[: len(eval_dataloader.dataset ) - samples_seen] else: samples_seen += references.shape[0] metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Tuple = metric.compute() return eval_metric["accuracy"] def _snake_case ( lowercase__ : str , lowercase__ : List[str] ) -> Any: '''simple docstring''' lowerCAmelCase_ :Optional[int] = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :Optional[int] = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Optional[Any] = args.model_name_or_path set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Dict = get_dataloaders(lowercase__ , lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :str = AutoModelForSequenceClassification.from_pretrained(lowercase__ , return_dict=lowercase__ ) # Instantiate optimizer lowerCAmelCase_ :List[str] = ( AdamW if accelerator.state.deepspeed_plugin is None or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) lowerCAmelCase_ :str = optimizer_cls(params=model.parameters() , lr=lowercase__ ) if accelerator.state.deepspeed_plugin is not None: lowerCAmelCase_ :Union[str, Any] = accelerator.state.deepspeed_plugin.deepspeed_config[ """gradient_accumulation_steps""" ] else: lowerCAmelCase_ :Any = 1 lowerCAmelCase_ :str = (len(lowercase__ ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): lowerCAmelCase_ :List[str] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=0 , num_training_steps=lowercase__ , ) else: lowerCAmelCase_ :int = DummyScheduler(lowercase__ , total_num_steps=lowercase__ , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # We need to keep track of how many total steps we have iterated over lowerCAmelCase_ :List[str] = 0 # We also need to keep track of the stating epoch so files are named properly lowerCAmelCase_ :List[Any] = 0 lowerCAmelCase_ :str = evaluate.load("""glue""" , """mrpc""" ) lowerCAmelCase_ :Optional[Any] = num_epochs if args.partial_train_epoch is not None: lowerCAmelCase_ :Dict = args.partial_train_epoch if args.resume_from_checkpoint: accelerator.load_state(args.resume_from_checkpoint ) lowerCAmelCase_ :Optional[Any] = args.resume_from_checkpoint.split("""epoch_""" )[1] lowerCAmelCase_ :int = """""" for char in epoch_string: if char.isdigit(): state_epoch_num += char else: break lowerCAmelCase_ :Union[str, Any] = int(lowercase__ ) + 1 lowerCAmelCase_ :Optional[int] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) accelerator.print("""resumed checkpoint performance:""" , lowercase__ ) accelerator.print("""resumed checkpoint's scheduler's lr:""" , lr_scheduler.get_lr()[0] ) accelerator.print("""resumed optimizers's lr:""" , optimizer.param_groups[0]["""lr"""] ) with open(os.path.join(args.output_dir , f"""state_{starting_epoch-1}.json""" ) , """r""" ) as f: lowerCAmelCase_ :List[str] = json.load(lowercase__ ) assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed" assert ( resumed_state["lr"] == lr_scheduler.get_lr()[0] ), "Scheduler learning rate mismatch, loading from checkpoint failed" assert ( resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"] ), "Optimizer learning rate mismatch, loading from checkpoint failed" assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed" return # Now we train the model lowerCAmelCase_ :List[Any] = {} for epoch in range(lowercase__ , lowercase__ ): model.train() for step, batch in enumerate(lowercase__ ): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Dict = outputs.loss lowerCAmelCase_ :int = loss / gradient_accumulation_steps accelerator.backward(lowercase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 lowerCAmelCase_ :List[str] = f"""epoch_{epoch}""" lowerCAmelCase_ :Any = os.path.join(args.output_dir , lowercase__ ) accelerator.save_state(lowercase__ ) lowerCAmelCase_ :List[Any] = evaluation_loop(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) lowerCAmelCase_ :Union[str, Any] = accuracy lowerCAmelCase_ :Any = lr_scheduler.get_lr()[0] lowerCAmelCase_ :str = optimizer.param_groups[0]["""lr"""] lowerCAmelCase_ :List[Any] = epoch lowerCAmelCase_ :Tuple = overall_step accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , f"""state_{epoch}.json""" ) , """w""" ) as f: json.dump(lowercase__ , lowercase__ ) def _snake_case ( ) -> int: '''simple docstring''' lowerCAmelCase_ :List[Any] = argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage.""" ) parser.add_argument( """--model_name_or_path""" , type=lowercase__ , default="""bert-base-cased""" , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=lowercase__ , ) parser.add_argument( """--output_dir""" , type=lowercase__ , default=""".""" , help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory.""" , ) parser.add_argument( """--resume_from_checkpoint""" , type=lowercase__ , default=lowercase__ , help="""If the training should continue from a checkpoint folder.""" , ) parser.add_argument( """--partial_train_epoch""" , type=lowercase__ , default=lowercase__ , help="""If passed, the training will stop after this number of epochs.""" , ) parser.add_argument( """--num_epochs""" , type=lowercase__ , default=2 , help="""Number of train epochs.""" , ) lowerCAmelCase_ :Optional[int] = parser.parse_args() lowerCAmelCase_ :List[Any] = {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" import unittest from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __UpperCAmelCase = get_tests_dir('fixtures/test_sentencepiece.model') @require_sentencepiece class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :List[str] = XLMProphetNetTokenizer UpperCAmelCase_ :Dict = False UpperCAmelCase_ :List[str] = True def __lowerCAmelCase ( self ) -> Optional[Any]: super().setUp() # We have a SentencePiece fixture for testing lowerCAmelCase_ :Optional[int] = XLMProphetNetTokenizer(__A , keep_accents=__A ) tokenizer.save_pretrained(self.tmpdirname ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Optional[Any] = """[PAD]""" lowerCAmelCase_ :Any = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(__A ) , __A ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(__A ) , __A ) def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , """[PAD]""" ) self.assertEqual(vocab_keys[1] , """[CLS]""" ) self.assertEqual(vocab_keys[-1] , """j""" ) self.assertEqual(len(__A ) , 1012 ) def __lowerCAmelCase ( self ) -> str: self.assertEqual(self.get_tokenizer().vocab_size , 1012 ) def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Optional[Any] = XLMProphetNetTokenizer(__A , keep_accents=__A ) lowerCAmelCase_ :Dict = tokenizer.tokenize("""This is a test""" ) self.assertListEqual(__A , ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(__A ) , [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] , ) lowerCAmelCase_ :List[Any] = tokenizer.tokenize("""I was born in 92000, and this is falsé.""" ) self.assertListEqual( __A , [ 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""", """é""", """.""", ] , ) lowerCAmelCase_ :Optional[int] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual( __A , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4] ] , ) lowerCAmelCase_ :Any = tokenizer.convert_ids_to_tokens(__A ) self.assertListEqual( __A , [ 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]""", """.""", ] , ) @cached_property def __lowerCAmelCase ( self ) -> Any: return XLMProphetNetTokenizer.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased""" ) @slow def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[Any] = """Hello World!""" lowerCAmelCase_ :Optional[Any] = [3_5389, 6672, 49, 2] self.assertListEqual(__A , self.big_tokenizer.encode(__A ) ) @slow def __lowerCAmelCase ( self ) -> Any: # fmt: off lowerCAmelCase_ :Optional[int] = {"""input_ids""": [[1_1073, 8_2783, 18, 26, 8_2783, 549, 5_1540, 248, 1_7209, 1301, 217, 20, 21_5186, 1325, 147, 1_7209, 1301, 217, 20, 5_6370, 53, 12_2020, 20, 1_6477, 27, 8_7355, 4548, 20, 4728, 7_8392, 17, 15_9969, 18, 26, 2_4491, 629, 15, 538, 2_2704, 5439, 15, 2788, 2_4491, 9885, 15, 4_3534, 605, 15, 814, 1_8403, 3_3200, 29, 15, 4_3534, 2_4458, 1_2410, 111, 2_4966, 8_3669, 9637, 14_4068, 26, 850, 2_2346, 27, 147, 2_4966, 8_3669, 8_3490, 26, 3_9113, 735, 27, 689, 656, 2800, 1339, 4600, 53, 12_2020, 11_5785, 34, 816, 1339, 4_6887, 18, 147, 5_3905, 1951, 4_2238, 4_1170, 1_7732, 834, 436, 15, 2_7523, 9_8733, 217, 147, 5542, 4981, 930, 1_7347, 16, 2], [2_0091, 629, 94, 8_2786, 58, 490, 20, 1528, 84, 5_3905, 344, 8_0592, 11_0128, 1_8822, 5267, 1306, 62, 15_2537, 308, 7997, 401, 12_4427, 549, 3_5442, 225, 109, 1_5055, 2_5748, 147, 7119, 4_3712, 34, 767, 13_5366, 18, 16, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 6_3784, 11_9466, 17, 14_7808, 8_8214, 18, 656, 81, 32, 3296, 1_0280, 16, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=__A , model_name="""microsoft/xprophetnet-large-wiki100-cased""" , revision="""1acad1643ddd54a44df6a1b797ada8373685d90e""" , )

"""simple docstring""" import baseaa import io import json import os from copy import deepcopy from ..optimizer import AcceleratedOptimizer from ..scheduler import AcceleratedScheduler class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Union[str, Any]: if isinstance(__A , __A ): # Don't modify user's data should they want to reuse it (e.g. in tests), because once we # modified it, it will not be accepted here again, since `auto` values would have been overridden lowerCAmelCase_ :Tuple = deepcopy(__A ) elif os.path.exists(__A ): with io.open(__A , """r""" , encoding="""utf-8""" ) as f: lowerCAmelCase_ :str = json.load(__A ) else: try: lowerCAmelCase_ :Dict = baseaa.urlsafe_baadecode(__A ).decode("""utf-8""" ) lowerCAmelCase_ :int = json.loads(__A ) except (UnicodeDecodeError, AttributeError, ValueError): raise ValueError( f"""Expected a string path to an existing deepspeed config, or a dictionary, or a base64 encoded string. Received: {config_file_or_dict}""" ) lowerCAmelCase_ :Optional[Any] = config self.set_stage_and_offload() def __lowerCAmelCase ( self ) -> Tuple: # zero stage - this is done as early as possible, before model is created, to allow # ``is_deepspeed_zero3_enabled`` query and getting to the early deepspeed config object # during ``zero.Init()`` which needs to know the dtype, and some other hparams. lowerCAmelCase_ :Tuple = self.get_value("""zero_optimization.stage""" , -1 ) # offload lowerCAmelCase_ :Dict = False if self.is_zeroa() or self.is_zeroa(): lowerCAmelCase_ :Optional[int] = set(["""cpu""", """nvme"""] ) lowerCAmelCase_ :Union[str, Any] = set( [ self.get_value("""zero_optimization.offload_optimizer.device""" ), self.get_value("""zero_optimization.offload_param.device""" ), ] ) if len(offload_devices & offload_devices_valid ) > 0: lowerCAmelCase_ :Optional[int] = True def __lowerCAmelCase ( self , __A ) -> Optional[Any]: lowerCAmelCase_ :str = self.config # find the config node of interest if it exists lowerCAmelCase_ :Tuple = ds_key_long.split(""".""" ) lowerCAmelCase_ :List[str] = nodes.pop() for node in nodes: lowerCAmelCase_ :Tuple = config.get(__A ) if config is None: return None, ds_key return config, ds_key def __lowerCAmelCase ( self , __A , __A=None ) -> Optional[Any]: lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = self.find_config_node(__A ) if config is None: return default return config.get(__A , __A ) def __lowerCAmelCase ( self , __A , __A=False ) -> Optional[Any]: lowerCAmelCase_ :Tuple = self.config # find the config node of interest if it exists lowerCAmelCase_ :Union[str, Any] = ds_key_long.split(""".""" ) for node in nodes: lowerCAmelCase_ :int = config lowerCAmelCase_ :Any = config.get(__A ) if config is None: if must_exist: raise ValueError(f"""Can't find {ds_key_long} entry in the config: {self.config}""" ) else: return # if found remove it if parent_config is not None: parent_config.pop(__A ) def __lowerCAmelCase ( self , __A ) -> Union[str, Any]: lowerCAmelCase_ :Optional[int] = self.get_value(__A ) return False if value is None else bool(__A ) def __lowerCAmelCase ( self , __A ) -> Optional[int]: lowerCAmelCase_ :List[str] = self.get_value(__A ) return False if value is None else not bool(__A ) def __lowerCAmelCase ( self ) -> str: return self._stage == 2 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._stage == 3 def __lowerCAmelCase ( self ) -> Union[str, Any]: return self._offload class _SCREAMING_SNAKE_CASE : def __init__( self , __A ) -> Optional[int]: lowerCAmelCase_ :Dict = engine def __lowerCAmelCase ( self , __A , **__A ) -> str: # runs backpropagation and handles mixed precision self.engine.backward(__A , **__A ) # Deepspeed's `engine.step` performs the following operations: # - gradient accumulation check # - gradient clipping # - optimizer step # - zero grad # - checking overflow # - lr_scheduler step (only if engine.lr_scheduler is not None) self.engine.step() # and this plugin overrides the above calls with no-ops when Accelerate runs under # Deepspeed, but allows normal functionality for non-Deepspeed cases thus enabling a simple # training loop that works transparently under many training regimes. class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A ) -> List[str]: super().__init__(__A , device_placement=__A , scaler=__A ) lowerCAmelCase_ :List[str] = hasattr(self.optimizer , """overflow""" ) def __lowerCAmelCase ( self , __A=None ) -> Optional[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed def __lowerCAmelCase ( self ) -> List[Any]: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed @property def __lowerCAmelCase ( self ) -> int: if self.__has_overflow__: return self.optimizer.overflow return False class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , __A , __A ) -> Optional[int]: super().__init__(__A , __A ) def __lowerCAmelCase ( self ) -> Any: pass # `accelerator.backward(loss)` is doing that automatically. Therefore, its implementation is not needed class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=0.0_0_1 , __A=0 , **__A ) -> List[Any]: lowerCAmelCase_ :str = params lowerCAmelCase_ :Any = lr lowerCAmelCase_ :List[Any] = weight_decay lowerCAmelCase_ :Any = kwargs class _SCREAMING_SNAKE_CASE : def __init__( self , __A , __A=None , __A=0 , **__A ) -> List[str]: lowerCAmelCase_ :Optional[int] = optimizer lowerCAmelCase_ :int = total_num_steps lowerCAmelCase_ :List[Any] = warmup_num_steps lowerCAmelCase_ :int = kwargs

"""simple docstring""" def _snake_case ( lowercase__ : list[int] , lowercase__ : list[int] , lowercase__ : int ) -> bool: '''simple docstring''' return not any( neighbour == 1 and colored_vertices[i] == color for i, neighbour in enumerate(lowercase__ ) ) def _snake_case ( lowercase__ : list[list[int]] , lowercase__ : int , lowercase__ : list[int] , lowercase__ : int ) -> bool: '''simple docstring''' if index == len(lowercase__ ): return True # Recursive Step for i in range(lowercase__ ): if valid_coloring(graph[index] , lowercase__ , lowercase__ ): # Color current vertex lowerCAmelCase_ :List[str] = i # Validate coloring if util_color(lowercase__ , lowercase__ , lowercase__ , index + 1 ): return True # Backtrack lowerCAmelCase_ :Tuple = -1 return False def _snake_case ( lowercase__ : list[list[int]] , lowercase__ : int ) -> list[int]: '''simple docstring''' lowerCAmelCase_ :List[str] = [-1] * len(lowercase__ ) if util_color(lowercase__ , lowercase__ , lowercase__ , 0 ): return colored_vertices return []

"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import numpy as np import torch from ..models.clipseg import CLIPSegForImageSegmentation from ..utils import is_vision_available, requires_backends from .base import PipelineTool if is_vision_available(): from PIL import Image class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :Dict = ( "This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image." "It takes two arguments named `image` which should be the original image, and `label` which should be a text " "describing the elements what should be identified in the segmentation mask. The tool returns the mask." ) UpperCAmelCase_ :List[str] = "CIDAS/clipseg-rd64-refined" UpperCAmelCase_ :List[Any] = "image_segmenter" UpperCAmelCase_ :Optional[int] = CLIPSegForImageSegmentation UpperCAmelCase_ :Tuple = ["image", "text"] UpperCAmelCase_ :Dict = ["image"] def __init__( self , *__A , **__A ) -> Optional[Any]: requires_backends(self , ["""vision"""] ) super().__init__(*__A , **__A ) def __lowerCAmelCase ( self , __A , __A ) -> Any: return self.pre_processor(text=[label] , images=[image] , padding=__A , return_tensors="""pt""" ) def __lowerCAmelCase ( self , __A ) -> Tuple: with torch.no_grad(): lowerCAmelCase_ :Dict = self.model(**__A ).logits return logits def __lowerCAmelCase ( self , __A ) -> Tuple: lowerCAmelCase_ :Optional[int] = outputs.cpu().detach().numpy() lowerCAmelCase_ :List[str] = 0 lowerCAmelCase_ :str = 1 return Image.fromarray((array * 255).astype(np.uinta ) )

"""simple docstring""" def _snake_case ( lowercase__ : int , lowercase__ : int ) -> int: '''simple docstring''' return x if y == 0 else greatest_common_divisor(lowercase__ , x % y ) def _snake_case ( lowercase__ : int , lowercase__ : int ) -> int: '''simple docstring''' return (x * y) // greatest_common_divisor(lowercase__ , lowercase__ ) def _snake_case ( lowercase__ : int = 2_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :Tuple = 1 for i in range(1 , n + 1 ): lowerCAmelCase_ :Dict = lcm(lowercase__ , lowercase__ ) return g if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" def _snake_case ( lowercase__ : list , lowercase__ : list , lowercase__ : int , lowercase__ : int , lowercase__ : int ) -> int: '''simple docstring''' if index == number_of_items: return 0 lowerCAmelCase_ :Any = 0 lowerCAmelCase_ :str = 0 lowerCAmelCase_ :Dict = knapsack(lowercase__ , lowercase__ , lowercase__ , lowercase__ , index + 1 ) if weights[index] <= max_weight: lowerCAmelCase_ :str = values[index] + knapsack( lowercase__ , lowercase__ , lowercase__ , max_weight - weights[index] , index + 1 ) return max(lowercase__ , lowercase__ ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.local_sgd import LocalSGD ######################################################################## # This is a fully working simple example to use Accelerate # with LocalSGD, which is a method to synchronize model # parameters every K batches. It is different, but complementary # to gradient accumulation. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## __UpperCAmelCase = 16 __UpperCAmelCase = 32 def _snake_case ( lowercase__ : Accelerator , lowercase__ : int = 1_6 ) -> str: '''simple docstring''' lowerCAmelCase_ :List[str] = AutoTokenizer.from_pretrained("""bert-base-cased""" ) lowerCAmelCase_ :Optional[Any] = load_dataset("""glue""" , """mrpc""" ) def tokenize_function(lowercase__ : int ): # max_length=None => use the model max length (it's actually the default) lowerCAmelCase_ :Optional[int] = tokenizer(examples["""sentence1"""] , examples["""sentence2"""] , truncation=lowercase__ , max_length=lowercase__ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): lowerCAmelCase_ :Optional[Any] = datasets.map( lowercase__ , batched=lowercase__ , remove_columns=["""idx""", """sentence1""", """sentence2"""] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library lowerCAmelCase_ :str = tokenized_datasets.rename_column("""label""" , """labels""" ) def collate_fn(lowercase__ : Dict ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCAmelCase_ :int = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCAmelCase_ :List[Any] = 1_6 elif accelerator.mixed_precision != "no": lowerCAmelCase_ :List[str] = 8 else: lowerCAmelCase_ :Optional[int] = None return tokenizer.pad( lowercase__ , padding="""longest""" , max_length=lowercase__ , pad_to_multiple_of=lowercase__ , return_tensors="""pt""" , ) # Instantiate dataloaders. lowerCAmelCase_ :Optional[Any] = DataLoader( tokenized_datasets["""train"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) lowerCAmelCase_ :List[Any] = DataLoader( tokenized_datasets["""validation"""] , shuffle=lowercase__ , collate_fn=lowercase__ , batch_size=lowercase__ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS', None) == "1": from accelerate.test_utils.training import mocked_dataloaders __UpperCAmelCase = mocked_dataloaders # noqa: F811 def _snake_case ( lowercase__ : List[Any] , lowercase__ : Optional[int] ) -> Optional[Any]: '''simple docstring''' if os.environ.get("""TESTING_MOCKED_DATALOADERS""" , lowercase__ ) == "1": lowerCAmelCase_ :Optional[Any] = 2 # New Code # lowerCAmelCase_ :List[str] = int(args.gradient_accumulation_steps ) lowerCAmelCase_ :int = int(args.local_sgd_steps ) # Initialize accelerator lowerCAmelCase_ :str = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=lowercase__ ) if accelerator.distributed_type not in [DistributedType.NO, DistributedType.MULTI_CPU, DistributedType.MULTI_GPU]: raise NotImplementedError("""LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)""" ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCAmelCase_ :int = config["""lr"""] lowerCAmelCase_ :Union[str, Any] = int(config["""num_epochs"""] ) lowerCAmelCase_ :int = int(config["""seed"""] ) lowerCAmelCase_ :Union[str, Any] = int(config["""batch_size"""] ) lowerCAmelCase_ :Union[str, Any] = evaluate.load("""glue""" , """mrpc""" ) set_seed(lowercase__ ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = get_dataloaders(lowercase__ , lowercase__ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCAmelCase_ :Optional[int] = AutoModelForSequenceClassification.from_pretrained("""bert-base-cased""" , return_dict=lowercase__ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). lowerCAmelCase_ :Union[str, Any] = model.to(accelerator.device ) # Instantiate optimizer lowerCAmelCase_ :Optional[Any] = AdamW(params=model.parameters() , lr=lowercase__ ) # Instantiate scheduler lowerCAmelCase_ :Union[str, Any] = get_linear_schedule_with_warmup( optimizer=lowercase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowercase__ ) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.prepare( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Now we train the model for epoch in range(lowercase__ ): model.train() with LocalSGD( accelerator=lowercase__ , model=lowercase__ , local_sgd_steps=lowercase__ , enabled=local_sgd_steps is not None ) as local_sgd: for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(lowercase__ ): lowerCAmelCase_ :str = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = output.loss accelerator.backward(lowercase__ ) optimizer.step() lr_scheduler.step() optimizer.zero_grad() # LocalSGD-specific line local_sgd.step() model.eval() for step, batch in enumerate(lowercase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): lowerCAmelCase_ :Optional[int] = model(**lowercase__ ) lowerCAmelCase_ :Optional[int] = outputs.logits.argmax(dim=-1 ) lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = accelerator.gather_for_metrics((predictions, batch["""labels"""]) ) metric.add_batch( predictions=lowercase__ , references=lowercase__ , ) lowerCAmelCase_ :Any = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , lowercase__ ) def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :str = argparse.ArgumentParser(description="""Simple example of training script.""" ) parser.add_argument( """--mixed_precision""" , type=lowercase__ , default=lowercase__ , choices=["""no""", """fp16""", """bf16""", """fp8"""] , help="""Whether to use mixed precision. Choose""" """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.""" """and an Nvidia Ampere GPU.""" , ) # New Code # parser.add_argument( """--gradient_accumulation_steps""" , type=lowercase__ , default=1 , help="""The number of minibatches to be ran before gradients are accumulated.""" , ) parser.add_argument( """--local_sgd_steps""" , type=lowercase__ , default=8 , help="""Number of local SGD steps or None to disable local SGD""" ) parser.add_argument("""--cpu""" , action="""store_true""" , help="""If passed, will train on the CPU.""" ) lowerCAmelCase_ :Optional[Any] = parser.parse_args() lowerCAmelCase_ :Tuple = {"""lr""": 2E-5, """num_epochs""": 3, """seed""": 4_2, """batch_size""": 1_6} training_function(lowercase__ , lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" from .imports import is_tqdm_available if is_tqdm_available(): from tqdm.auto import tqdm as _tqdm from ..state import PartialState def _snake_case ( lowercase__ : bool = True , *lowercase__ : Optional[int] , **lowercase__ : str ) -> Optional[Any]: '''simple docstring''' if not is_tqdm_available(): raise ImportError("""Accelerate's `tqdm` module requires `tqdm` to be installed. Please run `pip install tqdm`.""" ) lowerCAmelCase_ :Tuple = False if main_process_only: lowerCAmelCase_ :Dict = PartialState().local_process_index == 0 return _tqdm(*lowercase__ , **lowercase__ , disable=lowercase__ )

"""simple docstring""" from copy import deepcopy import torch import torch.nn.functional as F from torch.optim import AdamW from torch.optim.lr_scheduler import LambdaLR from torch.utils.data import DataLoader from accelerate.accelerator import Accelerator from accelerate.state import GradientState from accelerate.test_utils import RegressionDataset, RegressionModel from accelerate.utils import DistributedType, is_torch_version, set_seed def _snake_case ( lowercase__ : Any , lowercase__ : str , lowercase__ : List[Any] , lowercase__ : Optional[int] ) -> List[Any]: '''simple docstring''' for param, grad_param in zip(model_a.parameters() , model_b.parameters() ): if not param.requires_grad: continue if not did_step: # Grads should not be in sync assert ( torch.allclose(param.grad , grad_param.grad ) is False ), f"""Gradients in sync when they should not be at iteration {iteration}:\nmodel_a grad ({param.grad}) == model_b grad ({grad_param.grad})""" else: # Grads should be in sync assert ( torch.allclose(param.grad , grad_param.grad ) is True ), f"""Gradients not in sync when they should be at iteration {iteration}:\nmodel_a grad ({param.grad}) != model_b grad ({grad_param.grad})""" def _snake_case ( lowercase__ : int , lowercase__ : Tuple , lowercase__ : Optional[Any] , lowercase__ : Tuple , lowercase__ : Tuple=True ) -> str: '''simple docstring''' model.train() lowerCAmelCase_ :str = model(lowercase__ ) lowerCAmelCase_ :str = F.mse_loss(lowercase__ , target.to(output.device ) ) if not do_backward: loss /= accelerator.gradient_accumulation_steps loss.backward() else: accelerator.backward(lowercase__ ) def _snake_case ( lowercase__ : Optional[int] , lowercase__ : List[Any]=False ) -> List[Any]: '''simple docstring''' set_seed(4_2 ) lowerCAmelCase_ :Dict = RegressionModel() lowerCAmelCase_ :Optional[Any] = deepcopy(lowercase__ ) lowerCAmelCase_ :Optional[int] = RegressionDataset(length=8_0 ) lowerCAmelCase_ :Tuple = DataLoader(lowercase__ , batch_size=1_6 ) model.to(accelerator.device ) if sched: lowerCAmelCase_ :Optional[Any] = AdamW(params=model.parameters() , lr=1E-3 ) lowerCAmelCase_ :Dict = AdamW(params=ddp_model.parameters() , lr=1E-3 ) lowerCAmelCase_ :Union[str, Any] = LambdaLR(lowercase__ , lr_lambda=lambda lowercase__ : epoch**0.65 ) lowerCAmelCase_ :Optional[Any] = LambdaLR(lowercase__ , lr_lambda=lambda lowercase__ : epoch**0.65 ) # Make a copy of `model` if sched: lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = accelerator.prepare(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) else: lowerCAmelCase_ , lowerCAmelCase_ :Tuple = accelerator.prepare(lowercase__ , lowercase__ ) if sched: return (model, opt, sched, dataloader, ddp_model, ddp_opt, ddp_sched) return model, ddp_model, dataloader def _snake_case ( lowercase__ : int ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[str] = get_training_setup(lowercase__ ) # Use a single batch lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = next(iter(lowercase__ ) ).values() for iteration in range(3 ): # Gather the distributed inputs and targs for the base model lowerCAmelCase_ , lowerCAmelCase_ :List[str] = accelerator.gather((ddp_input, ddp_target) ) lowerCAmelCase_ , lowerCAmelCase_ :str = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Do "gradient accumulation" (noop) if iteration % 2 == 0: # Accumulate grads locally with accelerator.no_sync(lowercase__ ): step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) else: # Sync grads step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Since `no_sync` is a noop, `ddp_model` and `model` grads should always be in sync check_model_parameters(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue assert torch.allclose( param.grad , ddp_param.grad ), f"""Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})""" # Shuffle ddp_input on each iteration torch.manual_seed(1_3_3_7 + iteration ) lowerCAmelCase_ :int = ddp_input[torch.randperm(len(lowercase__ ) )] def _snake_case ( lowercase__ : Dict ) -> Tuple: '''simple docstring''' lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :List[Any] = get_training_setup(lowercase__ ) # Use a single batch lowerCAmelCase_ , lowerCAmelCase_ :Optional[int] = next(iter(lowercase__ ) ).values() for iteration in range(3 ): # Gather the distributed inputs and targs for the base model lowerCAmelCase_ , lowerCAmelCase_ :List[str] = accelerator.gather((ddp_input, ddp_target) ) lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Do "gradient accumulation" (noop) if iteration % 2 == 0: # Accumulate grads locally with accelerator.no_sync(lowercase__ ): step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) else: # Sync grads step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # DDP model and model should only be in sync when not (iteration % 2 == 0) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue if iteration % 2 == 0: # Grads should not be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is False ), f"""Gradients in sync when they should not be:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})""" else: # Grads should be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is True ), f"""Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})""" # Shuffle ddp_input on each iteration torch.manual_seed(1_3_3_7 + iteration ) lowerCAmelCase_ :int = ddp_input[torch.randperm(len(lowercase__ ) )] def _snake_case ( lowercase__ : Optional[int]=False , lowercase__ : Optional[Any]=False ) -> Any: '''simple docstring''' lowerCAmelCase_ :Optional[Any] = Accelerator( split_batches=lowercase__ , dispatch_batches=lowercase__ , gradient_accumulation_steps=2 ) # Test that context manager behaves properly lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :str = get_training_setup(lowercase__ ) for iteration, batch in enumerate(lowercase__ ): lowerCAmelCase_ , lowerCAmelCase_ :Tuple = batch.values() # Gather the distributed inputs and targs for the base model lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = accelerator.gather((ddp_input, ddp_target) ) lowerCAmelCase_ , lowerCAmelCase_ :Dict = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Do "gradient accumulation" (noop) with accelerator.accumulate(lowercase__ ): step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # DDP model and model should only be in sync when not (iteration % 2 == 0) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue if ((iteration + 1) % 2 == 0) or (iteration == len(lowercase__ ) - 1): # Grads should be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is True ), f"""Gradients not in sync when they should be at iteration {iteration}:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})""" else: # Grads should not be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is False ), f"""Gradients in sync when they should not be at iteration {iteration}:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})""" # Shuffle ddp_input on each iteration torch.manual_seed(1_3_3_7 + iteration ) lowerCAmelCase_ :List[str] = ddp_input[torch.randperm(len(lowercase__ ) )] GradientState._reset_state() def _snake_case ( lowercase__ : Dict=False , lowercase__ : Any=False ) -> Any: '''simple docstring''' lowerCAmelCase_ :Dict = Accelerator( split_batches=lowercase__ , dispatch_batches=lowercase__ , gradient_accumulation_steps=2 ) # Test that context manager behaves properly lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ :int = get_training_setup(lowercase__ , lowercase__ ) for iteration, batch in enumerate(lowercase__ ): lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = batch.values() # Gather the distributed inputs and targs for the base model lowerCAmelCase_ , lowerCAmelCase_ :Dict = accelerator.gather((ddp_input, ddp_target) ) lowerCAmelCase_ , lowerCAmelCase_ :List[str] = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" model.train() ddp_model.train() step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ) opt.step() if ((iteration + 1) % 2 == 0) or ((iteration + 1) == len(lowercase__ )): if split_batches: sched.step() else: for _ in range(accelerator.num_processes ): sched.step() opt.zero_grad() # Perform gradient accumulation under wrapper with accelerator.accumulate(lowercase__ ): step_model(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) ddp_opt.step() ddp_sched.step() ddp_opt.zero_grad() # Learning rates should be the same assert ( opt.param_groups[0]["lr"] == ddp_opt.param_groups[0]["lr"] ), f"""Learning rates found in each optimizer did not align\nopt: {opt.param_groups[0]["lr"]}\nDDP opt: {ddp_opt.param_groups[0]["lr"]}\n""" lowerCAmelCase_ :Any = (((iteration + 1) % 2) == 0) or ((iteration + 1) == len(lowercase__ )) if accelerator.num_processes > 1: check_model_parameters(lowercase__ , lowercase__ , lowercase__ , lowercase__ ) # Shuffle ddp_input on each iteration torch.manual_seed(1_3_3_7 + iteration ) GradientState._reset_state() def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :Tuple = Accelerator() lowerCAmelCase_ :List[Any] = RegressionDataset(length=8_0 ) lowerCAmelCase_ :Tuple = DataLoader(lowercase__ , batch_size=1_6 ) lowerCAmelCase_ :List[Any] = RegressionDataset(length=9_6 ) lowerCAmelCase_ :Dict = DataLoader(lowercase__ , batch_size=1_6 ) lowerCAmelCase_ , lowerCAmelCase_ :Optional[Any] = accelerator.prepare(lowercase__ , lowercase__ ) assert accelerator.gradient_state.active_dataloader is None for iteration, _ in enumerate(lowercase__ ): assert id(accelerator.gradient_state.active_dataloader ) == id(lowercase__ ) if iteration < len(lowercase__ ) - 1: assert not accelerator.gradient_state.end_of_dataloader if iteration == 1: for batch_num, _ in enumerate(lowercase__ ): assert id(accelerator.gradient_state.active_dataloader ) == id(lowercase__ ) if batch_num < len(lowercase__ ) - 1: assert not accelerator.gradient_state.end_of_dataloader else: assert accelerator.gradient_state.end_of_dataloader else: assert accelerator.gradient_state.end_of_dataloader assert accelerator.gradient_state.active_dataloader is None def _snake_case ( ) -> Dict: '''simple docstring''' lowerCAmelCase_ :Optional[Any] = Accelerator() lowerCAmelCase_ :Dict = accelerator.state if state.local_process_index == 0: print("""**Test `accumulate` gradient accumulation with dataloader break**""" ) test_dataloader_break() if state.distributed_type == DistributedType.NO: if state.local_process_index == 0: print("""**Test NOOP `no_sync` context manager**""" ) test_noop_sync(lowercase__ ) if state.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_CPU): if state.local_process_index == 0: print("""**Test Distributed `no_sync` context manager**""" ) test_distributed_sync(lowercase__ ) if state.distributed_type == DistributedType.MULTI_GPU: for split_batch in [True, False]: for dispatch_batches in [True, False]: if state.local_process_index == 0: print( """**Test `accumulate` gradient accumulation, """ , f"""`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**""" , ) test_gradient_accumulation(lowercase__ , lowercase__ ) # Currently will break on torch 2.0 +, need to investigate why if is_torch_version("""<""" , """2.0""" ) or state.distributed_type == DistributedType.NO: if state.local_process_index == 0: print( """**Test `accumulate` gradient accumulation with optimizer and scheduler, """ , """`split_batches=False`, `dispatch_batches=False`**""" , ) test_gradient_accumulation_with_opt_and_scheduler() if state.distributed_type == DistributedType.MULTI_GPU: for split_batch in [True, False]: for dispatch_batches in [True, False]: if not split_batch and not dispatch_batches: continue if state.local_process_index == 0: print( """**Test `accumulate` gradient accumulation with optimizer and scheduler, """ , f"""`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**""" , ) test_gradient_accumulation_with_opt_and_scheduler(lowercase__ , lowercase__ ) def _snake_case ( lowercase__ : Any ) -> List[str]: '''simple docstring''' main() if __name__ == "__main__": main()

"""simple docstring""" import importlib import json import os import sys import tempfile import unittest from pathlib import Path import transformers import transformers.models.auto from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig from transformers.models.bert.configuration_bert import BertConfig from transformers.models.roberta.configuration_roberta import RobertaConfig from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils')) from test_module.custom_configuration import CustomConfig # noqa E402 __UpperCAmelCase = get_tests_dir('fixtures/dummy-config.json') class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = 0 def __lowerCAmelCase ( self ) -> List[str]: self.assertIsNotNone(transformers.models.auto.__spec__ ) self.assertIsNotNone(importlib.util.find_spec("""transformers.models.auto""" ) ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""bert-base-uncased""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :int = AutoConfig.for_model("""roberta""" ) self.assertIsInstance(__A , __A ) def __lowerCAmelCase ( self ) -> Tuple: with tempfile.TemporaryDirectory() as tmp_dir: # This model name contains bert and roberta, but roberta ends up being picked. lowerCAmelCase_ :int = os.path.join(__A , """fake-roberta""" ) os.makedirs(__A , exist_ok=__A ) with open(os.path.join(__A , """config.json""" ) , """w""" ) as f: f.write(json.dumps({} ) ) lowerCAmelCase_ :Any = AutoConfig.from_pretrained(__A ) self.assertEqual(type(__A ) , __A ) def __lowerCAmelCase ( self ) -> Optional[int]: try: AutoConfig.register("""custom""" , __A ) # Wrong model type will raise an error with self.assertRaises(__A ): AutoConfig.register("""model""" , __A ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(__A ): AutoConfig.register("""bert""" , __A ) # Now that the config is registered, it can be used as any other config with the auto-API lowerCAmelCase_ :Union[str, Any] = CustomConfig() with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Optional[int] = AutoConfig.from_pretrained(__A ) self.assertIsInstance(__A , __A ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] def __lowerCAmelCase ( self ) -> Tuple: with self.assertRaisesRegex( __A , """bert-base is not a local folder and is not a valid model identifier""" ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""bert-base""" ) def __lowerCAmelCase ( self ) -> Any: with self.assertRaisesRegex( __A , r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)""" ): lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , revision="""aaaaaa""" ) def __lowerCAmelCase ( self ) -> int: with self.assertRaisesRegex( __A , """hf-internal-testing/no-config-test-repo does not appear to have a file named config.json.""" , ): lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/no-config-test-repo""" ) def __lowerCAmelCase ( self ) -> Tuple: # If remote code is not set, we will time out when asking whether to load the model. with self.assertRaises(__A ): lowerCAmelCase_ :Tuple = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(__A ): lowerCAmelCase_ :List[str] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) lowerCAmelCase_ :str = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) # Test config can be reloaded. with tempfile.TemporaryDirectory() as tmp_dir: config.save_pretrained(__A ) lowerCAmelCase_ :Dict = AutoConfig.from_pretrained(__A , trust_remote_code=__A ) self.assertEqual(reloaded_config.__class__.__name__ , """NewModelConfig""" ) def __lowerCAmelCase ( self ) -> int: class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :int = "new-model" try: AutoConfig.register("""new-model""" , __A ) # If remote code is not set, the default is to use local lowerCAmelCase_ :Any = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote code is disabled, we load the local one. lowerCAmelCase_ :Union[str, Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfigLocal""" ) # If remote is enabled, we load from the Hub lowerCAmelCase_ :Optional[Any] = AutoConfig.from_pretrained("""hf-internal-testing/test_dynamic_model""" , trust_remote_code=__A ) self.assertEqual(config.__class__.__name__ , """NewModelConfig""" ) finally: if "new-model" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["new-model"]

"""simple docstring""" from ..utils import DummyObject, requires_backends class _SCREAMING_SNAKE_CASE ( metaclass=A__ ): UpperCAmelCase_ :Union[str, Any] = ["onnx"] def __init__( self , *__A , **__A ) -> Dict: requires_backends(self , ["""onnx"""] ) @classmethod def __lowerCAmelCase ( cls , *__A , **__A ) -> str: requires_backends(cls , ["""onnx"""] ) @classmethod def __lowerCAmelCase ( cls , *__A , **__A ) -> str: requires_backends(cls , ["""onnx"""] )

"""simple docstring""" import json import os import unittest from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import ( VOCAB_FILES_NAMES, GPTSanJapaneseTokenizer, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :str = GPTSanJapaneseTokenizer UpperCAmelCase_ :Optional[int] = False UpperCAmelCase_ :Optional[int] = {"do_clean_text": False, "add_prefix_space": False} def __lowerCAmelCase ( self ) -> Tuple: super().setUp() # fmt: off lowerCAmelCase_ :Dict = ["""こん""", """こんに""", """にちは""", """ばんは""", """世界,㔺界""", """、""", """。""", """<BR>""", """<SP>""", """<TAB>""", """<URL>""", """<EMAIL>""", """<TEL>""", """<DATE>""", """<PRICE>""", """<BLOCK>""", """<KIGOU>""", """<U2000U2BFF>""", """<|emoji1|>""", """<unk>""", """<|bagoftoken|>""", """<|endoftext|>"""] # fmt: on lowerCAmelCase_ :List[str] = {"""emoji""": {"""\ud83d\ude00""": """<|emoji1|>"""}, """emoji_inv""": {"""<|emoji1|>""": """\ud83d\ude00"""}} # 😀 lowerCAmelCase_ :int = {"""unk_token""": """<unk>"""} lowerCAmelCase_ :Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) lowerCAmelCase_ :int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""emoji_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) with open(self.emoji_file , """w""" ) as emoji_writer: emoji_writer.write(json.dumps(__A ) ) def __lowerCAmelCase ( self , **__A ) -> int: kwargs.update(self.special_tokens_map ) return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname , **__A ) def __lowerCAmelCase ( self , __A ) -> Dict: lowerCAmelCase_ :List[Any] = """こんにちは、世界。 \nこんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[int] = """こんにちは、世界。 \nこんばんは、世界。😀""" return input_text, output_text def __lowerCAmelCase ( self , __A ) -> str: lowerCAmelCase_ , lowerCAmelCase_ :Tuple = self.get_input_output_texts(__A ) lowerCAmelCase_ :List[str] = tokenizer.encode(__A , add_special_tokens=__A ) lowerCAmelCase_ :str = tokenizer.decode(__A , clean_up_tokenization_spaces=__A ) return text, ids def __lowerCAmelCase ( self ) -> str: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> int: pass # TODO add if relevant def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :Union[str, Any] = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、世界。　こんばんは、㔺界。""" lowerCAmelCase_ :Any = ["""こん""", """にちは""", """、""", """世界""", """。""", """<SP>""", """こん""", """ばんは""", """、""", """㔺界""", """。"""] lowerCAmelCase_ :Tuple = tokenizer.tokenize(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids without special tokens lowerCAmelCase_ :List[Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6] lowerCAmelCase_ :List[str] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) # Testing conversion to ids with special tokens lowerCAmelCase_ :Any = tokens + [tokenizer.unk_token] lowerCAmelCase_ :Union[str, Any] = [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19] lowerCAmelCase_ :Union[str, Any] = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :int = self.get_tokenizer() # Testing tokenization lowerCAmelCase_ :Optional[int] = """こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。""" lowerCAmelCase_ :str = """こんにちは、、、、世界。こんばんは、、、、世界。""" lowerCAmelCase_ :str = tokenizer.encode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Tuple = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Any = """こんばんは、㔺界。😀""" lowerCAmelCase_ :Optional[Any] = """こんにちは、世界。こんばんは、世界。😀""" lowerCAmelCase_ :List[Any] = tokenizer.encode(prefix_text + input_text ) lowerCAmelCase_ :List[str] = tokenizer.encode("""""" , prefix_text=prefix_text + input_text ) lowerCAmelCase_ :int = tokenizer.encode(__A , prefix_text=__A ) lowerCAmelCase_ :int = tokenizer.decode(__A ) lowerCAmelCase_ :Dict = tokenizer.decode(__A ) lowerCAmelCase_ :Tuple = tokenizer.decode(__A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) self.assertEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> Any: lowerCAmelCase_ :int = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) # Testing tokenization lowerCAmelCase_ :List[Any] = """こんにちは、世界。""" lowerCAmelCase_ :Optional[int] = """こんばんは、㔺界。😀""" lowerCAmelCase_ :List[str] = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :Dict = len(tokenizer.encode(__A ) ) - 2 lowerCAmelCase_ :int = [1] + [0] * (len_prefix + len_text + 1) lowerCAmelCase_ :List[Any] = [1] * (len_prefix + len_text + 1) + [0] lowerCAmelCase_ :Dict = [1] + [1] * (len_prefix) + [0] * (len_text + 1) lowerCAmelCase_ :List[Any] = tokenizer(prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[str] = tokenizer("""""" , prefix_text=prefix_text + input_text ).token_type_ids lowerCAmelCase_ :List[Any] = tokenizer(__A , prefix_text=__A ).token_type_ids self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) self.assertListEqual(__A , __A ) @slow def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :Dict = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = tokenizer.encode("""あンいワ""" ) lowerCAmelCase_ :Optional[Any] = tokenizer.encode("""""" , prefix_text="""あンいワ""" ) lowerCAmelCase_ :int = tokenizer.encode("""いワ""" , prefix_text="""あン""" ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertEqual(tokenizer.decode(__A ) , tokenizer.decode(__A ) ) self.assertNotEqual(__A , __A ) self.assertNotEqual(__A , __A ) self.assertEqual(x_token_a[1] , x_token_a[-1] ) # SEG token self.assertEqual(x_token_a[1] , x_token_a[3] ) # SEG token @slow def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Union[str, Any] = self.tokenizer_class.from_pretrained("""Tanrei/GPTSAN-japanese""" ) lowerCAmelCase_ :int = [["""武田信玄""", """は、"""], ["""織田信長""", """の配下の、"""]] lowerCAmelCase_ :Dict = tokenizer(__A , padding=__A ) lowerCAmelCase_ :Any = tokenizer.batch_encode_plus(__A , padding=__A ) # fmt: off lowerCAmelCase_ :int = [[3_5993, 8640, 2_5948, 3_5998, 3_0647, 3_5675, 3_5999, 3_5999], [3_5993, 1_0382, 9868, 3_5998, 3_0646, 9459, 3_0646, 3_5675]] lowerCAmelCase_ :List[str] = [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]] lowerCAmelCase_ :int = [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]] # fmt: on self.assertListEqual(x_token.input_ids , __A ) self.assertListEqual(x_token.token_type_ids , __A ) self.assertListEqual(x_token.attention_mask , __A ) self.assertListEqual(x_token_a.input_ids , __A ) self.assertListEqual(x_token_a.token_type_ids , __A ) self.assertListEqual(x_token_a.attention_mask , __A ) def __lowerCAmelCase ( self ) -> Tuple: # Intentionally convert some words to accommodate character fluctuations unique to Japanese pass def __lowerCAmelCase ( self ) -> str: # tokenizer has no padding token pass

"""simple docstring""" import gc import random import unittest import numpy as np import torch from transformers import ( CLIPImageProcessor, CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer, CLIPVisionConfig, CLIPVisionModelWithProjection, ) from diffusers import ( DiffusionPipeline, UnCLIPImageVariationPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel, ) from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel from diffusers.utils import floats_tensor, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _SCREAMING_SNAKE_CASE ( A__ , unittest.TestCase ): UpperCAmelCase_ :Any = UnCLIPImageVariationPipeline UpperCAmelCase_ :Union[str, Any] = IMAGE_VARIATION_PARAMS - {"height", "width", "guidance_scale"} UpperCAmelCase_ :Dict = IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :Optional[Any] = [ "generator", "return_dict", "decoder_num_inference_steps", "super_res_num_inference_steps", ] UpperCAmelCase_ :Optional[int] = False @property def __lowerCAmelCase ( self ) -> int: return 32 @property def __lowerCAmelCase ( self ) -> Tuple: return 32 @property def __lowerCAmelCase ( self ) -> Dict: return self.time_input_dim @property def __lowerCAmelCase ( self ) -> List[Any]: return self.time_input_dim * 4 @property def __lowerCAmelCase ( self ) -> int: return 100 @property def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :int = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) return tokenizer @property def __lowerCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) lowerCAmelCase_ :List[Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) return CLIPTextModelWithProjection(__A ) @property def __lowerCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) lowerCAmelCase_ :str = CLIPVisionConfig( hidden_size=self.text_embedder_hidden_size , projection_dim=self.text_embedder_hidden_size , num_hidden_layers=5 , num_attention_heads=4 , image_size=32 , intermediate_size=37 , patch_size=1 , ) return CLIPVisionModelWithProjection(__A ) @property def __lowerCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) lowerCAmelCase_ :int = { """clip_embeddings_dim""": self.text_embedder_hidden_size, """time_embed_dim""": self.time_embed_dim, """cross_attention_dim""": self.cross_attention_dim, } lowerCAmelCase_ :Any = UnCLIPTextProjModel(**__A ) return model @property def __lowerCAmelCase ( self ) -> Optional[int]: torch.manual_seed(0 ) lowerCAmelCase_ :Union[str, Any] = { """sample_size""": 32, # RGB in channels """in_channels""": 3, # Out channels is double in channels because predicts mean and variance """out_channels""": 6, """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""), """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""), """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""", """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2), """layers_per_block""": 1, """cross_attention_dim""": self.cross_attention_dim, """attention_head_dim""": 4, """resnet_time_scale_shift""": """scale_shift""", """class_embed_type""": """identity""", } lowerCAmelCase_ :Any = UNetaDConditionModel(**__A ) return model @property def __lowerCAmelCase ( self ) -> Any: return { "sample_size": 64, "layers_per_block": 1, "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"), "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"), "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2), "in_channels": 6, "out_channels": 3, } @property def __lowerCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = UNetaDModel(**self.dummy_super_res_kwargs ) return model @property def __lowerCAmelCase ( self ) -> Union[str, Any]: # seeded differently to get different unet than `self.dummy_super_res_first` torch.manual_seed(1 ) lowerCAmelCase_ :Union[str, Any] = UNetaDModel(**self.dummy_super_res_kwargs ) return model def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Tuple = self.dummy_decoder lowerCAmelCase_ :str = self.dummy_text_proj lowerCAmelCase_ :Any = self.dummy_text_encoder lowerCAmelCase_ :Optional[Any] = self.dummy_tokenizer lowerCAmelCase_ :Dict = self.dummy_super_res_first lowerCAmelCase_ :Optional[Any] = self.dummy_super_res_last lowerCAmelCase_ :int = UnCLIPScheduler( variance_type="""learned_range""" , prediction_type="""epsilon""" , num_train_timesteps=1000 , ) lowerCAmelCase_ :List[str] = UnCLIPScheduler( variance_type="""fixed_small_log""" , prediction_type="""epsilon""" , num_train_timesteps=1000 , ) lowerCAmelCase_ :Optional[Any] = CLIPImageProcessor(crop_size=32 , size=32 ) lowerCAmelCase_ :Dict = self.dummy_image_encoder return { "decoder": decoder, "text_encoder": text_encoder, "tokenizer": tokenizer, "text_proj": text_proj, "feature_extractor": feature_extractor, "image_encoder": image_encoder, "super_res_first": super_res_first, "super_res_last": super_res_last, "decoder_scheduler": decoder_scheduler, "super_res_scheduler": super_res_scheduler, } def __lowerCAmelCase ( self , __A , __A=0 , __A=True ) -> Dict: lowerCAmelCase_ :Tuple = floats_tensor((1, 3, 32, 32) , rng=random.Random(__A ) ).to(__A ) if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :List[Any] = torch.manual_seed(__A ) else: lowerCAmelCase_ :str = torch.Generator(device=__A ).manual_seed(__A ) if pil_image: lowerCAmelCase_ :int = input_image * 0.5 + 0.5 lowerCAmelCase_ :Any = input_image.clamp(0 , 1 ) lowerCAmelCase_ :Optional[Any] = input_image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() lowerCAmelCase_ :Tuple = DiffusionPipeline.numpy_to_pil(__A )[0] return { "image": input_image, "generator": generator, "decoder_num_inference_steps": 2, "super_res_num_inference_steps": 2, "output_type": "np", } def __lowerCAmelCase ( self ) -> Dict: lowerCAmelCase_ :Optional[Any] = """cpu""" lowerCAmelCase_ :Optional[int] = self.get_dummy_components() lowerCAmelCase_ :Optional[int] = self.pipeline_class(**__A ) lowerCAmelCase_ :int = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Union[str, Any] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :Any = pipe(**__A ) lowerCAmelCase_ :Optional[int] = output.images lowerCAmelCase_ :List[Any] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :str = pipe( **__A , return_dict=__A , )[0] lowerCAmelCase_ :List[str] = image[0, -3:, -3:, -1] lowerCAmelCase_ :Optional[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :Any = np.array( [ 0.9_9_9_7, 0.0_0_0_2, 0.9_9_9_7, 0.9_9_9_7, 0.9_9_6_9, 0.0_0_2_3, 0.9_9_9_7, 0.9_9_6_9, 0.9_9_7_0, ] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :Optional[Any] = """cpu""" lowerCAmelCase_ :List[str] = self.get_dummy_components() lowerCAmelCase_ :Optional[Any] = self.pipeline_class(**__A ) lowerCAmelCase_ :Optional[Any] = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[Any] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :str = pipe(**__A ) lowerCAmelCase_ :Dict = output.images lowerCAmelCase_ :Union[str, Any] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :List[str] = pipe( **__A , return_dict=__A , )[0] lowerCAmelCase_ :str = image[0, -3:, -3:, -1] lowerCAmelCase_ :Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) lowerCAmelCase_ :str = np.array([0.9_9_9_7, 0.0_0_0_3, 0.9_9_9_7, 0.9_9_9_7, 0.9_9_7_0, 0.0_0_2_4, 0.9_9_9_7, 0.9_9_7_1, 0.9_9_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Union[str, Any] = """cpu""" lowerCAmelCase_ :Dict = self.get_dummy_components() lowerCAmelCase_ :Union[str, Any] = self.pipeline_class(**__A ) lowerCAmelCase_ :Dict = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Union[str, Any] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :int = [ pipeline_inputs["""image"""], pipeline_inputs["""image"""], ] lowerCAmelCase_ :List[str] = pipe(**__A ) lowerCAmelCase_ :Optional[int] = output.images lowerCAmelCase_ :Dict = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :List[Any] = [ tuple_pipeline_inputs["""image"""], tuple_pipeline_inputs["""image"""], ] lowerCAmelCase_ :Union[str, Any] = pipe( **__A , return_dict=__A , )[0] lowerCAmelCase_ :str = image[0, -3:, -3:, -1] lowerCAmelCase_ :List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (2, 64, 64, 3) lowerCAmelCase_ :Optional[Any] = np.array( [ 0.9_9_9_7, 0.9_9_8_9, 0.0_0_0_8, 0.0_0_2_1, 0.9_9_6_0, 0.0_0_1_8, 0.0_0_1_4, 0.0_0_0_2, 0.9_9_3_3, ] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2 def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Optional[Any] = torch.device("""cpu""" ) class _SCREAMING_SNAKE_CASE : UpperCAmelCase_ :str = 1 lowerCAmelCase_ :Dict = self.get_dummy_components() lowerCAmelCase_ :List[Any] = self.pipeline_class(**__A ) lowerCAmelCase_ :Optional[int] = pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :Dict = torch.Generator(device=__A ).manual_seed(0 ) lowerCAmelCase_ :Any = pipe.decoder.dtype lowerCAmelCase_ :Dict = 1 lowerCAmelCase_ :Optional[Any] = ( batch_size, pipe.decoder.config.in_channels, pipe.decoder.config.sample_size, pipe.decoder.config.sample_size, ) lowerCAmelCase_ :Optional[int] = pipe.prepare_latents( __A , dtype=__A , device=__A , generator=__A , latents=__A , scheduler=DummyScheduler() ) lowerCAmelCase_ :Tuple = ( batch_size, pipe.super_res_first.config.in_channels // 2, pipe.super_res_first.config.sample_size, pipe.super_res_first.config.sample_size, ) lowerCAmelCase_ :Optional[Any] = pipe.prepare_latents( __A , dtype=__A , device=__A , generator=__A , latents=__A , scheduler=DummyScheduler() ) lowerCAmelCase_ :List[str] = self.get_dummy_inputs(__A , pil_image=__A ) lowerCAmelCase_ :Dict = pipe( **__A , decoder_latents=__A , super_res_latents=__A ).images lowerCAmelCase_ :List[Any] = self.get_dummy_inputs(__A , pil_image=__A ) # Don't pass image, instead pass embedding lowerCAmelCase_ :Optional[Any] = pipeline_inputs.pop("""image""" ) lowerCAmelCase_ :Optional[int] = pipe.image_encoder(__A ).image_embeds lowerCAmelCase_ :Tuple = pipe( **__A , decoder_latents=__A , super_res_latents=__A , image_embeddings=__A , ).images # make sure passing text embeddings manually is identical assert np.abs(img_out_a - img_out_a ).max() < 1E-4 @skip_mps def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Union[str, Any] = torch_device == """cpu""" # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor lowerCAmelCase_ :Dict = 1E-2 self._test_attention_slicing_forward_pass( test_max_difference=__A , expected_max_diff=__A ) @skip_mps def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :List[Any] = torch_device == """cpu""" lowerCAmelCase_ :int = True lowerCAmelCase_ :Union[str, Any] = [ """decoder_num_inference_steps""", """super_res_num_inference_steps""", ] self._test_inference_batch_single_identical( test_max_difference=__A , relax_max_difference=__A , additional_params_copy_to_batched_inputs=__A , ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :str = [ """decoder_num_inference_steps""", """super_res_num_inference_steps""", ] if torch_device == "mps": # TODO: MPS errors with larger batch sizes lowerCAmelCase_ :List[str] = [2, 3] self._test_inference_batch_consistent( batch_sizes=__A , additional_params_copy_to_batched_inputs=__A , ) else: self._test_inference_batch_consistent( additional_params_copy_to_batched_inputs=__A ) @skip_mps def __lowerCAmelCase ( self ) -> Union[str, Any]: return super().test_dict_tuple_outputs_equivalent() @skip_mps def __lowerCAmelCase ( self ) -> Optional[int]: return super().test_save_load_local() @skip_mps def __lowerCAmelCase ( self ) -> Any: return super().test_save_load_optional_components() @slow @require_torch_gpu class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Union[str, Any]: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png""" ) lowerCAmelCase_ :str = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/unclip/karlo_v1_alpha_cat_variation_fp16.npy""" ) lowerCAmelCase_ :List[Any] = UnCLIPImageVariationPipeline.from_pretrained( """kakaobrain/karlo-v1-alpha-image-variations""" , torch_dtype=torch.floataa ) lowerCAmelCase_ :Optional[int] = pipeline.to(__A ) pipeline.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :str = torch.Generator(device="""cpu""" ).manual_seed(0 ) lowerCAmelCase_ :str = pipeline( __A , generator=__A , output_type="""np""" , ) lowerCAmelCase_ :List[str] = output.images[0] assert image.shape == (256, 256, 3) assert_mean_pixel_difference(__A , __A , 15 )

"""simple docstring""" import pandas as pd from matplotlib import pyplot as plt from sklearn.linear_model import LinearRegression # Splitting the dataset into the Training set and Test set from sklearn.model_selection import train_test_split # Fitting Polynomial Regression to the dataset from sklearn.preprocessing import PolynomialFeatures # Importing the dataset __UpperCAmelCase = pd.read_csv( 'https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/' 'position_salaries.csv' ) __UpperCAmelCase = dataset.iloc[:, 1:2].values __UpperCAmelCase = dataset.iloc[:, 2].values __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = train_test_split(X, y, test_size=0.2, random_state=0) __UpperCAmelCase = PolynomialFeatures(degree=4) __UpperCAmelCase = poly_reg.fit_transform(X) __UpperCAmelCase = LinearRegression() pol_reg.fit(X_poly, y) def _snake_case ( ) -> str: '''simple docstring''' plt.scatter(lowercase__ , lowercase__ , color="""red""" ) plt.plot(lowercase__ , pol_reg.predict(poly_reg.fit_transform(lowercase__ ) ) , color="""blue""" ) plt.title("""Truth or Bluff (Linear Regression)""" ) plt.xlabel("""Position level""" ) plt.ylabel("""Salary""" ) plt.show() if __name__ == "__main__": viz_polymonial() # Predicting a new result with Polymonial Regression pol_reg.predict(poly_reg.fit_transform([[5.5]])) # output should be 132148.43750003

"""simple docstring""" import math import random from typing import Any from .hill_climbing import SearchProblem def _snake_case ( lowercase__ : Any , lowercase__ : bool = True , lowercase__ : float = math.inf , lowercase__ : float = -math.inf , lowercase__ : float = math.inf , lowercase__ : float = -math.inf , lowercase__ : bool = False , lowercase__ : float = 1_0_0 , lowercase__ : float = 0.01 , lowercase__ : float = 1 , ) -> Any: '''simple docstring''' lowerCAmelCase_ :Any = False lowerCAmelCase_ :Optional[Any] = search_prob lowerCAmelCase_ :str = start_temperate lowerCAmelCase_ :Tuple = [] lowerCAmelCase_ :Tuple = 0 lowerCAmelCase_ :List[str] = None while not search_end: lowerCAmelCase_ :Tuple = current_state.score() if best_state is None or current_score > best_state.score(): lowerCAmelCase_ :Optional[Any] = current_state scores.append(lowercase__ ) iterations += 1 lowerCAmelCase_ :Union[str, Any] = None lowerCAmelCase_ :List[str] = current_state.get_neighbors() while ( next_state is None and neighbors ): # till we do not find a neighbor that we can move to lowerCAmelCase_ :List[Any] = random.randint(0 , len(lowercase__ ) - 1 ) # picking a random neighbor lowerCAmelCase_ :Optional[int] = neighbors.pop(lowercase__ ) lowerCAmelCase_ :Any = 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: lowerCAmelCase_ :Optional[Any] = change * -1 # in case we are finding minimum if change > 0: # improves the solution lowerCAmelCase_ :Optional[int] = picked_neighbor else: lowerCAmelCase_ :List[Any] = (math.e) ** ( change / current_temp ) # probability generation function if random.random() < probability: # random number within probability lowerCAmelCase_ :Union[str, Any] = picked_neighbor lowerCAmelCase_ :List[Any] = 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 lowerCAmelCase_ :Any = True else: lowerCAmelCase_ :str = next_state if visualization: from matplotlib import pyplot as plt plt.plot(range(lowercase__ ) , lowercase__ ) plt.xlabel("""Iterations""" ) plt.ylabel("""Function values""" ) plt.show() return best_state if __name__ == "__main__": def _snake_case ( lowercase__ : Tuple , lowercase__ : Union[str, Any] ) -> List[str]: '''simple docstring''' return (x**2) + (y**2) # starting the problem with initial coordinates (12, 47) __UpperCAmelCase = SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa) __UpperCAmelCase = simulated_annealing( prob, find_max=False, max_x=1_00, min_x=5, max_y=50, 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) __UpperCAmelCase = SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa) __UpperCAmelCase = simulated_annealing( prob, find_max=True, max_x=1_00, min_x=5, max_y=50, 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 _snake_case ( lowercase__ : List[str] , lowercase__ : str ) -> List[str]: '''simple docstring''' return (3 * x**2) - (6 * y) __UpperCAmelCase = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa) __UpperCAmelCase = 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()}""" ) __UpperCAmelCase = SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa) __UpperCAmelCase = 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()}""" )

"""simple docstring""" from __future__ import annotations __UpperCAmelCase = 1.6021e-19 # units = C def _snake_case ( lowercase__ : float , lowercase__ : float , lowercase__ : float , ) -> tuple[str, float]: '''simple docstring''' if (conductivity, electron_conc, mobility).count(0 ) != 1: raise ValueError("""You cannot supply more or less than 2 values""" ) elif conductivity < 0: raise ValueError("""Conductivity cannot be negative""" ) elif electron_conc < 0: raise ValueError("""Electron concentration cannot be negative""" ) elif mobility < 0: raise ValueError("""mobility cannot be negative""" ) elif conductivity == 0: return ( "conductivity", mobility * electron_conc * ELECTRON_CHARGE, ) elif electron_conc == 0: return ( "electron_conc", conductivity / (mobility * ELECTRON_CHARGE), ) else: return ( "mobility", conductivity / (electron_conc * ELECTRON_CHARGE), ) if __name__ == "__main__": import doctest doctest.testmod()

"""simple docstring""" import argparse import os import pickle import sys import torch from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging logging.set_verbosity_info() # We do this to be able to load python 2 datasets pickles # See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918 __UpperCAmelCase = data_utils.TransfoXLTokenizer __UpperCAmelCase = data_utils.TransfoXLCorpus __UpperCAmelCase = data_utils __UpperCAmelCase = data_utils def _snake_case ( lowercase__ : Union[str, Any] , lowercase__ : int , lowercase__ : str , lowercase__ : Any ) -> Optional[int]: '''simple docstring''' if transfo_xl_dataset_file: # Convert a pre-processed corpus (see original TensorFlow repo) with open(lowercase__ , """rb""" ) as fp: lowerCAmelCase_ :Tuple = pickle.load(lowercase__ , encoding="""latin1""" ) # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term) lowerCAmelCase_ :Optional[int] = pytorch_dump_folder_path + """/""" + VOCAB_FILES_NAMES["""pretrained_vocab_file"""] print(f"""Save vocabulary to {pytorch_vocab_dump_path}""" ) lowerCAmelCase_ :Union[str, Any] = corpus.vocab.__dict__ torch.save(lowercase__ , lowercase__ ) lowerCAmelCase_ :str = corpus.__dict__ corpus_dict_no_vocab.pop("""vocab""" , lowercase__ ) lowerCAmelCase_ :str = pytorch_dump_folder_path + """/""" + CORPUS_NAME print(f"""Save dataset to {pytorch_dataset_dump_path}""" ) torch.save(lowercase__ , lowercase__ ) if tf_checkpoint_path: # Convert a pre-trained TensorFlow model lowerCAmelCase_ :int = os.path.abspath(lowercase__ ) lowerCAmelCase_ :Any = os.path.abspath(lowercase__ ) print(f"""Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.""" ) # Initialise PyTorch model if transfo_xl_config_file == "": lowerCAmelCase_ :Optional[int] = TransfoXLConfig() else: lowerCAmelCase_ :Optional[Any] = TransfoXLConfig.from_json_file(lowercase__ ) print(f"""Building PyTorch model from configuration: {config}""" ) lowerCAmelCase_ :List[str] = TransfoXLLMHeadModel(lowercase__ ) lowerCAmelCase_ :Any = load_tf_weights_in_transfo_xl(lowercase__ , lowercase__ , lowercase__ ) # Save pytorch-model lowerCAmelCase_ :Any = os.path.join(lowercase__ , lowercase__ ) lowerCAmelCase_ :Optional[int] = os.path.join(lowercase__ , lowercase__ ) print(f"""Save PyTorch model to {os.path.abspath(lowercase__ )}""" ) torch.save(model.state_dict() , lowercase__ ) print(f"""Save configuration file to {os.path.abspath(lowercase__ )}""" ) with open(lowercase__ , """w""" , encoding="""utf-8""" ) as f: f.write(config.to_json_string() ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the folder to store the PyTorch model or dataset/vocab.', ) parser.add_argument( '--tf_checkpoint_path', default='', type=str, help='An optional path to a TensorFlow checkpoint path to be converted.', ) parser.add_argument( '--transfo_xl_config_file', default='', type=str, help=( 'An optional config json file corresponding to the pre-trained BERT model. \n' 'This specifies the model architecture.' ), ) parser.add_argument( '--transfo_xl_dataset_file', default='', type=str, help='An optional dataset file to be converted in a vocabulary.', ) __UpperCAmelCase = parser.parse_args() convert_transfo_xl_checkpoint_to_pytorch( args.tf_checkpoint_path, args.transfo_xl_config_file, args.pytorch_dump_folder_path, args.transfo_xl_dataset_file, )

"""simple docstring""" import warnings from ...utils import logging from .image_processing_clip import CLIPImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class _SCREAMING_SNAKE_CASE ( A__ ): def __init__( self , *__A , **__A ) -> None: warnings.warn( """The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use CLIPImageProcessor instead.""" , __A , ) super().__init__(*__A , **__A )

"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :int = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" from itertools import zip_longest import requests from bsa import BeautifulSoup from pandas import DataFrame def _snake_case ( lowercase__ : str = "laptop" ) -> DataFrame: '''simple docstring''' lowerCAmelCase_ :Dict = f"""https://www.amazon.in/laptop/s?k={product}""" lowerCAmelCase_ :List[str] = { """User-Agent""": """Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko)Chrome/44.0.2403.157 Safari/537.36""", """Accept-Language""": """en-US, en;q=0.5""", } lowerCAmelCase_ :List[Any] = BeautifulSoup(requests.get(lowercase__ , headers=lowercase__ ).text ) # Initialize a Pandas dataframe with the column titles lowerCAmelCase_ :Union[str, Any] = DataFrame( columns=[ """Product Title""", """Product Link""", """Current Price of the product""", """Product Rating""", """MRP of the product""", """Discount""", ] ) # Loop through each entry and store them in the dataframe for item, _ in zip_longest( soup.find_all( """div""" , attrs={"""class""": """s-result-item""", """data-component-type""": """s-search-result"""} , ) , soup.find_all("""div""" , attrs={"""class""": """a-row a-size-base a-color-base"""} ) , ): try: lowerCAmelCase_ :str = item.ha.text lowerCAmelCase_ :Dict = """https://www.amazon.in/""" + item.ha.a["""href"""] lowerCAmelCase_ :int = item.find("""span""" , attrs={"""class""": """a-offscreen"""} ).text try: lowerCAmelCase_ :Dict = item.find("""span""" , attrs={"""class""": """a-icon-alt"""} ).text except AttributeError: lowerCAmelCase_ :int = """Not available""" try: lowerCAmelCase_ :str = ( """₹""" + item.find( """span""" , attrs={"""class""": """a-price a-text-price"""} ).text.split("""₹""" )[1] ) except AttributeError: lowerCAmelCase_ :Optional[Any] = """""" try: lowerCAmelCase_ :str = float( ( ( float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) - float(product_price.strip("""₹""" ).replace(""",""" , """""" ) ) ) / float(product_mrp.strip("""₹""" ).replace(""",""" , """""" ) ) ) * 1_0_0 ) except ValueError: lowerCAmelCase_ :Union[str, Any] = float("""nan""" ) except AttributeError: pass lowerCAmelCase_ :Any = [ product_title, product_link, product_price, product_rating, product_mrp, discount, ] lowerCAmelCase_ :List[Any] = """ """ lowerCAmelCase_ :Tuple = """ """ data_frame.index += 1 return data_frame if __name__ == "__main__": __UpperCAmelCase = 'headphones' get_amazon_product_data(product).to_csv(F"""Amazon Product Data for {product}.csv""")

"""simple docstring""" # Copyright 2021 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import argparse import os from accelerate.utils import ComputeEnvironment from .cluster import get_cluster_input from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401 from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401 from .sagemaker import get_sagemaker_input __UpperCAmelCase = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine' def _snake_case ( ) -> Optional[int]: '''simple docstring''' lowerCAmelCase_ :Any = _ask_options( """In which compute environment are you running?""" , ["""This machine""", """AWS (Amazon SageMaker)"""] , _convert_compute_environment , ) if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: lowerCAmelCase_ :Tuple = get_sagemaker_input() else: lowerCAmelCase_ :Any = get_cluster_input() return config def _snake_case ( lowercase__ : Any=None ) -> Dict: '''simple docstring''' if subparsers is not None: lowerCAmelCase_ :Tuple = subparsers.add_parser("""config""" , description=lowercase__ ) else: lowerCAmelCase_ :Optional[Any] = argparse.ArgumentParser("""Accelerate config command""" , description=lowercase__ ) parser.add_argument( """--config_file""" , default=lowercase__ , help=( """The path to use to store the config file. Will default to a file named default_config.yaml in the cache """ """location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have """ """such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed """ """with 'huggingface'.""" ) , ) if subparsers is not None: parser.set_defaults(func=lowercase__ ) return parser def _snake_case ( lowercase__ : Any ) -> str: '''simple docstring''' lowerCAmelCase_ :Optional[Any] = get_user_input() if args.config_file is not None: lowerCAmelCase_ :Optional[int] = args.config_file else: if not os.path.isdir(lowercase__ ): os.makedirs(lowercase__ ) lowerCAmelCase_ :str = default_yaml_config_file if config_file.endswith(""".json""" ): config.to_json_file(lowercase__ ) else: config.to_yaml_file(lowercase__ ) print(f"""accelerate configuration saved at {config_file}""" ) def _snake_case ( ) -> Tuple: '''simple docstring''' lowerCAmelCase_ :Tuple = config_command_parser() lowerCAmelCase_ :Dict = parser.parse_args() config_command(lowercase__ ) if __name__ == "__main__": main()

"""simple docstring""" import shutil import tempfile import unittest from transformers import ClapFeatureExtractor, ClapProcessor, RobertaTokenizer, RobertaTokenizerFast from transformers.testing_utils import require_sentencepiece, require_torchaudio from .test_feature_extraction_clap import floats_list @require_torchaudio @require_sentencepiece class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> Optional[int]: lowerCAmelCase_ :Any = """laion/clap-htsat-unfused""" lowerCAmelCase_ :Optional[Any] = tempfile.mkdtemp() def __lowerCAmelCase ( self , **__A ) -> List[Any]: return RobertaTokenizer.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self , **__A ) -> Tuple: return ClapFeatureExtractor.from_pretrained(self.checkpoint , **__A ) def __lowerCAmelCase ( self ) -> int: shutil.rmtree(self.tmpdirname ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :Optional[Any] = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :Optional[Any] = ClapProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Tuple: lowerCAmelCase_ :Dict = ClapProcessor(tokenizer=self.get_tokenizer() , feature_extractor=self.get_feature_extractor() ) processor.save_pretrained(self.tmpdirname ) lowerCAmelCase_ :str = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) lowerCAmelCase_ :Dict = self.get_feature_extractor(do_normalize=__A , padding_value=1.0 ) lowerCAmelCase_ :Union[str, Any] = ClapProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=__A , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , __A ) self.assertEqual(processor.feature_extractor.to_json_string() , feature_extractor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.feature_extractor , __A ) def __lowerCAmelCase ( self ) -> Union[str, Any]: lowerCAmelCase_ :Dict = self.get_feature_extractor() lowerCAmelCase_ :str = self.get_tokenizer() lowerCAmelCase_ :List[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :Optional[Any] = floats_list((3, 1000) ) lowerCAmelCase_ :Optional[Any] = feature_extractor(__A , return_tensors="""np""" ) lowerCAmelCase_ :str = processor(audios=__A , return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1E-2 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :List[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :List[Any] = """This is a test string""" lowerCAmelCase_ :Dict = processor(text=__A ) lowerCAmelCase_ :List[str] = tokenizer(__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def __lowerCAmelCase ( self ) -> int: lowerCAmelCase_ :int = self.get_feature_extractor() lowerCAmelCase_ :Tuple = self.get_tokenizer() lowerCAmelCase_ :Optional[Any] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) lowerCAmelCase_ :int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] lowerCAmelCase_ :Tuple = processor.batch_decode(__A ) lowerCAmelCase_ :Optional[Any] = tokenizer.batch_decode(__A ) self.assertListEqual(__A , __A ) def __lowerCAmelCase ( self ) -> List[Any]: lowerCAmelCase_ :Optional[Any] = self.get_feature_extractor() lowerCAmelCase_ :Any = self.get_tokenizer() lowerCAmelCase_ :Optional[int] = ClapProcessor(tokenizer=__A , feature_extractor=__A ) self.assertListEqual( processor.model_input_names[2:] , feature_extractor.model_input_names , msg="""`processor` and `feature_extractor` model input names do not match""" , )

"""simple docstring""" __UpperCAmelCase = {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []} __UpperCAmelCase = {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]} def _snake_case ( lowercase__ : dict[int, list[int]] , lowercase__ : int , lowercase__ : list[bool] ) -> list[int]: '''simple docstring''' lowerCAmelCase_ :Dict = True lowerCAmelCase_ :Tuple = [] for neighbour in graph[vert]: if not visited[neighbour]: order += topology_sort(lowercase__ , lowercase__ , lowercase__ ) order.append(lowercase__ ) return order def _snake_case ( lowercase__ : dict[int, list[int]] , lowercase__ : int , lowercase__ : list[bool] ) -> list[int]: '''simple docstring''' lowerCAmelCase_ :Union[str, Any] = True lowerCAmelCase_ :List[str] = [vert] for neighbour in reversed_graph[vert]: if not visited[neighbour]: component += find_components(lowercase__ , lowercase__ , lowercase__ ) return component def _snake_case ( lowercase__ : dict[int, list[int]] ) -> list[list[int]]: '''simple docstring''' lowerCAmelCase_ :int = len(lowercase__ ) * [False] lowerCAmelCase_ :dict[int, list[int]] = {vert: [] for vert in range(len(lowercase__ ) )} for vert, neighbours in graph.items(): for neighbour in neighbours: reversed_graph[neighbour].append(lowercase__ ) lowerCAmelCase_ :str = [] for i, was_visited in enumerate(lowercase__ ): if not was_visited: order += topology_sort(lowercase__ , lowercase__ , lowercase__ ) lowerCAmelCase_ :Union[str, Any] = [] lowerCAmelCase_ :Union[str, Any] = len(lowercase__ ) * [False] for i in range(len(lowercase__ ) ): lowerCAmelCase_ :Optional[Any] = order[len(lowercase__ ) - i - 1] if not visited[vert]: lowerCAmelCase_ :Optional[Any] = find_components(lowercase__ , lowercase__ , lowercase__ ) components_list.append(lowercase__ ) return components_list

"""simple docstring""" import os from math import logaa def _snake_case ( lowercase__ : str = "base_exp.txt" ) -> int: '''simple docstring''' lowerCAmelCase_ :float = 0 lowerCAmelCase_ :Union[str, Any] = 0 for i, line in enumerate(open(os.path.join(os.path.dirname(lowercase__ ) , lowercase__ ) ) ): lowerCAmelCase_ , lowerCAmelCase_ :Union[str, Any] = list(map(lowercase__ , line.split(""",""" ) ) ) if x * logaa(lowercase__ ) > largest: lowerCAmelCase_ :Any = x * logaa(lowercase__ ) lowerCAmelCase_ :List[Any] = i + 1 return result if __name__ == "__main__": print(solution())

"""simple docstring""" def _snake_case ( lowercase__ : int ) -> int: '''simple docstring''' lowerCAmelCase_ :Dict = 0 while num > 0: digit_sum += num % 1_0 num //= 1_0 return digit_sum def _snake_case ( lowercase__ : int = 1_0_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :Dict = 1 lowerCAmelCase_ :Union[str, Any] = 2 for i in range(2 , max_n + 1 ): lowerCAmelCase_ :List[Any] = pre_numerator lowerCAmelCase_ :Dict = 2 * i // 3 if i % 3 == 0 else 1 lowerCAmelCase_ :Any = cur_numerator lowerCAmelCase_ :str = e_cont * pre_numerator + temp return sum_digits(lowercase__ ) if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" import itertools import math def _snake_case ( lowercase__ : int ) -> bool: '''simple docstring''' if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(lowercase__ ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def _snake_case ( ) -> Dict: '''simple docstring''' lowerCAmelCase_ :List[Any] = 2 while True: if is_prime(lowercase__ ): yield num num += 1 def _snake_case ( lowercase__ : int = 1_0_0_0_1 ) -> int: '''simple docstring''' return next(itertools.islice(prime_generator() , nth - 1 , lowercase__ ) ) if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" def _snake_case ( lowercase__ : int , lowercase__ : int ) -> str: '''simple docstring''' return "\n".join( f"""{number} * {i} = {number * i}""" for i in range(1 , number_of_terms + 1 ) ) if __name__ == "__main__": print(multiplication_table(number=5, number_of_terms=10))

"""simple docstring""" def _snake_case ( lowercase__ : int = 5_0 ) -> int: '''simple docstring''' lowerCAmelCase_ :int = [1] * (length + 1) for row_length in range(3 , length + 1 ): for block_length in range(3 , row_length + 1 ): for block_start in range(row_length - block_length ): ways_number[row_length] += ways_number[ row_length - block_start - block_length - 1 ] ways_number[row_length] += 1 return ways_number[length] if __name__ == "__main__": print(F"""{solution() = }""")

"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging __UpperCAmelCase = logging.get_logger(__name__) __UpperCAmelCase = {} class _SCREAMING_SNAKE_CASE ( A__ ): UpperCAmelCase_ :List[Any] = "llama" UpperCAmelCase_ :str = ["past_key_values"] def __init__( self , __A=3_2000 , __A=4096 , __A=1_1008 , __A=32 , __A=32 , __A=None , __A="silu" , __A=2048 , __A=0.0_2 , __A=1E-6 , __A=True , __A=0 , __A=1 , __A=2 , __A=1 , __A=False , __A=None , **__A , ) -> List[str]: lowerCAmelCase_ :str = vocab_size lowerCAmelCase_ :str = max_position_embeddings lowerCAmelCase_ :int = hidden_size lowerCAmelCase_ :List[str] = intermediate_size lowerCAmelCase_ :Tuple = num_hidden_layers lowerCAmelCase_ :Dict = num_attention_heads # for backward compatibility if num_key_value_heads is None: lowerCAmelCase_ :List[str] = num_attention_heads lowerCAmelCase_ :Any = num_key_value_heads lowerCAmelCase_ :Optional[int] = hidden_act lowerCAmelCase_ :Any = initializer_range lowerCAmelCase_ :str = rms_norm_eps lowerCAmelCase_ :List[Any] = pretraining_tp lowerCAmelCase_ :int = use_cache lowerCAmelCase_ :List[Any] = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=__A , bos_token_id=__A , eos_token_id=__A , tie_word_embeddings=__A , **__A , ) def __lowerCAmelCase ( self ) -> List[Any]: if self.rope_scaling is None: return if not isinstance(self.rope_scaling , __A ) or len(self.rope_scaling ) != 2: raise ValueError( """`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, """ f"""got {self.rope_scaling}""" ) lowerCAmelCase_ :List[str] = self.rope_scaling.get("""type""" , __A ) lowerCAmelCase_ :List[Any] = self.rope_scaling.get("""factor""" , __A ) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( f"""`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}""" ) if rope_scaling_factor is None or not isinstance(__A , __A ) or rope_scaling_factor <= 1.0: raise ValueError(f"""`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}""" )

"""simple docstring""" # This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/ 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, ControlNetModel, DDIMScheduler, StableDiffusionControlNetImgaImgPipeline, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import ( IMAGE_TO_IMAGE_IMAGE_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS, ) from ..test_pipelines_common import ( PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin, ) enable_full_determinism() class _SCREAMING_SNAKE_CASE ( A__ , A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :Tuple = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :List[str] = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"} ) UpperCAmelCase_ :Optional[Any] = IMAGE_TO_IMAGE_IMAGE_PARAMS def __lowerCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) lowerCAmelCase_ :Tuple = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :List[str] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Union[str, Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :List[Any] = CLIPTextModel(__A ) lowerCAmelCase_ :int = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Union[str, Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> List[str]: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Tuple = torch.manual_seed(__A ) else: lowerCAmelCase_ :Optional[int] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :List[Any] = 2 lowerCAmelCase_ :int = randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ) lowerCAmelCase_ :Optional[int] = floats_tensor(control_image.shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Tuple = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :Union[str, Any] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> int: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Union[str, Any]: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) class _SCREAMING_SNAKE_CASE ( A__ , A__ , unittest.TestCase ): UpperCAmelCase_ :List[str] = StableDiffusionControlNetImgaImgPipeline UpperCAmelCase_ :int = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} UpperCAmelCase_ :str = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS UpperCAmelCase_ :int = frozenset([] ) # TO_DO: add image_params once refactored VaeImageProcessor.preprocess def __lowerCAmelCase ( self ) -> Optional[int]: torch.manual_seed(0 ) lowerCAmelCase_ :Dict = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=32 , ) torch.manual_seed(0 ) def init_weights(__A ): if isinstance(__A , torch.nn.Convad ): torch.nn.init.normal(m.weight ) m.bias.data.fill_(1.0 ) lowerCAmelCase_ :List[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = ControlNetModel( block_out_channels=(32, 64) , layers_per_block=2 , in_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") , cross_attention_dim=32 , conditioning_embedding_out_channels=(16, 32) , ) controlneta.controlnet_down_blocks.apply(__A ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="""scaled_linear""" , clip_sample=__A , set_alpha_to_one=__A , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[int] = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , ) torch.manual_seed(0 ) lowerCAmelCase_ :Optional[Any] = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) lowerCAmelCase_ :str = CLIPTextModel(__A ) lowerCAmelCase_ :str = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ) lowerCAmelCase_ :Optional[Any] = MultiControlNetModel([controlneta, controlneta] ) lowerCAmelCase_ :List[Any] = { """unet""": unet, """controlnet""": controlnet, """scheduler""": scheduler, """vae""": vae, """text_encoder""": text_encoder, """tokenizer""": tokenizer, """safety_checker""": None, """feature_extractor""": None, } return components def __lowerCAmelCase ( self , __A , __A=0 ) -> str: if str(__A ).startswith("""mps""" ): lowerCAmelCase_ :Optional[Any] = torch.manual_seed(__A ) else: lowerCAmelCase_ :List[Any] = torch.Generator(device=__A ).manual_seed(__A ) lowerCAmelCase_ :Optional[Any] = 2 lowerCAmelCase_ :Optional[int] = [ randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), randn_tensor( (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) , generator=__A , device=torch.device(__A ) , ), ] lowerCAmelCase_ :int = floats_tensor(control_image[0].shape , rng=random.Random(__A ) ).to(__A ) lowerCAmelCase_ :Optional[Any] = image.cpu().permute(0 , 2 , 3 , 1 )[0] lowerCAmelCase_ :List[Any] = Image.fromarray(np.uinta(__A ) ).convert("""RGB""" ).resize((64, 64) ) lowerCAmelCase_ :List[str] = { """prompt""": """A painting of a squirrel eating a burger""", """generator""": generator, """num_inference_steps""": 2, """guidance_scale""": 6.0, """output_type""": """numpy""", """image""": image, """control_image""": control_image, } return inputs def __lowerCAmelCase ( self ) -> Optional[Any]: lowerCAmelCase_ :List[str] = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) lowerCAmelCase_ :Union[str, Any] = 1_0.0 lowerCAmelCase_ :Union[str, Any] = 4 lowerCAmelCase_ :Tuple = self.get_dummy_inputs(__A ) lowerCAmelCase_ :List[str] = steps lowerCAmelCase_ :int = scale lowerCAmelCase_ :Union[str, Any] = pipe(**__A )[0] lowerCAmelCase_ :Any = self.get_dummy_inputs(__A ) lowerCAmelCase_ :str = steps lowerCAmelCase_ :str = scale lowerCAmelCase_ :Tuple = pipe(**__A , control_guidance_start=0.1 , control_guidance_end=0.2 )[0] lowerCAmelCase_ :Optional[Any] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Union[str, Any] = steps lowerCAmelCase_ :Union[str, Any] = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=[0.1, 0.3] , control_guidance_end=[0.2, 0.7] )[0] lowerCAmelCase_ :List[str] = self.get_dummy_inputs(__A ) lowerCAmelCase_ :Optional[int] = steps lowerCAmelCase_ :Tuple = scale lowerCAmelCase_ :str = pipe(**__A , control_guidance_start=0.4 , control_guidance_end=[0.5, 0.8] )[0] # make sure that all outputs are different assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 assert np.sum(np.abs(output_a - output_a ) ) > 1E-3 def __lowerCAmelCase ( self ) -> Dict: return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3 ) @unittest.skipIf( torch_device != """cuda""" or not is_xformers_available() , reason="""XFormers attention is only available with CUDA and `xformers` installed""" , ) def __lowerCAmelCase ( self ) -> Tuple: self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> Optional[int]: self._test_inference_batch_single_identical(expected_max_diff=2E-3 ) def __lowerCAmelCase ( self ) -> List[str]: lowerCAmelCase_ :str = self.get_dummy_components() lowerCAmelCase_ :Tuple = self.pipeline_class(**__A ) pipe.to(__A ) pipe.set_progress_bar_config(disable=__A ) with tempfile.TemporaryDirectory() as tmpdir: try: # save_pretrained is not implemented for Multi-ControlNet pipe.save_pretrained(__A ) except NotImplementedError: pass @slow @require_torch_gpu class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __lowerCAmelCase ( self ) -> int: super().tearDown() gc.collect() torch.cuda.empty_cache() def __lowerCAmelCase ( self ) -> str: lowerCAmelCase_ :Any = ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny""" ) lowerCAmelCase_ :int = StableDiffusionControlNetImgaImgPipeline.from_pretrained( """runwayml/stable-diffusion-v1-5""" , safety_checker=__A , controlnet=__A ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=__A ) lowerCAmelCase_ :List[str] = torch.Generator(device="""cpu""" ).manual_seed(0 ) lowerCAmelCase_ :List[Any] = """evil space-punk bird""" lowerCAmelCase_ :List[Any] = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png""" ).resize((512, 512) ) lowerCAmelCase_ :int = load_image( """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png""" ).resize((512, 512) ) lowerCAmelCase_ :Union[str, Any] = pipe( __A , __A , control_image=__A , generator=__A , output_type="""np""" , num_inference_steps=50 , strength=0.6 , ) lowerCAmelCase_ :Tuple = output.images[0] assert image.shape == (512, 512, 3) lowerCAmelCase_ :Tuple = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy""" ) assert np.abs(expected_image - image ).max() < 9E-2