code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if divisor % 5 == 0 or divisor % 2 == 0: return 0 lowercase : str = 1 lowercase : str = 1 while repunit: lowercase : Tuple = (10 * repunit + 1) % divisor repunit_index += 1 return repunit_index def _snake_case( SCREAMING_SNAKE_CASE__ = 1_000_000 ) -> int: lowercase : List[Any] = limit - 1 if divisor % 2 == 0: divisor += 1 while least_divisible_repunit(SCREAMING_SNAKE_CASE__ ) <= limit: divisor += 2 return divisor if __name__ == "__main__": print(F'''{solution() = }''')
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING lowercase : Any = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == """tf""" else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = {} if top_k is not None: lowercase : int = top_k return {}, {}, postprocess_params def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = load_image(snake_case ) lowercase : List[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = self.model(**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ): '''simple docstring''' if top_k > self.model.config.num_labels: lowercase : Tuple = self.model.config.num_labels if self.framework == "pt": lowercase : str = model_outputs.logits.softmax(-1 )[0] lowercase , lowercase : Dict = probs.topk(snake_case ) elif self.framework == "tf": lowercase : Optional[int] = stable_softmax(model_outputs.logits ,axis=-1 )[0] lowercase : Union[str, Any] = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : List[str] = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f"Unsupported framework: {self.framework}" ) lowercase : Tuple = scores.tolist() lowercase : Dict = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case ,snake_case )]
20
1
import qiskit def _snake_case( SCREAMING_SNAKE_CASE__ = 2 ) -> qiskit.result.counts.Counts: lowercase : Any = qubits # Using Aer's simulator lowercase : Any = qiskit.Aer.get_backend("""aer_simulator""" ) # Creating a Quantum Circuit acting on the q register lowercase : List[str] = qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) # Adding a H gate on qubit 0 (now q0 in superposition) circuit.h(0 ) for i in range(1 , SCREAMING_SNAKE_CASE__ ): # Adding CX (CNOT) gate circuit.cx(i - 1 , SCREAMING_SNAKE_CASE__ ) # Mapping the quantum measurement to the classical bits circuit.measure(list(range(SCREAMING_SNAKE_CASE__ ) ) , list(range(SCREAMING_SNAKE_CASE__ ) ) ) # Now measuring any one qubit would affect other qubits to collapse # their super position and have same state as the measured one. # Executing the circuit on the simulator lowercase : int = qiskit.execute(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , shots=1_000 ) return job.result().get_counts(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": print(F'''Total count for various states are: {quantum_entanglement(3)}''')
20
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
1
import functools def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: # Validation if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) or not all(isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) for day in days ): raise ValueError("""The parameter days should be a list of integers""" ) if len(SCREAMING_SNAKE_CASE__ ) != 3 or not all(isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) for cost in costs ): raise ValueError("""The parameter costs should be a list of three integers""" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: return 0 if min(SCREAMING_SNAKE_CASE__ ) <= 0: raise ValueError("""All days elements should be greater than 0""" ) if max(SCREAMING_SNAKE_CASE__ ) >= 366: raise ValueError("""All days elements should be less than 366""" ) lowercase : List[Any] = set(SCREAMING_SNAKE_CASE__ ) @functools.cache def dynamic_programming(SCREAMING_SNAKE_CASE__ ) -> int: if index > 365: return 0 if index not in days_set: return dynamic_programming(index + 1 ) return min( costs[0] + dynamic_programming(index + 1 ) , costs[1] + dynamic_programming(index + 7 ) , costs[2] + dynamic_programming(index + 30 ) , ) return dynamic_programming(1 ) if __name__ == "__main__": import doctest doctest.testmod()
20
import json import os from dataclasses import dataclass from functools import partial from typing import Callable import flax.linen as nn import jax import jax.numpy as jnp import joblib import optax import wandb from flax import jax_utils, struct, traverse_util from flax.serialization import from_bytes, to_bytes from flax.training import train_state from flax.training.common_utils import shard from tqdm.auto import tqdm from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule class __snake_case ( lowerCAmelCase ): _a : BigBirdConfig _a : jnp.dtype= jnp.floataa _a : bool= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setup() lowercase : List[str] = nn.Dense(5 ,dtype=self.dtype ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = super().__call__(*snake_case ,**snake_case ) lowercase : Any = self.cls(outputs[2] ) return outputs[:2] + (cls_out,) class __snake_case ( lowerCAmelCase ): _a : List[Any]= FlaxBigBirdForNaturalQuestionsModule def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: def cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ): lowercase : int = logits.shape[-1] lowercase : Dict = (labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__ )[None]).astype("""f4""" ) lowercase : Any = jax.nn.log_softmax(SCREAMING_SNAKE_CASE__ , axis=-1 ) lowercase : Optional[Any] = -jnp.sum(labels * logits , axis=-1 ) if reduction is not None: lowercase : Any = reduction(SCREAMING_SNAKE_CASE__ ) return loss lowercase : Optional[Any] = partial(SCREAMING_SNAKE_CASE__ , reduction=jnp.mean ) lowercase : Optional[int] = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Dict = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return (start_loss + end_loss + pooled_loss) / 3 @dataclass class __snake_case : _a : str= "google/bigbird-roberta-base" _a : int= 3000 _a : int= 1_0500 _a : int= 128 _a : int= 3 _a : int= 1 _a : int= 5 # tx_args _a : float= 3E-5 _a : float= 0.0 _a : int= 2_0000 _a : float= 0.00_95 _a : str= "bigbird-roberta-natural-questions" _a : str= "training-expt" _a : str= "data/nq-training.jsonl" _a : str= "data/nq-validation.jsonl" def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' os.makedirs(self.base_dir ,exist_ok=snake_case ) lowercase : Optional[int] = os.path.join(self.base_dir ,self.save_dir ) lowercase : Optional[int] = self.batch_size_per_device * jax.device_count() @dataclass class __snake_case : _a : int _a : int= 4096 # no dynamic padding on TPUs def __call__( self ,snake_case ): '''simple docstring''' lowercase : int = self.collate_fn(snake_case ) lowercase : Union[str, Any] = jax.tree_util.tree_map(snake_case ,snake_case ) return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Union[str, Any] = self.fetch_inputs(features["""input_ids"""] ) lowercase : Tuple = { """input_ids""": jnp.array(snake_case ,dtype=jnp.intaa ), """attention_mask""": jnp.array(snake_case ,dtype=jnp.intaa ), """start_labels""": jnp.array(features["""start_token"""] ,dtype=jnp.intaa ), """end_labels""": jnp.array(features["""end_token"""] ,dtype=jnp.intaa ), """pooled_labels""": jnp.array(features["""category"""] ,dtype=jnp.intaa ), } return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = [self._fetch_inputs(snake_case ) for ids in input_ids] return zip(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [1 for _ in range(len(snake_case ) )] while len(snake_case ) < self.max_length: input_ids.append(self.pad_id ) attention_mask.append(0 ) return input_ids, attention_mask def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> Any: if seed is not None: lowercase : Optional[int] = dataset.shuffle(seed=SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) // batch_size ): lowercase : Optional[Any] = dataset[i * batch_size : (i + 1) * batch_size] yield dict(SCREAMING_SNAKE_CASE__ ) @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[Any]: def loss_fn(SCREAMING_SNAKE_CASE__ ): lowercase : List[str] = model_inputs.pop("""start_labels""" ) lowercase : Optional[int] = model_inputs.pop("""end_labels""" ) lowercase : str = model_inputs.pop("""pooled_labels""" ) lowercase : Union[str, Any] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=SCREAMING_SNAKE_CASE__ , dropout_rng=SCREAMING_SNAKE_CASE__ , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[str] = outputs return state.loss_fn( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) lowercase , lowercase : int = jax.random.split(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = jax.value_and_grad(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : Union[str, Any] = grad_fn(state.params ) lowercase : List[Any] = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) lowercase : List[Any] = jax.lax.pmean(SCREAMING_SNAKE_CASE__ , """batch""" ) lowercase : str = state.apply_gradients(grads=SCREAMING_SNAKE_CASE__ ) return state, metrics, new_drp_rng @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = model_inputs.pop("""start_labels""" ) lowercase : Dict = model_inputs.pop("""end_labels""" ) lowercase : Optional[Any] = model_inputs.pop("""pooled_labels""" ) lowercase : Optional[int] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=state.params , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[Any] = outputs lowercase : Dict = state.loss_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : str = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) return metrics class __snake_case ( train_state.TrainState ): _a : Callable= struct.field(pytree_node=lowerCAmelCase ) @dataclass class __snake_case : _a : Args _a : Callable _a : Callable _a : Callable _a : Callable _a : wandb _a : Callable= None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = model.params lowercase : Any = TrainState.create( apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,loss_fn=snake_case ,) if ckpt_dir is not None: lowercase , lowercase , lowercase , lowercase , lowercase : Tuple = restore_checkpoint(snake_case ,snake_case ) lowercase : List[str] = { """lr""": args.lr, """init_lr""": args.init_lr, """warmup_steps""": args.warmup_steps, """num_train_steps""": num_train_steps, """weight_decay""": args.weight_decay, } lowercase , lowercase : Tuple = build_tx(**snake_case ) lowercase : str = train_state.TrainState( step=snake_case ,apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,opt_state=snake_case ,) lowercase : Any = args lowercase : Optional[Any] = data_collator lowercase : List[str] = lr lowercase : str = params lowercase : Tuple = jax_utils.replicate(snake_case ) return state def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = self.args lowercase : Optional[Any] = len(snake_case ) // args.batch_size lowercase : int = jax.random.PRNGKey(0 ) lowercase : List[str] = jax.random.split(snake_case ,jax.device_count() ) for epoch in range(args.max_epochs ): lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : List[str] = get_batched_dataset(snake_case ,args.batch_size ,seed=snake_case ) lowercase : int = 0 for batch in tqdm(snake_case ,total=snake_case ,desc=f"Running EPOCH-{epoch}" ): lowercase : Dict = self.data_collator(snake_case ) lowercase , lowercase , lowercase : Optional[int] = self.train_step_fn(snake_case ,snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 if i % args.logging_steps == 0: lowercase : Optional[Any] = jax_utils.unreplicate(state.step ) lowercase : List[str] = running_loss.item() / i lowercase : List[str] = self.scheduler_fn(state_step - 1 ) lowercase : int = self.evaluate(snake_case ,snake_case ) lowercase : Tuple = { """step""": state_step.item(), """eval_loss""": eval_loss.item(), """tr_loss""": tr_loss, """lr""": lr.item(), } tqdm.write(str(snake_case ) ) self.logger.log(snake_case ,commit=snake_case ) if i % args.save_steps == 0: self.save_checkpoint(args.save_dir + f"-e{epoch}-s{i}" ,state=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = get_batched_dataset(snake_case ,self.args.batch_size ) lowercase : Any = len(snake_case ) // self.args.batch_size lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : Optional[int] = 0 for batch in tqdm(snake_case ,total=snake_case ,desc="""Evaluating ... """ ): lowercase : Tuple = self.data_collator(snake_case ) lowercase : Optional[int] = self.val_step_fn(snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 return running_loss / i def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = jax_utils.unreplicate(snake_case ) print(f"SAVING CHECKPOINT IN {save_dir}" ,end=""" ... """ ) self.model_save_fn(snake_case ,params=state.params ) with open(os.path.join(snake_case ,"""opt_state.msgpack""" ) ,"""wb""" ) as f: f.write(to_bytes(state.opt_state ) ) joblib.dump(self.args ,os.path.join(snake_case ,"""args.joblib""" ) ) joblib.dump(self.data_collator ,os.path.join(snake_case ,"""data_collator.joblib""" ) ) with open(os.path.join(snake_case ,"""training_state.json""" ) ,"""w""" ) as f: json.dump({"""step""": state.step.item()} ,snake_case ) print("""DONE""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: print(f"RESTORING CHECKPOINT FROM {save_dir}" , end=""" ... """ ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """flax_model.msgpack""" ) , """rb""" ) as f: lowercase : str = from_bytes(state.params , f.read() ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """opt_state.msgpack""" ) , """rb""" ) as f: lowercase : Optional[int] = from_bytes(state.opt_state , f.read() ) lowercase : Optional[Any] = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """args.joblib""" ) ) lowercase : int = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """data_collator.joblib""" ) ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """training_state.json""" ) , """r""" ) as f: lowercase : Tuple = json.load(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = training_state["""step"""] print("""DONE""" ) return params, opt_state, step, args, data_collator def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : List[str] = num_train_steps - warmup_steps lowercase : Dict = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=SCREAMING_SNAKE_CASE__ , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=1e-7 , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = optax.join_schedules(schedules=[warmup_fn, decay_fn] , boundaries=[warmup_steps] ) return lr def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: def weight_decay_mask(SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = {k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()} return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = scheduler_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__ , weight_decay=SCREAMING_SNAKE_CASE__ , mask=SCREAMING_SNAKE_CASE__ ) return tx, lr
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> list[list]: lowercase : Dict = current_set.copy() for row_index, row in enumerate(SCREAMING_SNAKE_CASE__ ): lowercase : Tuple = row[0] for column_index, column in enumerate(SCREAMING_SNAKE_CASE__ ): if magnitude == 0: lowercase : Union[str, Any] = column continue lowercase : List[Any] = column / magnitude # Subtract to cancel term lowercase : Tuple = current_set[0] lowercase : Tuple = [first_row] lowercase : Union[str, Any] = current_set[1::] for row in current_set: lowercase : Any = [] # If first term is 0, it is already in form we want, so we preserve it if row[0] == 0: final_set.append(SCREAMING_SNAKE_CASE__ ) continue for column_index in range(len(SCREAMING_SNAKE_CASE__ ) ): temp_row.append(first_row[column_index] - row[column_index] ) final_set.append(SCREAMING_SNAKE_CASE__ ) # Create next recursion iteration set if len(final_set[0] ) != 3: lowercase : List[str] = final_set[0] lowercase : Dict = [] lowercase : str = [] for row in final_set[1::]: current_first_column.append(row[0] ) next_iteration.append(row[1::] ) lowercase : Dict = simplify(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): resultant[i].insert(0 , current_first_column[i] ) resultant.insert(0 , SCREAMING_SNAKE_CASE__ ) lowercase : Any = resultant return final_set def _snake_case( SCREAMING_SNAKE_CASE__ ) -> list: if len(SCREAMING_SNAKE_CASE__ ) == 0: raise IndexError("""solve_simultaneous() requires n lists of length n+1""" ) lowercase : str = len(SCREAMING_SNAKE_CASE__ ) + 1 if any(len(SCREAMING_SNAKE_CASE__ ) != _length for item in equations ): raise IndexError("""solve_simultaneous() requires n lists of length n+1""" ) for row in equations: if any(not isinstance(SCREAMING_SNAKE_CASE__ , (int, float) ) for column in row ): raise ValueError("""solve_simultaneous() requires lists of integers""" ) if len(SCREAMING_SNAKE_CASE__ ) == 1: return [equations[0][-1] / equations[0][0]] lowercase : str = equations.copy() if any(0 in row for row in data_set ): lowercase : Dict = data_set.copy() lowercase : int = [] for row_index, row in enumerate(SCREAMING_SNAKE_CASE__ ): if 0 not in row: lowercase : Tuple = data_set.pop(SCREAMING_SNAKE_CASE__ ) break if not full_row: raise ValueError("""solve_simultaneous() requires at least 1 full equation""" ) data_set.insert(0 , SCREAMING_SNAKE_CASE__ ) lowercase : Any = data_set.copy() lowercase : List[str] = simplify(SCREAMING_SNAKE_CASE__ ) lowercase : int = simplified[::-1] lowercase : list = [] for row in simplified: lowercase : List[Any] = row[-1] if not solutions: if row[-2] == 0: solutions.append(0 ) continue solutions.append(current_solution / row[-2] ) continue lowercase : int = row.copy()[: len(SCREAMING_SNAKE_CASE__ ) - 1 :] while temp_row[0] == 0: temp_row.pop(0 ) if len(SCREAMING_SNAKE_CASE__ ) == 0: solutions.append(0 ) continue lowercase : Optional[Any] = temp_row[1::] lowercase : Dict = temp_row[::-1] for column_index, column in enumerate(SCREAMING_SNAKE_CASE__ ): current_solution -= column * solutions[column_index] solutions.append(SCREAMING_SNAKE_CASE__ ) lowercase : Any = [] for item in solutions: final.append(float(round(SCREAMING_SNAKE_CASE__ , 5 ) ) ) return final[::-1] if __name__ == "__main__": import doctest doctest.testmod() lowercase : Any = [ [2, 1, 1, 1, 1, 4], [1, 2, 1, 1, 1, 5], [1, 1, 2, 1, 1, 6], [1, 1, 1, 2, 1, 7], [1, 1, 1, 1, 2, 8], ] print(solve_simultaneous(eq)) print(solve_simultaneous([[4, 2]]))
20
from math import sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' must been an int and positive" lowercase : Union[str, Any] = True # 0 and 1 are none primes. if number <= 1: lowercase : str = False for divisor in range(2 , int(round(sqrt(SCREAMING_SNAKE_CASE__ ) ) ) + 1 ): # if 'number' divisible by 'divisor' then sets 'status' # of false and break up the loop. if number % divisor == 0: lowercase : Any = False break # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'status' must been from type bool" return status def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" # beginList: contains all natural numbers from 2 up to N lowercase : str = list(range(2 , n + 1 ) ) lowercase : Tuple = [] # this list will be returns. # actual sieve of erathostenes for i in range(len(SCREAMING_SNAKE_CASE__ ) ): for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0): lowercase : Tuple = 0 # filters actual prime numbers. lowercase : int = [x for x in begin_list if x != 0] # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" lowercase : Dict = [] # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2 , n + 1 ): if is_prime(SCREAMING_SNAKE_CASE__ ): ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and number >= 0, "'number' must been an int and >= 0" lowercase : Tuple = [] # this list will be returns of the function. # potential prime number factors. lowercase : Optional[Any] = 2 lowercase : Any = number if number == 0 or number == 1: ans.append(SCREAMING_SNAKE_CASE__ ) # if 'number' not prime then builds the prime factorization of 'number' elif not is_prime(SCREAMING_SNAKE_CASE__ ): while quotient != 1: if is_prime(SCREAMING_SNAKE_CASE__ ) and (quotient % factor == 0): ans.append(SCREAMING_SNAKE_CASE__ ) quotient /= factor else: factor += 1 else: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Tuple = 0 # prime factorization of 'number' lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = max(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Union[str, Any] = 0 # prime factorization of 'number' lowercase : Tuple = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = min(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 == 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 == 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 != 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 != 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__ ) ), "'number' must been an int, even and > 2" lowercase : Union[str, Any] = [] # this list will returned # creates a list of prime numbers between 2 up to 'number' lowercase : str = get_prime_numbers(SCREAMING_SNAKE_CASE__ ) lowercase : Any = len(SCREAMING_SNAKE_CASE__ ) # run variable for while-loops. lowercase : Optional[Any] = 0 lowercase : List[Any] = None # exit variable. for break up the loops lowercase : Any = True while i < len_pn and loop: lowercase : str = i + 1 while j < len_pn and loop: if prime_numbers[i] + prime_numbers[j] == number: lowercase : Union[str, Any] = False ans.append(prime_numbers[i] ) ans.append(prime_numbers[j] ) j += 1 i += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (len(SCREAMING_SNAKE_CASE__ ) == 2) and (ans[0] + ans[1] == number) and is_prime(ans[0] ) and is_prime(ans[1] ) ), "'ans' must contains two primes. And sum of elements must been eq 'number'" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 0) and (numbera >= 0) ), "'number1' and 'number2' must been positive integer." lowercase : Union[str, Any] = 0 while numbera != 0: lowercase : Optional[int] = numbera % numbera lowercase : Optional[int] = numbera lowercase : Dict = rest # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( numbera >= 0 ), "'number' must been from type int and positive" return numbera def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 1) and (numbera >= 1) ), "'number1' and 'number2' must been positive integer." lowercase : Dict = 1 # actual answer that will be return. # for kgV (x,1) if numbera > 1 and numbera > 1: # builds the prime factorization of 'number1' and 'number2' lowercase : Optional[Any] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) elif numbera == 1 or numbera == 1: lowercase : Union[str, Any] = [] lowercase : List[str] = [] lowercase : Dict = max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = 0 lowercase : Optional[Any] = 0 lowercase : List[str] = [] # captured numbers int both 'primeFac1' and 'primeFac2' # iterates through primeFac1 for n in prime_fac_a: if n not in done: if n in prime_fac_a: lowercase : Dict = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ): ans *= n else: lowercase : List[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # iterates through primeFac2 for n in prime_fac_a: if n not in done: lowercase : Optional[int] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( ans >= 0 ), "'ans' must been from type int and positive" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'number' must been a positive int" lowercase : Dict = 0 lowercase : List[str] = 2 # this variable holds the answer while index < n: index += 1 ans += 1 # counts to the next number # if ans not prime then # runs to the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): ans += 1 # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and is_prime( SCREAMING_SNAKE_CASE__ ), "'ans' must been a prime number and from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert ( is_prime(SCREAMING_SNAKE_CASE__ ) and is_prime(SCREAMING_SNAKE_CASE__ ) and (p_number_a < p_number_a) ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" lowercase : List[str] = p_number_a + 1 # jump to the next number lowercase : List[Any] = [] # this list will be returns. # if number is not prime then # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 while number < p_number_a: ans.append(SCREAMING_SNAKE_CASE__ ) number += 1 # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ans[0] != p_number_a and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] != p_number_a ), "'ans' must been a list without the arguments" # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 1), "'n' must been int and >= 1" lowercase : Optional[Any] = [] # will be returned. for divisor in range(1 , n + 1 ): if n % divisor == 0: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] == n, "Error in function getDivisiors(...)" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number > 1 ), "'number' must been an int and >= 1" lowercase : str = get_divisors(SCREAMING_SNAKE_CASE__ ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (divisors[0] == 1) and (divisors[len(SCREAMING_SNAKE_CASE__ ) - 1] == number) ), "Error in help-function getDivisiors(...)" # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1] ) == number def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (denominator != 0) ), "The arguments must been from type int and 'denominator' != 0" # build the greatest common divisor of numerator and denominator. lowercase : Tuple = gcd(abs(SCREAMING_SNAKE_CASE__ ) , abs(SCREAMING_SNAKE_CASE__ ) ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numerator % gcd_of_fraction == 0) and (denominator % gcd_of_fraction == 0) ), "Error in function gcd(...,...)" return (numerator // gcd_of_fraction, denominator // gcd_of_fraction) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been a int and >= 0" lowercase : List[str] = 1 # this will be return. for factor in range(1 , n + 1 ): ans *= factor return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been an int and >= 0" lowercase : int = 0 lowercase : Union[str, Any] = 1 lowercase : int = 1 # this will be return for _ in range(n - 1 ): lowercase : Optional[int] = ans ans += fiba lowercase : Optional[int] = tmp return ans
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: if index == r: for j in range(SCREAMING_SNAKE_CASE__ ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location lowercase : Tuple = arr[i] combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 , SCREAMING_SNAKE_CASE__ , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # A temporary array to store all combination one by one lowercase : Optional[int] = [0] * r # Print all combination using temporary array 'data[]' combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , 0 , SCREAMING_SNAKE_CASE__ , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase : int = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
1
from __future__ import annotations import math from collections.abc import Callable def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = 100 , ) -> float: lowercase : List[Any] = x_start lowercase : Union[str, Any] = fnc(SCREAMING_SNAKE_CASE__ ) lowercase : Any = 0.0 for _ in range(SCREAMING_SNAKE_CASE__ ): # Approximates curve as a sequence of linear lines and sums their length lowercase : List[Any] = (x_end - x_start) / steps + xa lowercase : Dict = fnc(SCREAMING_SNAKE_CASE__ ) length += math.hypot(xa - xa , fxa - fxa ) # Increment step lowercase : List[Any] = xa lowercase : Union[str, Any] = fxa return length if __name__ == "__main__": def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: return math.sin(10 * x ) print("""f(x) = sin(10 * x)""") print("""The length of the curve from x = -10 to x = 10 is:""") lowercase : Optional[Any] = 10 while i <= 100000: print(F'''With {i} steps: {line_length(f, -10, 10, i)}''') i *= 10
20
import argparse import requests import torch from PIL import Image from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: if "cls_token" in name: lowercase : List[Any] = name.replace("""cls_token""" , """vit.embeddings.cls_token""" ) if "mask_token" in name: lowercase : Any = name.replace("""mask_token""" , """decoder.mask_token""" ) if "decoder_pos_embed" in name: lowercase : str = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : List[str] = name.replace("""pos_embed""" , """vit.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """vit.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : int = name.replace("""patch_embed.norm""" , """vit.embeddings.norm""" ) if "decoder_blocks" in name: lowercase : Tuple = name.replace("""decoder_blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[Any] = name.replace("""blocks""" , """vit.encoder.layer""" ) if "attn.proj" in name: lowercase : List[str] = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "norm1" in name: lowercase : Optional[Any] = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Union[str, Any] = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : Dict = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : Dict = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Dict = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : List[str] = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name: lowercase : Tuple = name.replace("""norm.weight""" , """vit.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name: lowercase : int = name.replace("""norm.bias""" , """vit.layernorm.bias""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: for key in orig_state_dict.copy().keys(): lowercase : List[Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if "qkv" in key: lowercase : int = key.split(""".""" ) lowercase : List[str] = int(key_split[1] ) if "decoder_blocks" in key: lowercase : Tuple = config.decoder_hidden_size lowercase : int = """decoder.decoder_layers.""" if "weight" in key: lowercase : List[Any] = val[:dim, :] lowercase : Tuple = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] elif "bias" in key: lowercase : str = val[:dim] lowercase : Dict = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Tuple = config.hidden_size lowercase : Union[str, Any] = """vit.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : Dict = val[-dim:, :] elif "bias" in key: lowercase : Any = val[:dim] lowercase : str = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Union[str, Any] = val return orig_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : int = ViTMAEConfig() if "large" in checkpoint_url: lowercase : Dict = 1_024 lowercase : str = 4_096 lowercase : Optional[Any] = 24 lowercase : Optional[Any] = 16 elif "huge" in checkpoint_url: lowercase : int = 14 lowercase : List[Any] = 1_280 lowercase : int = 5_120 lowercase : List[Any] = 32 lowercase : Any = 16 lowercase : List[str] = ViTMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" )["""model"""] lowercase : Tuple = ViTMAEImageProcessor(size=config.image_size ) lowercase : Optional[int] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() lowercase : Union[str, Any] = """https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg""" lowercase : Union[str, Any] = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ) lowercase : Optional[Any] = ViTMAEImageProcessor(size=config.image_size ) lowercase : List[Any] = image_processor(images=SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) # forward pass torch.manual_seed(2 ) lowercase : int = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits if "large" in checkpoint_url: lowercase : List[Any] = torch.tensor( [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]] ) elif "huge" in checkpoint_url: lowercase : Tuple = torch.tensor( [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]] ) else: lowercase : List[str] = torch.tensor( [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]] ) # verify logits assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print(f"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""", type=str, help="""URL of the checkpoint you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : List[Any] = parser.parse_args() convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
20
1
import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type ,pa.intaa() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with self.assertRaises(snake_case ): lowercase : Dict = pa.array(TypedSequence([1, 2, 3] ) ,type=pa.intaa() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with self.assertRaises(snake_case ): lowercase : Tuple = pa.array(TypedSequence([1, 2, 3] ,try_type=Value("""bool""" ) ,type=Value("""int64""" ) ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = pa.array(TypedSequence([1, 2, 3] ,type=Value("""int32""" ) ) ) self.assertEqual(arr.type ,pa.intaa() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): lowercase : str = pa.array(TypedSequence(["""foo""", """bar"""] ,type=Value("""int64""" ) ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = pa.array(TypedSequence([1, 2, 3] ,try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type ,pa.intaa() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = pa.array(TypedSequence(["""foo""", """bar"""] ,try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type ,pa.string() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = pa.array(TypedSequence([[[1, 2, 3]]] ,type=ArrayaD((1, 3) ,"""int64""" ) ) ) self.assertEqual(arr.type ,ArrayaDExtensionType((1, 3) ,"""int64""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): lowercase : Dict = pa.array(TypedSequence(["""foo""", """bar"""] ,type=ArrayaD((1, 3) ,"""int64""" ) ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = pa.array(TypedSequence([[[1, 2, 3]]] ,try_type=ArrayaD((1, 3) ,"""int64""" ) ) ) self.assertEqual(arr.type ,ArrayaDExtensionType((1, 3) ,"""int64""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = pa.array(TypedSequence(["""foo""", """bar"""] ,try_type=ArrayaD((1, 3) ,"""int64""" ) ) ) self.assertEqual(arr.type ,pa.string() ) @require_pil def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' import PIL.Image lowercase : Dict = PIL.Image.fromarray(np.arange(10 ,dtype=np.uinta ).reshape(2 ,5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" ,side_effect=snake_case ) as mock_cast_to_python_objects: lowercase : int = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] ,type=Image() ) ) lowercase , lowercase : Optional[int] = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" ,snake_case ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Union[str, Any] = pa.BufferReader(SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , pa.Buffer ) else pa.memory_map(SCREAMING_SNAKE_CASE__ ) lowercase : Any = pa.ipc.open_stream(SCREAMING_SNAKE_CASE__ ) lowercase : pa.Table = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 10] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: lowercase : int = pa.BufferOutputStream() lowercase : Optional[int] = pa.schema(SCREAMING_SNAKE_CASE__ ) if fields else None with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ , schema=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) lowercase , lowercase : Dict = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: lowercase : Optional[int] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__ , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _snake_case( ) -> Dict: lowercase : Union[str, Any] = pa.BufferOutputStream() lowercase : List[str] = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ , features=SCREAMING_SNAKE_CASE__ ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) lowercase , lowercase : str = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata lowercase : List[Any] = pa.BufferReader(output.getvalue() ) lowercase : Any = pa.ipc.open_stream(SCREAMING_SNAKE_CASE__ ) lowercase : pa.Table = f.read_all() lowercase : List[str] = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(SCREAMING_SNAKE_CASE__ ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 10] ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Dict = pa.BufferOutputStream() with ArrowWriter( stream=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ , hash_salt="""split_name""" , check_duplicates=SCREAMING_SNAKE_CASE__ , ) as writer: with pytest.raises(SCREAMING_SNAKE_CASE__ ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) lowercase , lowercase : Optional[Any] = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 10] ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: lowercase : List[Any] = pa.BufferOutputStream() with ArrowWriter( stream=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ , hash_salt="""split_name""" , check_duplicates=SCREAMING_SNAKE_CASE__ , ) as writer: with pytest.raises(SCREAMING_SNAKE_CASE__ ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=10 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=10 ) lowercase , lowercase : Dict = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 10] ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : str = pa.BufferOutputStream() with ArrowWriter( stream=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ , hash_salt="""split_name""" , check_duplicates=SCREAMING_SNAKE_CASE__ , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) lowercase , lowercase : Optional[int] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 10] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Union[str, Any] = pa.BufferOutputStream() lowercase : Tuple = pa.schema(SCREAMING_SNAKE_CASE__ ) if fields else None with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ , schema=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) lowercase , lowercase : str = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: lowercase : Union[str, Any] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__ , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 10] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Tuple = pa.BufferOutputStream() lowercase : List[str] = pa.schema(SCREAMING_SNAKE_CASE__ ) if fields else None with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ , schema=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) lowercase , lowercase : str = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: lowercase : Union[str, Any] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__ , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 10] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : List[str] = pa.BufferOutputStream() lowercase : List[Any] = pa.schema(SCREAMING_SNAKE_CASE__ ) if fields else None with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ , schema=SCREAMING_SNAKE_CASE__ , writer_batch_size=SCREAMING_SNAKE_CASE__ ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) lowercase , lowercase : Optional[int] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: lowercase : str = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__ , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _snake_case( ) -> int: with tempfile.TemporaryDirectory() as tmp_dir: lowercase : Tuple = {"""col_1""": pa.string(), """col_2""": pa.intaa()} lowercase : List[Any] = os.path.join(SCREAMING_SNAKE_CASE__ , """test.arrow""" ) with ArrowWriter(path=SCREAMING_SNAKE_CASE__ , schema=pa.schema(SCREAMING_SNAKE_CASE__ ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) lowercase , lowercase : str = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE__ , metadata=writer._schema.metadata ) _check_output(SCREAMING_SNAKE_CASE__ , 1 ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: if pa.types.is_list(SCREAMING_SNAKE_CASE__ ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: if isinstance(lst[0] , SCREAMING_SNAKE_CASE__ ): change_first_primitive_element_in_list(lst[0] , SCREAMING_SNAKE_CASE__ ) else: lowercase : Optional[Any] = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : List[str] = pa.array(TypedSequence(SCREAMING_SNAKE_CASE__ , optimized_int_type=SCREAMING_SNAKE_CASE__ ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: # in range lowercase : Dict = pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE__ , col=SCREAMING_SNAKE_CASE__ ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications lowercase : int = copy.deepcopy(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE__ , col=SCREAMING_SNAKE_CASE__ ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: lowercase : Optional[Any] = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=SCREAMING_SNAKE_CASE__ ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : str = """mock://dataset-train.arrow""" with ArrowWriter(path=SCREAMING_SNAKE_CASE__ , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(SCREAMING_SNAKE_CASE__ ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) lowercase , lowercase : Optional[int] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(SCREAMING_SNAKE_CASE__ ) def _snake_case( ) -> Dict: lowercase : Any = pa.BufferOutputStream() with ParquetWriter(stream=SCREAMING_SNAKE_CASE__ ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) lowercase , lowercase : List[str] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 lowercase : Union[str, Any] = pa.BufferReader(output.getvalue() ) lowercase : pa.Table = pq.read_table(SCREAMING_SNAKE_CASE__ ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import PIL.Image lowercase : str = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(SCREAMING_SNAKE_CASE__ , format="""png""" ) lowercase : Tuple = pa.BufferOutputStream() with ParquetWriter( stream=SCREAMING_SNAKE_CASE__ , features=Features({"""image""": Image()} ) , embed_local_files=SCREAMING_SNAKE_CASE__ ) as writer: writer.write({"""image""": image_path} ) writer.finalize() lowercase : int = pa.BufferReader(output.getvalue() ) lowercase : pa.Table = pq.read_table(SCREAMING_SNAKE_CASE__ ) lowercase : int = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , SCREAMING_SNAKE_CASE__ ) with open(SCREAMING_SNAKE_CASE__ , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _snake_case( ) -> str: lowercase : List[str] = pa.schema([pa.field("""col_1""" , pa.string() , nullable=SCREAMING_SNAKE_CASE__ )] ) lowercase : Optional[int] = pa.BufferOutputStream() with ArrowWriter(stream=SCREAMING_SNAKE_CASE__ ) as writer: writer._build_writer(inferred_schema=SCREAMING_SNAKE_CASE__ ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
20
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=0.999 , SCREAMING_SNAKE_CASE__="cosine" , ) -> List[Any]: if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.exp(t * -12.0 ) else: raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}" ) lowercase : int = [] for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = i / num_diffusion_timesteps lowercase : Optional[int] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) / alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ) ) return torch.tensor(SCREAMING_SNAKE_CASE__ , dtype=torch.floataa ) class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Tuple= [e.name for e in KarrasDiffusionSchedulers] _a : int= 2 @register_to_config def __init__( self ,snake_case = 1000 ,snake_case = 0.00_085 ,snake_case = 0.012 ,snake_case = "linear" ,snake_case = None ,snake_case = "epsilon" ,snake_case = False ,snake_case = False ,snake_case = 1.0 ,snake_case = "linspace" ,snake_case = 0 ,): '''simple docstring''' if trained_betas is not None: lowercase : List[str] = torch.tensor(snake_case ,dtype=torch.floataa ) elif beta_schedule == "linear": lowercase : Optional[Any] = torch.linspace(snake_case ,snake_case ,snake_case ,dtype=torch.floataa ) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. lowercase : int = ( torch.linspace(beta_start**0.5 ,beta_end**0.5 ,snake_case ,dtype=torch.floataa ) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule lowercase : Union[str, Any] = betas_for_alpha_bar(snake_case ,alpha_transform_type="""cosine""" ) elif beta_schedule == "exp": lowercase : int = betas_for_alpha_bar(snake_case ,alpha_transform_type="""exp""" ) else: raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}" ) lowercase : Any = 1.0 - self.betas lowercase : Dict = torch.cumprod(self.alphas ,dim=0 ) # set all values self.set_timesteps(snake_case ,snake_case ,snake_case ) lowercase : Tuple = use_karras_sigmas def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if schedule_timesteps is None: lowercase : Union[str, Any] = self.timesteps lowercase : Dict = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter ) == 0: lowercase : Dict = 1 if len(snake_case ) > 1 else 0 else: lowercase : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep lowercase : str = self._index_counter[timestep_int] return indices[pos].item() @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[Any] = self.index_for_timestep(snake_case ) lowercase : Dict = self.sigmas[step_index] lowercase : List[str] = sample / ((sigma**2 + 1) ** 0.5) return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,): '''simple docstring''' lowercase : Any = num_inference_steps lowercase : List[Any] = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": lowercase : Optional[int] = np.linspace(0 ,num_train_timesteps - 1 ,snake_case ,dtype=snake_case )[::-1].copy() elif self.config.timestep_spacing == "leading": lowercase : int = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : List[str] = (np.arange(0 ,snake_case ) * step_ratio).round()[::-1].copy().astype(snake_case ) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": lowercase : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : Optional[int] = (np.arange(snake_case ,0 ,-step_ratio )).round().copy().astype(snake_case ) timesteps -= 1 else: raise ValueError( f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." ) lowercase : Optional[int] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 ) lowercase : Dict = np.log(snake_case ) lowercase : Union[str, Any] = np.interp(snake_case ,np.arange(0 ,len(snake_case ) ) ,snake_case ) if self.config.use_karras_sigmas: lowercase : List[Any] = self._convert_to_karras(in_sigmas=snake_case ,num_inference_steps=self.num_inference_steps ) lowercase : Tuple = np.array([self._sigma_to_t(snake_case ,snake_case ) for sigma in sigmas] ) lowercase : Any = np.concatenate([sigmas, [0.0]] ).astype(np.floataa ) lowercase : List[Any] = torch.from_numpy(snake_case ).to(device=snake_case ) lowercase : List[Any] = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2 ), sigmas[-1:]] ) lowercase : Dict = torch.from_numpy(snake_case ) lowercase : List[Any] = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2 )] ) if str(snake_case ).startswith("""mps""" ): # mps does not support float64 lowercase : Any = timesteps.to(snake_case ,dtype=torch.floataa ) else: lowercase : str = timesteps.to(device=snake_case ) # empty dt and derivative lowercase : Union[str, Any] = None lowercase : Any = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter lowercase : str = defaultdict(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = np.log(snake_case ) # get distribution lowercase : Union[str, Any] = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range lowercase : Optional[int] = np.cumsum((dists >= 0) ,axis=0 ).argmax(axis=0 ).clip(max=log_sigmas.shape[0] - 2 ) lowercase : Any = low_idx + 1 lowercase : str = log_sigmas[low_idx] lowercase : Dict = log_sigmas[high_idx] # interpolate sigmas lowercase : int = (low - log_sigma) / (low - high) lowercase : Dict = np.clip(snake_case ,0 ,1 ) # transform interpolation to time range lowercase : Optional[Any] = (1 - w) * low_idx + w * high_idx lowercase : Tuple = t.reshape(sigma.shape ) return t def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : float = in_sigmas[-1].item() lowercase : float = in_sigmas[0].item() lowercase : Dict = 7.0 # 7.0 is the value used in the paper lowercase : Optional[int] = np.linspace(0 ,1 ,snake_case ) lowercase : int = sigma_min ** (1 / rho) lowercase : Any = sigma_max ** (1 / rho) lowercase : Tuple = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.dt is None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = True ,): '''simple docstring''' lowercase : Union[str, Any] = self.index_for_timestep(snake_case ) # advance index counter by 1 lowercase : Optional[int] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: lowercase : str = self.sigmas[step_index] lowercase : Optional[int] = self.sigmas[step_index + 1] else: # 2nd order / Heun's method lowercase : Dict = self.sigmas[step_index - 1] lowercase : Optional[Any] = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API lowercase : Union[str, Any] = 0 lowercase : Any = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": lowercase : Any = sigma_hat if self.state_in_first_order else sigma_next lowercase : int = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": lowercase : Union[str, Any] = sigma_hat if self.state_in_first_order else sigma_next lowercase : Optional[Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": lowercase : Optional[Any] = model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`" ) if self.config.clip_sample: lowercase : str = pred_original_sample.clamp( -self.config.clip_sample_range ,self.config.clip_sample_range ) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order lowercase : Optional[int] = (sample - pred_original_sample) / sigma_hat # 3. delta timestep lowercase : Union[str, Any] = sigma_next - sigma_hat # store for 2nd order step lowercase : Optional[int] = derivative lowercase : Union[str, Any] = dt lowercase : Union[str, Any] = sample else: # 2. 2nd order / Heun's method lowercase : Tuple = (sample - pred_original_sample) / sigma_next lowercase : Dict = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample lowercase : Tuple = self.dt lowercase : Optional[Any] = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" lowercase : List[str] = None lowercase : Tuple = None lowercase : Dict = None lowercase : List[Any] = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[int] = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype ) if original_samples.device.type == "mps" and torch.is_floating_point(snake_case ): # mps does not support float64 lowercase : List[Any] = self.timesteps.to(original_samples.device ,dtype=torch.floataa ) lowercase : List[str] = timesteps.to(original_samples.device ,dtype=torch.floataa ) else: lowercase : List[str] = self.timesteps.to(original_samples.device ) lowercase : Tuple = timesteps.to(original_samples.device ) lowercase : Any = [self.index_for_timestep(snake_case ,snake_case ) for t in timesteps] lowercase : int = sigmas[step_indices].flatten() while len(sigma.shape ) < len(original_samples.shape ): lowercase : Any = sigma.unsqueeze(-1 ) lowercase : Optional[int] = original_samples + noise * sigma return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase : str = {"""configuration_vit""": ["""VIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTConfig""", """ViTOnnxConfig"""]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = ["""ViTFeatureExtractor"""] lowercase : str = ["""ViTImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Dict = [ """VIT_PRETRAINED_MODEL_ARCHIVE_LIST""", """ViTForImageClassification""", """ViTForMaskedImageModeling""", """ViTModel""", """ViTPreTrainedModel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : str = [ """TFViTForImageClassification""", """TFViTModel""", """TFViTPreTrainedModel""", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Dict = [ """FlaxViTForImageClassification""", """FlaxViTModel""", """FlaxViTPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase : List[str] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch lowercase : List[str] = logging.get_logger(__name__) @add_end_docstrings( lowerCAmelCase , R"\n top_k (`int`, defaults to 5):\n The number of predictions to return.\n targets (`str` or `List[str]`, *optional*):\n When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n token will be used (with a warning, and that might be slower).\n\n " , ) class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if self.framework == "tf": lowercase : str = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": lowercase : Optional[int] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ) else: raise ValueError("""Unsupported framework""" ) return masked_index def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = self.get_masked_index(snake_case ) lowercase : Dict = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,f"No mask_token ({self.tokenizer.mask_token}) found on the input" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if isinstance(snake_case ,snake_case ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,**snake_case ): '''simple docstring''' if return_tensors is None: lowercase : int = self.framework lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=snake_case ) self.ensure_exactly_one_mask_token(snake_case ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[int] = self.model(**snake_case ) lowercase : Tuple = model_inputs["""input_ids"""] return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ,snake_case=None ): '''simple docstring''' if target_ids is not None and target_ids.shape[0] < top_k: lowercase : str = target_ids.shape[0] lowercase : Optional[Any] = model_outputs["""input_ids"""][0] lowercase : List[str] = model_outputs["""logits"""] if self.framework == "tf": lowercase : List[str] = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] lowercase : Tuple = outputs.numpy() lowercase : Tuple = outputs[0, masked_index, :] lowercase : Any = stable_softmax(snake_case ,axis=-1 ) if target_ids is not None: lowercase : Union[str, Any] = tf.gather_nd(tf.squeeze(snake_case ,0 ) ,target_ids.reshape(-1 ,1 ) ) lowercase : int = tf.expand_dims(snake_case ,0 ) lowercase : Tuple = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : int = topk.values.numpy(), topk.indices.numpy() else: lowercase : Optional[Any] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample lowercase : Union[str, Any] = outputs[0, masked_index, :] lowercase : Tuple = logits.softmax(dim=-1 ) if target_ids is not None: lowercase : List[str] = probs[..., target_ids] lowercase , lowercase : Union[str, Any] = probs.topk(snake_case ) lowercase : Any = [] lowercase : List[Any] = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() ,predictions.tolist() ) ): lowercase : Dict = [] for v, p in zip(_values ,_predictions ): # Copy is important since we're going to modify this array in place lowercase : Dict = input_ids.numpy().copy() if target_ids is not None: lowercase : Union[str, Any] = target_ids[p].tolist() lowercase : Tuple = p # Filter padding out: lowercase : List[str] = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back lowercase : Tuple = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : Optional[Any] = {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p] ), """sequence""": sequence} row.append(snake_case ) result.append(snake_case ) if single_mask: return result[0] return result def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if isinstance(snake_case ,snake_case ): lowercase : List[Any] = [targets] try: lowercase : List[str] = self.tokenizer.get_vocab() except Exception: lowercase : Any = {} lowercase : Dict = [] for target in targets: lowercase : Dict = vocab.get(snake_case ,snake_case ) if id_ is None: lowercase : Optional[int] = self.tokenizer( snake_case ,add_special_tokens=snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,max_length=1 ,truncation=snake_case ,)["""input_ids"""] if len(snake_case ) == 0: logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " """We cannot replace it with anything meaningful, ignoring it""" ) continue lowercase : Union[str, Any] = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`." ) target_ids.append(id_ ) lowercase : Optional[Any] = list(set(snake_case ) ) if len(snake_case ) == 0: raise ValueError("""At least one target must be provided when passed.""" ) lowercase : Optional[Any] = np.array(snake_case ) return target_ids def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : Dict = {} if targets is not None: lowercase : str = self.get_target_ids(snake_case ,snake_case ) lowercase : List[Any] = target_ids if top_k is not None: lowercase : List[str] = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,"""The tokenizer does not define a `mask_token`.""" ) return {}, {}, postprocess_params def __call__( self ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Tuple = super().__call__(snake_case ,**snake_case ) if isinstance(snake_case ,snake_case ) and len(snake_case ) == 1: return outputs[0] return outputs
20
1
import argparse import json import os from tensorflow.core.protobuf.saved_model_pba import SavedModel # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_copies.py lowercase : Optional[int] = """.""" # Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model) lowercase : Any = [ """Assert""", """AssignVariableOp""", """EmptyTensorList""", """MergeV2Checkpoints""", """ReadVariableOp""", """ResourceGather""", """RestoreV2""", """SaveV2""", """ShardedFilename""", """StatefulPartitionedCall""", """StaticRegexFullMatch""", """VarHandleOp""", ] def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: lowercase : Optional[int] = SavedModel() lowercase : str = [] with open(os.path.join(SCREAMING_SNAKE_CASE__ , """utils""" , """tf_ops""" , """onnx.json""" ) ) as f: lowercase : Any = json.load(SCREAMING_SNAKE_CASE__ )["""opsets"""] for i in range(1 , opset + 1 ): onnx_ops.extend(onnx_opsets[str(SCREAMING_SNAKE_CASE__ )] ) with open(SCREAMING_SNAKE_CASE__ , """rb""" ) as f: saved_model.ParseFromString(f.read() ) lowercase : str = set() # Iterate over every metagraph in case there is more than one (a saved model can contain multiple graphs) for meta_graph in saved_model.meta_graphs: # Add operations in the graph definition model_op_names.update(node.op for node in meta_graph.graph_def.node ) # Go through the functions in the graph definition for func in meta_graph.graph_def.library.function: # Add operations in each function model_op_names.update(node.op for node in func.node_def ) # Convert to list, sorted if you want lowercase : int = sorted(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = [] for op in model_op_names: if op not in onnx_ops and op not in INTERNAL_OPS: incompatible_ops.append(SCREAMING_SNAKE_CASE__ ) if strict and len(SCREAMING_SNAKE_CASE__ ) > 0: raise Exception(f"Found the following incompatible ops for the opset {opset}:\n" + incompatible_ops ) elif len(SCREAMING_SNAKE_CASE__ ) > 0: print(f"Found the following incompatible ops for the opset {opset}:" ) print(*SCREAMING_SNAKE_CASE__ , sep="""\n""" ) else: print(f"The saved model {saved_model_path} can properly be converted with ONNX." ) if __name__ == "__main__": lowercase : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--saved_model_path""", help="""Path of the saved model to check (the .pb file).""") parser.add_argument( """--opset""", default=12, type=int, help="""The ONNX opset against which the model has to be tested.""" ) parser.add_argument( """--framework""", choices=["""onnx"""], default="""onnx""", help="""Frameworks against which to test the saved model.""" ) parser.add_argument( """--strict""", action="""store_true""", help="""Whether make the checking strict (raise errors) or not (raise warnings)""" ) lowercase : Optional[int] = parser.parse_args() if args.framework == "onnx": onnx_compliancy(args.saved_model_path, args.strict, args.opset)
20
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 MobileNetVaImageProcessor class __snake_case ( unittest.TestCase ): def __init__( self ,snake_case ,snake_case=7 ,snake_case=3 ,snake_case=18 ,snake_case=30 ,snake_case=400 ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=None ,): '''simple docstring''' lowercase : Dict = size if size is not None else {"""shortest_edge""": 20} lowercase : Union[str, Any] = crop_size if crop_size is not None else {"""height""": 18, """width""": 18} lowercase : str = parent lowercase : int = batch_size lowercase : str = num_channels lowercase : int = image_size lowercase : List[str] = min_resolution lowercase : str = max_resolution lowercase : Dict = do_resize lowercase : Dict = size lowercase : Dict = do_center_crop lowercase : str = crop_size def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, } @require_torch @require_vision class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Any= MobileNetVaImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = MobileNetVaImageProcessingTester(self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case ,"""do_resize""" ) ) self.assertTrue(hasattr(snake_case ,"""size""" ) ) self.assertTrue(hasattr(snake_case ,"""do_center_crop""" ) ) self.assertTrue(hasattr(snake_case ,"""crop_size""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 20} ) self.assertEqual(image_processor.crop_size ,{"""height""": 18, """width""": 18} ) lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 ,crop_size=84 ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 42} ) self.assertEqual(image_processor.crop_size ,{"""height""": 84, """width""": 84} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowercase : str = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,Image.Image ) # Test not batched input lowercase : Dict = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : Tuple = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,numpify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,np.ndarray ) # Test not batched input lowercase : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,torchify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,torch.Tensor ) # Test not batched input lowercase : Optional[int] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,)
20
1
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) lowercase : Dict = """bert-base-cased""" lowercase : int = """fp16""" lowercase : Optional[int] = """bf16""" lowercase : str = [FPaa, BFaa] @require_fsdp @require_cuda class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() lowercase : str = dict( ACCELERATE_USE_FSDP="""true""" ,MASTER_ADDR="""localhost""" ,MASTER_PORT="""10999""" ,RANK="""0""" ,LOCAL_RANK="""0""" ,WORLD_SIZE="""1""" ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(snake_case ): lowercase : Tuple = self.dist_env.copy() lowercase : Dict = f"{i + 1}" lowercase : Optional[int] = strategy with mockenv_context(**snake_case ): lowercase : Any = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy ,ShardingStrategy(i + 1 ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(snake_case ): lowercase : Dict = self.dist_env.copy() lowercase : List[str] = prefetch_policy with mockenv_context(**snake_case ): lowercase : Tuple = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch ,BackwardPrefetch(i + 1 ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(snake_case ): lowercase : int = self.dist_env.copy() lowercase : List[str] = state_dict_type with mockenv_context(**snake_case ): lowercase : Optional[Any] = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type ,StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = AutoModel.from_pretrained(snake_case ) for policy in FSDP_AUTO_WRAP_POLICY: lowercase : str = self.dist_env.copy() lowercase : Optional[Any] = policy if policy == "TRANSFORMER_BASED_WRAP": lowercase : List[Any] = """BertLayer""" elif policy == "SIZE_BASED_WRAP": lowercase : List[str] = """2000""" with mockenv_context(**snake_case ): lowercase : Optional[Any] = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(snake_case ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) lowercase : Union[str, Any] = self.dist_env.copy() lowercase : Optional[int] = """TRANSFORMER_BASED_WRAP""" lowercase : Optional[int] = """T5Layer""" with mockenv_context(**snake_case ): lowercase : str = FullyShardedDataParallelPlugin() with self.assertRaises(snake_case ) as cm: fsdp_plugin.set_auto_wrap_policy(snake_case ) self.assertTrue("""Could not find the transformer layer class to wrap in the model.""" in str(cm.exception ) ) lowercase : List[str] = self.dist_env.copy() lowercase : Tuple = """SIZE_BASED_WRAP""" lowercase : List[Any] = """0""" with mockenv_context(**snake_case ): lowercase : Any = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(snake_case ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: lowercase : str = self.dist_env.copy() lowercase : List[Any] = mp_dtype with mockenv_context(**snake_case ): lowercase : Dict = Accelerator() if mp_dtype == "fp16": lowercase : str = torch.floataa elif mp_dtype == "bf16": lowercase : Optional[int] = torch.bfloataa lowercase : Optional[Any] = MixedPrecision(param_dtype=snake_case ,reduce_dtype=snake_case ,buffer_dtype=snake_case ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy ,snake_case ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler ,snake_case ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: lowercase : Dict = self.dist_env.copy() lowercase : Optional[int] = str(snake_case ).lower() with mockenv_context(**snake_case ): lowercase : Optional[Any] = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload ,CPUOffload(offload_params=snake_case ) ) @require_fsdp @require_multi_gpu @slow class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() lowercase : Optional[int] = 0.82 lowercase : List[str] = [ """fsdp_shard_grad_op_transformer_based_wrap""", """fsdp_full_shard_transformer_based_wrap""", ] lowercase : int = { """multi_gpu_fp16""": 3200, """fsdp_shard_grad_op_transformer_based_wrap_fp16""": 2000, """fsdp_full_shard_transformer_based_wrap_fp16""": 1900, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } lowercase : Dict = 160 lowercase : Optional[Any] = 160 lowercase : int = inspect.getfile(accelerate.test_utils ) lowercase : Any = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """external_deps"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = os.path.join(self.test_scripts_folder ,"""test_performance.py""" ) lowercase : int = ["""accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", """--use_fsdp"""] for config in self.performance_configs: lowercase : Optional[int] = cmd.copy() for i, strategy in enumerate(snake_case ): if strategy.lower() in config: cmd_config.append(f"--fsdp_sharding_strategy={i+1}" ) break if "fp32" in config: cmd_config.append("""--mixed_precision=no""" ) else: cmd_config.append("""--mixed_precision=fp16""" ) if "cpu_offload" in config: cmd_config.append("""--fsdp_offload_params=True""" ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(f"--fsdp_auto_wrap_policy={policy}" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append("""--fsdp_transformer_layer_cls_to_wrap=BertLayer""" ) elif policy == "SIZE_BASED_WRAP": cmd_config.append("""--fsdp_min_num_params=2000""" ) cmd_config.extend( [ self.test_file_path, f"--output_dir={self.tmpdir}", f"--performance_lower_bound={self.performance_lower_bound}", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case ,env=os.environ.copy() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = os.path.join(self.test_scripts_folder ,"""test_checkpointing.py""" ) lowercase : int = [ """accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", """--use_fsdp""", """--mixed_precision=fp16""", """--fsdp_transformer_layer_cls_to_wrap=BertLayer""", ] for i, strategy in enumerate(snake_case ): lowercase : Any = cmd.copy() cmd_config.append(f"--fsdp_sharding_strategy={i+1}" ) if strategy != "FULL_SHARD": continue lowercase : Union[str, Any] = len(snake_case ) for state_dict_type in FSDP_STATE_DICT_TYPE: lowercase : Optional[int] = cmd_config[:state_dict_config_index] cmd_config.append(f"--fsdp_state_dict_type={state_dict_type}" ) cmd_config.extend( [ self.test_file_path, f"--output_dir={self.tmpdir}", """--partial_train_epoch=1""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case ,env=os.environ.copy() ) lowercase : Tuple = cmd_config[:-1] lowercase : Tuple = os.path.join(self.tmpdir ,"""epoch_0""" ) cmd_config.extend( [ f"--resume_from_checkpoint={resume_from_checkpoint}", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case ,env=os.environ.copy() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = os.path.join(self.test_scripts_folder ,"""test_peak_memory_usage.py""" ) lowercase : List[Any] = [ """accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): lowercase : Dict = cmd.copy() if "fp16" in spec: cmd_config.extend(["""--mixed_precision=fp16"""] ) else: cmd_config.extend(["""--mixed_precision=no"""] ) if "multi_gpu" in spec: continue else: cmd_config.extend(["""--use_fsdp"""] ) for i, strategy in enumerate(snake_case ): if strategy.lower() in spec: cmd_config.append(f"--fsdp_sharding_strategy={i+1}" ) break if "cpu_offload" in spec: cmd_config.append("""--fsdp_offload_params=True""" ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(f"--fsdp_auto_wrap_policy={policy}" ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append("""--fsdp_transformer_layer_cls_to_wrap=BertLayer""" ) elif policy == "SIZE_BASED_WRAP": cmd_config.append("""--fsdp_min_num_params=2000""" ) cmd_config.extend( [ self.test_file_path, f"--output_dir={self.tmpdir}", f"--peak_memory_upper_bound={peak_mem_upper_bound}", f"--n_train={self.n_train}", f"--n_val={self.n_val}", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(snake_case ,env=os.environ.copy() )
20
from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef import datasets lowercase : str = """\ @inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019} } """ lowercase : Dict = """\ GLUE, the General Language Understanding Evaluation benchmark (https://gluebenchmark.com/) is a collection of resources for training, evaluating, and analyzing natural language understanding systems. """ lowercase : int = """ Compute GLUE evaluation metric associated to each GLUE dataset. Args: predictions: list of predictions to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. Returns: depending on the GLUE subset, one or several of: \"accuracy\": Accuracy \"f1\": F1 score \"pearson\": Pearson Correlation \"spearmanr\": Spearman Correlation \"matthews_correlation\": Matthew Correlation Examples: >>> glue_metric = datasets.load_metric('glue', 'sst2') # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"] >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> glue_metric = datasets.load_metric('glue', 'mrpc') # 'mrpc' or 'qqp' >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> glue_metric = datasets.load_metric('glue', 'stsb') >>> references = [0., 1., 2., 3., 4., 5.] >>> predictions = [0., 1., 2., 3., 4., 5.] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)}) {'pearson': 1.0, 'spearmanr': 1.0} >>> glue_metric = datasets.load_metric('glue', 'cola') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: return float((preds == labels).mean() ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = simple_accuracy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = float(fa_score(y_true=SCREAMING_SNAKE_CASE__ , y_pred=SCREAMING_SNAKE_CASE__ ) ) return { "accuracy": acc, "f1": fa, } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = float(pearsonr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) lowercase : Dict = float(spearmanr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) return { "pearson": pearson_corr, "spearmanr": spearman_corr, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config_name not in [ "sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans", ]: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), } ) ,codebase_urls=[] ,reference_urls=[] ,format="""numpy""" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if self.config_name == "cola": return {"matthews_correlation": matthews_corrcoef(snake_case ,snake_case )} elif self.config_name == "stsb": return pearson_and_spearman(snake_case ,snake_case ) elif self.config_name in ["mrpc", "qqp"]: return acc_and_fa(snake_case ,snake_case ) elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]: return {"accuracy": simple_accuracy(snake_case ,snake_case )} else: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" )
20
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase : Union[str, Any] = {"""configuration_yolos""": ["""YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP""", """YolosConfig""", """YolosOnnxConfig"""]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[Any] = ["""YolosFeatureExtractor"""] lowercase : Optional[int] = ["""YolosImageProcessor"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : int = [ """YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST""", """YolosForObjectDetection""", """YolosModel""", """YolosPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase : Optional[int] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
1
import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin lowercase : Union[str, Any] = get_tests_dir("""fixtures/test_sentencepiece.model""") if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right lowercase : Optional[Any] = 250004 lowercase : Optional[int] = 250020 @require_sentencepiece @require_tokenizers class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Optional[int]= MBartTokenizer _a : str= MBartTokenizerFast _a : Dict= True _a : int= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() # We have a SentencePiece fixture for testing lowercase : str = MBartTokenizer(snake_case ,keep_accents=snake_case ) tokenizer.save_pretrained(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = MBartTokenizer(snake_case ,keep_accents=snake_case ) lowercase : Any = tokenizer.tokenize("""This is a test""" ) self.assertListEqual(snake_case ,["""▁This""", """▁is""", """▁a""", """▁t""", """est"""] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(snake_case ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,) lowercase : str = tokenizer.tokenize("""I was born in 92000, and this is falsé.""" ) self.assertListEqual( snake_case ,[ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """9""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """é""", """.""", ] ,) lowercase : Optional[Any] = tokenizer.convert_tokens_to_ids(snake_case ) self.assertListEqual( snake_case ,[ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4] # ^ unk: 2 + 1 = 3 unk: 2 + 1 = 3 ^ ] ,) lowercase : str = tokenizer.convert_ids_to_tokens(snake_case ) self.assertListEqual( snake_case ,[ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """<unk>""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """<unk>""", """.""", ] ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if not self.test_slow_tokenizer: # as we don't have a slow version, we can't compare the outputs between slow and fast versions return lowercase : Union[str, Any] = (self.rust_tokenizer_class, """hf-internal-testing/tiny-random-mbart""", {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowercase : Tuple = self.rust_tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : Optional[Any] = self.tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : Optional[int] = tempfile.mkdtemp() lowercase : Dict = tokenizer_r.save_pretrained(snake_case ) lowercase : Tuple = tokenizer_p.save_pretrained(snake_case ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) lowercase : Optional[Any] = tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f ) self.assertSequenceEqual(snake_case ,snake_case ) # Checks everything loads correctly in the same way lowercase : Any = tokenizer_r.from_pretrained(snake_case ) lowercase : str = tokenizer_p.from_pretrained(snake_case ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(snake_case ,snake_case ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(snake_case ) # Save tokenizer rust, legacy_format=True lowercase : int = tempfile.mkdtemp() lowercase : Dict = tokenizer_r.save_pretrained(snake_case ,legacy_format=snake_case ) lowercase : str = tokenizer_p.save_pretrained(snake_case ) # Checks it save with the same files self.assertSequenceEqual(snake_case ,snake_case ) # Checks everything loads correctly in the same way lowercase : Optional[int] = tokenizer_r.from_pretrained(snake_case ) lowercase : Tuple = tokenizer_p.from_pretrained(snake_case ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(snake_case ,snake_case ) ) shutil.rmtree(snake_case ) # Save tokenizer rust, legacy_format=False lowercase : List[Any] = tempfile.mkdtemp() lowercase : List[Any] = tokenizer_r.save_pretrained(snake_case ,legacy_format=snake_case ) lowercase : Union[str, Any] = tokenizer_p.save_pretrained(snake_case ) # Checks it saved the tokenizer.json file self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way lowercase : Tuple = tokenizer_r.from_pretrained(snake_case ) lowercase : Optional[int] = tokenizer_p.from_pretrained(snake_case ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(snake_case ,snake_case ) ) shutil.rmtree(snake_case ) @require_torch @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): _a : Any= "facebook/mbart-large-en-ro" _a : Union[str, Any]= [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] _a : str= [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] _a : Optional[Any]= [8274, 12_7873, 2_5916, 7, 8622, 2071, 438, 6_7485, 53, 18_7895, 23, 5_1712, 2, EN_CODE] @classmethod def _SCREAMING_SNAKE_CASE ( cls ): '''simple docstring''' lowercase : MBartTokenizer = MBartTokenizer.from_pretrained( cls.checkpoint_name ,src_lang="""en_XX""" ,tgt_lang="""ro_RO""" ) lowercase : Optional[int] = 1 return cls def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""] ,250001 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""] ,250004 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""] ,250020 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.assertIn(snake_case ,self.tokenizer.all_special_ids ) lowercase : int = [RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2] lowercase : Dict = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : str = self.tokenizer.decode(generated_ids[1:] ,skip_special_tokens=snake_case ) self.assertEqual(snake_case ,snake_case ) self.assertNotIn(self.tokenizer.eos_token ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ["""this is gunna be a long sentence """ * 20] assert isinstance(src_text[0] ,snake_case ) lowercase : Tuple = 10 lowercase : Dict = self.tokenizer(snake_case ,max_length=snake_case ,truncation=snake_case ).input_ids[0] self.assertEqual(ids[-2] ,2 ) self.assertEqual(ids[-1] ,snake_case ) self.assertEqual(len(snake_case ) ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""] ) ,[250026, 250001] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = tempfile.mkdtemp() lowercase : Dict = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(snake_case ) lowercase : List[str] = MBartTokenizer.from_pretrained(snake_case ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids ,snake_case ) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.tokenizer(self.src_text ,text_target=self.tgt_text ,padding=snake_case ,return_tensors="""pt""" ) lowercase : List[str] = shift_tokens_right(batch["""labels"""] ,self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE] assert batch.decoder_input_ids[1][0].tolist() == RO_CODE assert batch.decoder_input_ids[1][-1] == 2 assert batch.labels[1][-2:].tolist() == [2, RO_CODE] @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.tokenizer( self.src_text ,text_target=self.tgt_text ,padding=snake_case ,truncation=snake_case ,max_length=len(self.expected_src_tokens ) ,return_tensors="""pt""" ,) lowercase : Any = shift_tokens_right(batch["""labels"""] ,self.tokenizer.pad_token_id ) self.assertIsInstance(snake_case ,snake_case ) self.assertEqual((2, 14) ,batch.input_ids.shape ) self.assertEqual((2, 14) ,batch.attention_mask.shape ) lowercase : int = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens ,snake_case ) self.assertEqual(2 ,batch.decoder_input_ids[0, -1] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens ,[] ) self.assertEqual(self.tokenizer.suffix_tokens ,[self.tokenizer.eos_token_id, EN_CODE] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.tokenizer(self.src_text ,padding=snake_case ,truncation=snake_case ,max_length=3 ,return_tensors="""pt""" ) lowercase : Optional[int] = self.tokenizer( text_target=self.tgt_text ,padding=snake_case ,truncation=snake_case ,max_length=10 ,return_tensors="""pt""" ) lowercase : Dict = targets["""input_ids"""] lowercase : int = shift_tokens_right(snake_case ,self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] ,3 ) self.assertEqual(batch.decoder_input_ids.shape[1] ,10 ) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = self.tokenizer._build_translation_inputs( """A test""" ,return_tensors="""pt""" ,src_lang="""en_XX""" ,tgt_lang="""ar_AR""" ) self.assertEqual( nested_simplify(snake_case ) ,{ # A, test, EOS, en_XX """input_ids""": [[62, 3034, 2, 250004]], """attention_mask""": [[1, 1, 1, 1]], # ar_AR """forced_bos_token_id""": 250001, } ,)
20
from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class __snake_case : _a : int _a : TreeNode | None= None _a : TreeNode | None= None lowercase : Dict = namedtuple("""CoinsDistribResult""", """moves excess""") def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if root is None: return 0 # Validation def count_nodes(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(SCREAMING_SNAKE_CASE__ ) != count_coins(SCREAMING_SNAKE_CASE__ ): raise ValueError("""The nodes number should be same as the number of coins""" ) # Main calculation def get_distrib(SCREAMING_SNAKE_CASE__ ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 , 1 ) lowercase , lowercase : int = get_distrib(node.left ) lowercase , lowercase : List[Any] = get_distrib(node.right ) lowercase : Optional[Any] = 1 - left_distrib_excess lowercase : Union[str, Any] = 1 - right_distrib_excess lowercase : List[Any] = ( left_distrib_moves + right_distrib_moves + abs(SCREAMING_SNAKE_CASE__ ) + abs(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = node.data - coins_to_left - coins_to_right return CoinsDistribResult(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return get_distrib(SCREAMING_SNAKE_CASE__ )[0] if __name__ == "__main__": import doctest doctest.testmod()
20
1
from __future__ import annotations def _snake_case( SCREAMING_SNAKE_CASE__ ) -> list[int]: # This function is recursive lowercase : Optional[Any] = len(SCREAMING_SNAKE_CASE__ ) # If the array contains only one element, we return it (it's the stop condition of # recursion) if array_length <= 1: return array # Else lowercase : Dict = array[0] lowercase : Union[str, Any] = False lowercase : List[str] = 1 lowercase : list[int] = [] while not is_found and i < array_length: if array[i] < pivot: lowercase : Tuple = True lowercase : Tuple = [element for element in array[i:] if element >= array[i]] lowercase : str = longest_subsequence(SCREAMING_SNAKE_CASE__ ) if len(SCREAMING_SNAKE_CASE__ ) > len(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = temp_array else: i += 1 lowercase : Any = [element for element in array[1:] if element >= pivot] lowercase : Dict = [pivot, *longest_subsequence(SCREAMING_SNAKE_CASE__ )] if len(SCREAMING_SNAKE_CASE__ ) > len(SCREAMING_SNAKE_CASE__ ): return temp_array else: return longest_subseq if __name__ == "__main__": import doctest doctest.testmod()
20
from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline lowercase : Optional[Any] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,**snake_case ): '''simple docstring''' super().__init__(**snake_case ) if self.framework != "pt": raise ValueError(f"The {self.__class__} is only available in PyTorch." ) # No specific FOR_XXX available yet def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : Union[str, Any] = {} if "candidate_labels" in kwargs: lowercase : List[str] = kwargs["""candidate_labels"""] if "hypothesis_template" in kwargs: lowercase : Dict = kwargs["""hypothesis_template"""] return preprocess_params, {}, {} def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case="This is a sound of {}." ): '''simple docstring''' if isinstance(snake_case ,snake_case ): if audio.startswith("""http://""" ) or audio.startswith("""https://""" ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png lowercase : Optional[Any] = requests.get(snake_case ).content else: with open(snake_case ,"""rb""" ) as f: lowercase : Union[str, Any] = f.read() if isinstance(snake_case ,snake_case ): lowercase : int = ffmpeg_read(snake_case ,self.feature_extractor.sampling_rate ) if not isinstance(snake_case ,np.ndarray ): raise ValueError("""We expect a numpy ndarray as input""" ) if len(audio.shape ) != 1: raise ValueError("""We expect a single channel audio input for ZeroShotAudioClassificationPipeline""" ) lowercase : Dict = self.feature_extractor( [audio] ,sampling_rate=self.feature_extractor.sampling_rate ,return_tensors="""pt""" ) lowercase : Tuple = candidate_labels lowercase : Tuple = [hypothesis_template.format(snake_case ) for x in candidate_labels] lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=self.framework ,padding=snake_case ) lowercase : Optional[Any] = [text_inputs] return inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = model_inputs.pop("""candidate_labels""" ) lowercase : Dict = model_inputs.pop("""text_inputs""" ) if isinstance(text_inputs[0] ,snake_case ): lowercase : List[Any] = text_inputs[0] else: # Batching case. lowercase : Dict = text_inputs[0][0] lowercase : Optional[Any] = self.model(**snake_case ,**snake_case ) lowercase : Any = { """candidate_labels""": candidate_labels, """logits""": outputs.logits_per_audio, } return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = model_outputs.pop("""candidate_labels""" ) lowercase : Any = model_outputs["""logits"""][0] if self.framework == "pt": lowercase : Any = logits.softmax(dim=0 ) lowercase : Tuple = probs.tolist() else: raise ValueError("""`tf` framework not supported.""" ) lowercase : Tuple = [ {"""score""": score, """label""": candidate_label} for score, candidate_label in sorted(zip(snake_case ,snake_case ) ,key=lambda snake_case : -x[0] ) ] return result
20
1
import argparse from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline if __name__ == "__main__": lowercase : Any = argparse.ArgumentParser() parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""") parser.add_argument( """--txt2img_unclip""", default="""kakaobrain/karlo-v1-alpha""", type=str, required=False, help="""The pretrained txt2img unclip.""", ) lowercase : List[Any] = parser.parse_args() lowercase : List[Any] = UnCLIPPipeline.from_pretrained(args.txtaimg_unclip) lowercase : Any = CLIPImageProcessor() lowercase : Any = CLIPVisionModelWithProjection.from_pretrained("""openai/clip-vit-large-patch14""") lowercase : Tuple = UnCLIPImageVariationPipeline( decoder=txtaimg.decoder, text_encoder=txtaimg.text_encoder, tokenizer=txtaimg.tokenizer, text_proj=txtaimg.text_proj, feature_extractor=feature_extractor, image_encoder=image_encoder, super_res_first=txtaimg.super_res_first, super_res_last=txtaimg.super_res_last, decoder_scheduler=txtaimg.decoder_scheduler, super_res_scheduler=txtaimg.super_res_scheduler, ) imgaimg.save_pretrained(args.dump_path)
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def _snake_case( *SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=2 ) -> Optional[Any]: from .. import __version__ lowercase : int = take_from lowercase : Tuple = () if not isinstance(args[0] , SCREAMING_SNAKE_CASE__ ): lowercase : Dict = (args,) for attribute, version_name, message in args: if version.parse(version.parse(SCREAMING_SNAKE_CASE__ ).base_version ) >= version.parse(SCREAMING_SNAKE_CASE__ ): raise ValueError( f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'" f" version {__version__} is >= {version_name}" ) lowercase : int = None if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(SCREAMING_SNAKE_CASE__ ),) lowercase : Union[str, Any] = f"The `{attribute}` argument is deprecated and will be removed in version {version_name}." elif hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): values += (getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ),) lowercase : int = f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}." elif deprecated_kwargs is None: lowercase : Dict = f"`{attribute}` is deprecated and will be removed in version {version_name}." if warning is not None: lowercase : Dict = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , SCREAMING_SNAKE_CASE__ , stacklevel=SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and len(SCREAMING_SNAKE_CASE__ ) > 0: lowercase : str = inspect.getouterframes(inspect.currentframe() )[1] lowercase : List[str] = call_frame.filename lowercase : Tuple = call_frame.lineno lowercase : List[str] = call_frame.function lowercase , lowercase : Optional[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: return elif len(SCREAMING_SNAKE_CASE__ ) == 1: return values[0] return values
20
1
import argparse import json import gdown import numpy as np import torch from huggingface_hub import hf_hub_download from transformers import ( VideoMAEConfig, VideoMAEForPreTraining, VideoMAEForVideoClassification, VideoMAEImageProcessor, ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : int = VideoMAEConfig() set_architecture_configs(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if "finetuned" not in model_name: lowercase : Dict = False if "finetuned" in model_name: lowercase : Any = """huggingface/label-files""" if "kinetics" in model_name: lowercase : Optional[int] = 400 lowercase : Any = """kinetics400-id2label.json""" elif "ssv2" in model_name: lowercase : Dict = 174 lowercase : Tuple = """something-something-v2-id2label.json""" else: raise ValueError("""Model name should either contain 'kinetics' or 'ssv2' in case it's fine-tuned.""" ) lowercase : Any = json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) , """r""" ) ) lowercase : Any = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Any = idalabel lowercase : List[Any] = {v: k for k, v in idalabel.items()} return config def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: if "small" in model_name: lowercase : Optional[Any] = 384 lowercase : Dict = 1_536 lowercase : Optional[Any] = 12 lowercase : Union[str, Any] = 16 lowercase : List[str] = 12 lowercase : int = 3 lowercase : List[Any] = 192 lowercase : Optional[Any] = 768 elif "large" in model_name: lowercase : int = 1_024 lowercase : Optional[Any] = 4_096 lowercase : Optional[Any] = 24 lowercase : List[str] = 16 lowercase : Optional[int] = 12 lowercase : Union[str, Any] = 8 lowercase : str = 512 lowercase : Union[str, Any] = 2_048 elif "huge" in model_name: lowercase : Dict = 1_280 lowercase : Union[str, Any] = 5_120 lowercase : Optional[Any] = 32 lowercase : Optional[Any] = 16 lowercase : int = 12 lowercase : Dict = 8 lowercase : Dict = 640 lowercase : Dict = 2_560 elif "base" not in model_name: raise ValueError("""Model name should include either \"small\", \"base\", \"large\", or \"huge\"""" ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: if "encoder." in name: lowercase : str = name.replace("""encoder.""" , """""" ) if "cls_token" in name: lowercase : Any = name.replace("""cls_token""" , """videomae.embeddings.cls_token""" ) if "decoder_pos_embed" in name: lowercase : Optional[int] = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : Dict = name.replace("""pos_embed""" , """videomae.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """videomae.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : List[str] = name.replace("""patch_embed.norm""" , """videomae.embeddings.norm""" ) if "decoder.blocks" in name: lowercase : List[str] = name.replace("""decoder.blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[str] = name.replace("""blocks""" , """videomae.encoder.layer""" ) if "attn.proj" in name: lowercase : Any = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name and "bias" not in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "attn" in name: lowercase : str = name.replace("""attn""" , """attention.attention""" ) if "norm1" in name: lowercase : Tuple = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Any = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : str = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : str = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : Dict = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Union[str, Any] = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : str = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name and "fc" not in name: lowercase : Optional[int] = name.replace("""norm.weight""" , """videomae.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name and "fc" not in name: lowercase : Any = name.replace("""norm.bias""" , """videomae.layernorm.bias""" ) if "head" in name and "decoder" not in name: lowercase : List[str] = name.replace("""head""" , """classifier""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: for key in orig_state_dict.copy().keys(): lowercase : Union[str, Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if key.startswith("""encoder.""" ): lowercase : Union[str, Any] = key.replace("""encoder.""" , """""" ) if "qkv" in key: lowercase : Tuple = key.split(""".""" ) if key.startswith("""decoder.blocks""" ): lowercase : Tuple = config.decoder_hidden_size lowercase : str = int(key_split[2] ) lowercase : Optional[Any] = """decoder.decoder_layers.""" if "weight" in key: lowercase : Optional[Any] = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] else: lowercase : int = config.hidden_size lowercase : Optional[int] = int(key_split[1] ) lowercase : Optional[Any] = """videomae.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : Optional[Any] = val[dim : dim * 2, :] lowercase : Any = val[-dim:, :] else: lowercase : List[str] = val return orig_state_dict def _snake_case( ) -> Any: lowercase : str = hf_hub_download( repo_id="""hf-internal-testing/spaghetti-video""" , filename="""eating_spaghetti.npy""" , repo_type="""dataset""" ) lowercase : Dict = np.load(SCREAMING_SNAKE_CASE__ ) return list(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: lowercase : Optional[Any] = get_videomae_config(SCREAMING_SNAKE_CASE__ ) if "finetuned" in model_name: lowercase : Tuple = VideoMAEForVideoClassification(SCREAMING_SNAKE_CASE__ ) else: lowercase : Union[str, Any] = VideoMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) # download original checkpoint, hosted on Google Drive lowercase : Optional[Any] = """pytorch_model.bin""" gdown.cached_download(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , quiet=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = torch.load(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" ) if "model" in files: lowercase : Tuple = files["""model"""] else: lowercase : Tuple = files["""module"""] lowercase : Optional[Any] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() # verify model on basic input lowercase : Union[str, Any] = VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] , image_std=[0.5, 0.5, 0.5] ) lowercase : Union[str, Any] = prepare_video() lowercase : Any = image_processor(SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) if "finetuned" not in model_name: lowercase : List[Any] = hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos""" , filename="""bool_masked_pos.pt""" ) lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits lowercase : int = [ """videomae-small-finetuned-kinetics""", """videomae-small-finetuned-ssv2""", # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600) """videomae-base-short""", """videomae-base-short-finetuned-kinetics""", """videomae-base""", """videomae-base-finetuned-kinetics""", """videomae-large""", """videomae-large-finetuned-kinetics""", """videomae-huge-finetuned-kinetics""", # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400) """videomae-base-short-ssv2""", """videomae-base-short-finetuned-ssv2""", """videomae-base-ssv2""", """videomae-base-finetuned-ssv2""", ] # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5] if model_name == "videomae-small-finetuned-kinetics": lowercase : Tuple = torch.Size([1, 400] ) lowercase : Any = torch.tensor([-0.9291, -0.4061, -0.9307] ) elif model_name == "videomae-small-finetuned-ssv2": lowercase : int = torch.Size([1, 174] ) lowercase : List[Any] = torch.tensor([0.2671, -0.4689, -0.8235] ) elif model_name == "videomae-base": lowercase : List[str] = torch.Size([1, 1_408, 1_536] ) lowercase : Tuple = torch.tensor([[0.7739, 0.7968, 0.7089], [0.6701, 0.7487, 0.6209], [0.4287, 0.5158, 0.4773]] ) elif model_name == "videomae-base-short": lowercase : Tuple = torch.Size([1, 1_408, 1_536] ) lowercase : str = torch.tensor([[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]] ) # we verified the loss both for normalized and unnormalized targets for this one lowercase : List[str] = torch.tensor([0.5142] ) if config.norm_pix_loss else torch.tensor([0.6469] ) elif model_name == "videomae-large": lowercase : Tuple = torch.Size([1, 1_408, 1_536] ) lowercase : int = torch.tensor([[0.7149, 0.7997, 0.6966], [0.6768, 0.7869, 0.6948], [0.5139, 0.6221, 0.5605]] ) elif model_name == "videomae-large-finetuned-kinetics": lowercase : Optional[int] = torch.Size([1, 400] ) lowercase : Union[str, Any] = torch.tensor([0.0771, 0.0011, -0.3625] ) elif model_name == "videomae-huge-finetuned-kinetics": lowercase : str = torch.Size([1, 400] ) lowercase : str = torch.tensor([0.2433, 0.1632, -0.4894] ) elif model_name == "videomae-base-short-finetuned-kinetics": lowercase : Dict = torch.Size([1, 400] ) lowercase : Dict = torch.tensor([0.6588, 0.0990, -0.2493] ) elif model_name == "videomae-base-finetuned-kinetics": lowercase : Tuple = torch.Size([1, 400] ) lowercase : str = torch.tensor([0.3669, -0.0688, -0.2421] ) elif model_name == "videomae-base-short-ssv2": lowercase : Union[str, Any] = torch.Size([1, 1_408, 1_536] ) lowercase : Dict = torch.tensor([[0.4712, 0.5296, 0.5786], [0.2278, 0.2729, 0.4026], [0.0352, 0.0730, 0.2506]] ) elif model_name == "videomae-base-short-finetuned-ssv2": lowercase : Optional[Any] = torch.Size([1, 174] ) lowercase : Optional[Any] = torch.tensor([-0.0537, -0.1539, -0.3266] ) elif model_name == "videomae-base-ssv2": lowercase : Union[str, Any] = torch.Size([1, 1_408, 1_536] ) lowercase : int = torch.tensor([[0.8131, 0.8727, 0.8546], [0.7366, 0.9377, 0.8870], [0.5935, 0.8874, 0.8564]] ) elif model_name == "videomae-base-finetuned-ssv2": lowercase : Optional[Any] = torch.Size([1, 174] ) lowercase : Union[str, Any] = torch.tensor([0.1961, -0.8337, -0.6389] ) else: raise ValueError(f"Model name not supported. Should be one of {model_names}" ) # verify logits assert logits.shape == expected_shape if "finetuned" in model_name: assert torch.allclose(logits[0, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) else: print("""Logits:""" , logits[0, :3, :3] ) assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print("""Logits ok!""" ) # verify loss, if applicable if model_name == "videomae-base-short": lowercase : Union[str, Any] = outputs.loss assert torch.allclose(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print("""Loss ok!""" ) if pytorch_dump_folder_path is not None: print(f"Saving model and image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) if push_to_hub: print("""Pushing to the hub...""" ) model.push_to_hub(SCREAMING_SNAKE_CASE__ , organization="""nielsr""" ) if __name__ == "__main__": lowercase : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4""", type=str, help=( """URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct""" """ download link.""" ), ) parser.add_argument( """--pytorch_dump_folder_path""", default="""/Users/nielsrogge/Documents/VideoMAE/Test""", type=str, help="""Path to the output PyTorch model directory.""", ) parser.add_argument("""--model_name""", default="""videomae-base""", type=str, help="""Name of the model.""") parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub.""" ) lowercase : Optional[int] = parser.parse_args() convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
20
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: if index == r: for j in range(SCREAMING_SNAKE_CASE__ ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location lowercase : Tuple = arr[i] combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 , SCREAMING_SNAKE_CASE__ , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # A temporary array to store all combination one by one lowercase : Optional[int] = [0] * r # Print all combination using temporary array 'data[]' combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , 0 , SCREAMING_SNAKE_CASE__ , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase : int = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
1
import os import warnings from typing import List, Optional from ...tokenization_utils_base import BatchEncoding from ...utils import logging from .configuration_rag import RagConfig lowercase : List[Any] = logging.get_logger(__name__) class __snake_case : def __init__( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[Any] = question_encoder lowercase : Union[str, Any] = generator lowercase : str = self.question_encoder def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if os.path.isfile(snake_case ): raise ValueError(f"Provided path ({save_directory}) should be a directory, not a file" ) os.makedirs(snake_case ,exist_ok=snake_case ) lowercase : Dict = os.path.join(snake_case ,"""question_encoder_tokenizer""" ) lowercase : List[Any] = os.path.join(snake_case ,"""generator_tokenizer""" ) self.question_encoder.save_pretrained(snake_case ) self.generator.save_pretrained(snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,**snake_case ): '''simple docstring''' from ..auto.tokenization_auto import AutoTokenizer lowercase : List[str] = kwargs.pop("""config""" ,snake_case ) if config is None: lowercase : List[Any] = RagConfig.from_pretrained(snake_case ) lowercase : str = AutoTokenizer.from_pretrained( snake_case ,config=config.question_encoder ,subfolder="""question_encoder_tokenizer""" ) lowercase : Any = AutoTokenizer.from_pretrained( snake_case ,config=config.generator ,subfolder="""generator_tokenizer""" ) return cls(question_encoder=snake_case ,generator=snake_case ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' return self.current_tokenizer(*snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,*snake_case ,**snake_case ): '''simple docstring''' return self.generator.batch_decode(*snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,*snake_case ,**snake_case ): '''simple docstring''' return self.generator.decode(*snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.question_encoder def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = self.generator def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = "longest" ,snake_case = None ,snake_case = True ,**snake_case ,): '''simple docstring''' warnings.warn( """`prepare_seq2seq_batch` is deprecated and will be removed in version 5 of 🤗 Transformers. Use the """ """regular `__call__` method to prepare your inputs and the tokenizer under the `with_target_tokenizer` """ """context manager to prepare your targets. See the documentation of your specific tokenizer for more """ """details""" ,snake_case ,) if max_length is None: lowercase : Union[str, Any] = self.current_tokenizer.model_max_length lowercase : Tuple = self( snake_case ,add_special_tokens=snake_case ,return_tensors=snake_case ,max_length=snake_case ,padding=snake_case ,truncation=snake_case ,**snake_case ,) if tgt_texts is None: return model_inputs # Process tgt_texts if max_target_length is None: lowercase : Dict = self.current_tokenizer.model_max_length lowercase : Tuple = self( text_target=snake_case ,add_special_tokens=snake_case ,return_tensors=snake_case ,padding=snake_case ,max_length=snake_case ,truncation=snake_case ,**snake_case ,) lowercase : List[str] = labels["""input_ids"""] return model_inputs
20
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : Optional[Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): lowercase : Any = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ , keep_in_memory=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : int = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} lowercase : str = features.copy() if features else default_expected_features lowercase : Optional[Any] = ( Features({feature: Value(SCREAMING_SNAKE_CASE__ ) for feature, dtype in features.items()} ) if features is not None else None ) lowercase : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__ ) ) as con: lowercase : Optional[int] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = tmp_path / """cache""" lowercase : int = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() lowercase : List[str] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Dict = tmp_path / """cache""" lowercase : List[str] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() lowercase : Optional[int] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : str = tmp_path / """cache""" lowercase : Optional[int] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : Optional[Any] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() with pytest.raises(SCREAMING_SNAKE_CASE__ ): SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
1
from __future__ import annotations def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: # preprocessing the first row for i in range(1 , len(matrix[0] ) ): matrix[0][i] += matrix[0][i - 1] # preprocessing the first column for i in range(1 , len(SCREAMING_SNAKE_CASE__ ) ): matrix[i][0] += matrix[i - 1][0] # updating the path cost for current position for i in range(1 , len(SCREAMING_SNAKE_CASE__ ) ): for j in range(1 , len(matrix[0] ) ): matrix[i][j] += min(matrix[i - 1][j] , matrix[i][j - 1] ) return matrix[-1][-1] if __name__ == "__main__": import doctest doctest.testmod()
20
import os import numpy import onnx def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : int = a.name lowercase : Any = b.name lowercase : Optional[Any] = """""" lowercase : Dict = """""" lowercase : int = a == b lowercase : int = name_a lowercase : List[str] = name_b return res def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) _graph_replace_input_with(node_proto.attribute[1].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for n in graph_proto.node: _node_replace_input_with(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Any = list(model.graph.initializer ) lowercase : Dict = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i lowercase : Union[str, Any] = inits[i].name lowercase : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Union[str, Any] = os.path.dirname(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = os.path.basename(SCREAMING_SNAKE_CASE__ ) lowercase : str = onnx.load(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) lowercase : List[str] = list(model.graph.initializer ) lowercase : Tuple = set() lowercase : int = {} lowercase : Optional[Any] = [] lowercase : Dict = 0 for i in range(len(SCREAMING_SNAKE_CASE__ ) ): if i in dup_set: continue for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(SCREAMING_SNAKE_CASE__ ) dup_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : int = inits[j].data_type lowercase : Optional[int] = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 11: mem_size *= 8 else: print("""unexpected data type: """ , SCREAMING_SNAKE_CASE__ ) total_reduced_size += mem_size lowercase : Tuple = inits[i].name lowercase : int = inits[j].name if name_i in dup_map: dup_map[name_i].append(SCREAMING_SNAKE_CASE__ ) else: lowercase : List[str] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_024 / 1_024 / 1_024 , """GB""" ) lowercase : str = sorted(SCREAMING_SNAKE_CASE__ ) _remove_dup_initializers_from_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = """optimized_""" + model_file_name lowercase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) onnx.save(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return new_model
20
1
import argparse import os import re import packaging.version lowercase : Optional[Any] = """examples/""" lowercase : int = { """examples""": (re.compile(R"""^check_min_version\(\"[^\"]+\"\)\s*$""", re.MULTILINE), """check_min_version(\"VERSION\")\n"""), """init""": (re.compile(R"""^__version__\s+=\s+\"([^\"]+)\"\s*$""", re.MULTILINE), """__version__ = \"VERSION\"\n"""), """setup""": (re.compile(R"""^(\s*)version\s*=\s*\"[^\"]+\",""", re.MULTILINE), R"""\1version=\"VERSION\","""), """doc""": (re.compile(R"""^(\s*)release\s*=\s*\"[^\"]+\"$""", re.MULTILINE), """release = \"VERSION\"\n"""), } lowercase : Any = { """init""": """src/transformers/__init__.py""", """setup""": """setup.py""", } lowercase : Any = """README.md""" def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: with open(SCREAMING_SNAKE_CASE__ , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: lowercase : str = f.read() lowercase , lowercase : Any = REPLACE_PATTERNS[pattern] lowercase : List[Any] = replace.replace("""VERSION""" , SCREAMING_SNAKE_CASE__ ) lowercase : int = re_pattern.sub(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) with open(SCREAMING_SNAKE_CASE__ , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: for folder, directories, fnames in os.walk(SCREAMING_SNAKE_CASE__ ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ , pattern="""examples""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=False ) -> str: for pattern, fname in REPLACE_FILES.items(): update_version_in_file(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if not patch: update_version_in_examples(SCREAMING_SNAKE_CASE__ ) def _snake_case( ) -> Tuple: lowercase : str = """🤗 Transformers currently provides the following architectures""" lowercase : Union[str, Any] = """1. Want to contribute a new model?""" with open(SCREAMING_SNAKE_CASE__ , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: lowercase : Union[str, Any] = f.readlines() # Find the start of the list. lowercase : Optional[int] = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 lowercase : Optional[int] = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): lowercase : List[Any] = lines[index].replace( """https://huggingface.co/docs/transformers/main/model_doc""" , """https://huggingface.co/docs/transformers/model_doc""" , ) index += 1 with open(SCREAMING_SNAKE_CASE__ , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(SCREAMING_SNAKE_CASE__ ) def _snake_case( ) -> Union[str, Any]: with open(REPLACE_FILES["""init"""] , """r""" ) as f: lowercase : Optional[Any] = f.read() lowercase : Dict = REPLACE_PATTERNS["""init"""][0].search(SCREAMING_SNAKE_CASE__ ).groups()[0] return packaging.version.parse(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__=False ) -> List[str]: lowercase : Tuple = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: lowercase : Any = default_version.base_version elif patch: lowercase : Union[str, Any] = f"{default_version.major}.{default_version.minor}.{default_version.micro + 1}" else: lowercase : Optional[int] = f"{default_version.major}.{default_version.minor + 1}.0" # Now let's ask nicely if that's the right one. lowercase : Optional[int] = input(f"Which version are you releasing? [{default_version}]" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: lowercase : Union[str, Any] = default_version print(f"Updating version to {version}." ) global_version_update(SCREAMING_SNAKE_CASE__ , patch=SCREAMING_SNAKE_CASE__ ) if not patch: print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() def _snake_case( ) -> Any: lowercase : Dict = get_version() lowercase : List[str] = f"{current_version.major}.{current_version.minor + 1}.0.dev0" lowercase : Tuple = current_version.base_version # Check with the user we got that right. lowercase : Optional[Any] = input(f"Which version are we developing now? [{dev_version}]" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: lowercase : Union[str, Any] = dev_version print(f"Updating version to {version}." ) global_version_update(SCREAMING_SNAKE_CASE__ ) print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() if __name__ == "__main__": lowercase : str = argparse.ArgumentParser() parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""") parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""") lowercase : Union[str, Any] = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print("""Nothing to do after a patch :-)""") else: post_release_work()
20
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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = [] embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight", f"stage{idx}.patch_embed.proj.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias", f"stage{idx}.patch_embed.proj.bias", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight", f"stage{idx}.patch_embed.norm.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias", f"stage{idx}.patch_embed.norm.bias", ) ) return embed def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Optional[Any] = [] 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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Optional[Any] = [] token.append((f"cvt.encoder.stages.{idx}.cls_token", """stage2.cls_token""") ) return token def _snake_case( ) -> Dict: lowercase : Optional[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 _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = """imagenet-1k-id2label.json""" lowercase : List[str] = 1_000 lowercase : int = """huggingface/label-files""" lowercase : Union[str, Any] = num_labels lowercase : Optional[Any] = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) ) , """r""" ) ) lowercase : List[Any] = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Dict = idalabel lowercase : List[str] = {v: k for k, v in idalabel.items()} lowercase : List[str] = CvtConfig(num_labels=SCREAMING_SNAKE_CASE__ , idalabel=SCREAMING_SNAKE_CASE__ , labelaid=SCREAMING_SNAKE_CASE__ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": lowercase : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": lowercase : Dict = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: lowercase : int = [2, 2, 20] lowercase : Optional[int] = [3, 12, 16] lowercase : str = [192, 768, 1_024] lowercase : Union[str, Any] = CvtForImageClassification(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) lowercase : Optional[Any] = image_size lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ , map_location=torch.device("""cpu""" ) ) lowercase : Optional[Any] = OrderedDict() lowercase : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: lowercase : Optional[Any] = list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__ ) lowercase : str = list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__ ) for cnt in range(config.depth[idx] ): lowercase : List[str] = list_of_state_dict + attention(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = list_of_state_dict + final() for gg in list_of_state_dict: print(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=384, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : Optional[int] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
1
import numpy as np lowercase : List[Any] = [ ["""a""", """b""", """c""", """d""", """e"""], ["""f""", """g""", """h""", """i""", """k"""], ["""l""", """m""", """n""", """o""", """p"""], ["""q""", """r""", """s""", """t""", """u"""], ["""v""", """w""", """x""", """y""", """z"""], ] class __snake_case : def __init__( self ): '''simple docstring''' lowercase : int = np.array(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Tuple = np.where(letter == self.SQUARE ) lowercase : List[str] = np.concatenate([indexa + 1, indexa + 1] ) return indexes def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = self.SQUARE[indexa - 1, indexa - 1] return letter def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = message.lower() lowercase : str = message.replace(""" """ ,"""""" ) lowercase : Tuple = message.replace("""j""" ,"""i""" ) lowercase : List[str] = np.empty((2, len(snake_case )) ) for letter_index in range(len(snake_case ) ): lowercase : List[str] = self.letter_to_numbers(message[letter_index] ) lowercase : List[str] = numbers[0] lowercase : Union[str, Any] = numbers[1] lowercase : str = first_step.reshape(2 * len(snake_case ) ) lowercase : Dict = """""" for numbers_index in range(len(snake_case ) ): lowercase : Any = int(second_step[numbers_index * 2] ) lowercase : Optional[int] = int(second_step[(numbers_index * 2) + 1] ) lowercase : List[str] = self.numbers_to_letter(snake_case ,snake_case ) lowercase : Tuple = encoded_message + letter return encoded_message def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[Any] = message.lower() message.replace(""" """ ,"""""" ) lowercase : Dict = np.empty(2 * len(snake_case ) ) for letter_index in range(len(snake_case ) ): lowercase : Optional[int] = self.letter_to_numbers(message[letter_index] ) lowercase : List[str] = numbers[0] lowercase : Any = numbers[1] lowercase : Optional[int] = first_step.reshape((2, len(snake_case )) ) lowercase : Tuple = """""" for numbers_index in range(len(snake_case ) ): lowercase : Any = int(second_step[0, numbers_index] ) lowercase : Optional[int] = int(second_step[1, numbers_index] ) lowercase : List[str] = self.numbers_to_letter(snake_case ,snake_case ) lowercase : Any = decoded_message + letter return decoded_message
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "microsoft/speecht5_tts" _a : Tuple= ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) _a : Dict= "text_reader" _a : Optional[Any]= SpeechTaProcessor _a : Tuple= SpeechTaForTextToSpeech _a : Optional[int]= SpeechTaHifiGan _a : Union[str, Any]= ["text"] _a : Optional[int]= ["audio"] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.post_processor is None: lowercase : Any = """microsoft/speecht5_hifigan""" super().setup() def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : int = self.pre_processor(text=snake_case ,return_tensors="""pt""" ,truncation=snake_case ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) lowercase : Tuple = load_dataset("""Matthijs/cmu-arctic-xvectors""" ,split="""validation""" ) lowercase : List[str] = torch.tensor(embeddings_dataset[7305]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.model.generate_speech(**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.post_processor(snake_case ).cpu().detach()
20
1
import sys from .dependency_versions_table import deps from .utils.versions import require_version, require_version_core # define which module versions we always want to check at run time # (usually the ones defined in `install_requires` in setup.py) # # order specific notes: # - tqdm must be checked before tokenizers lowercase : List[Any] = """python tqdm regex requests packaging filelock numpy tokenizers""".split() if sys.version_info < (3, 7): pkgs_to_check_at_runtime.append("""dataclasses""") if sys.version_info < (3, 8): pkgs_to_check_at_runtime.append("""importlib_metadata""") for pkg in pkgs_to_check_at_runtime: if pkg in deps: if pkg == "tokenizers": # must be loaded here, or else tqdm check may fail from .utils import is_tokenizers_available if not is_tokenizers_available(): continue # not required, check version only if installed require_version_core(deps[pkg]) else: raise ValueError(F'''can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py''') def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> List[Any]: require_version(deps[pkg] , SCREAMING_SNAKE_CASE__ )
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : str = { """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""], """convert_funnel_original_tf_checkpoint_to_pytorch""": [], """tokenization_funnel""": ["""FunnelTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Tuple = ["""FunnelTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = [ """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """FunnelBaseModel""", """FunnelForMaskedLM""", """FunnelForMultipleChoice""", """FunnelForPreTraining""", """FunnelForQuestionAnswering""", """FunnelForSequenceClassification""", """FunnelForTokenClassification""", """FunnelModel""", """FunnelPreTrainedModel""", """load_tf_weights_in_funnel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFFunnelBaseModel""", """TFFunnelForMaskedLM""", """TFFunnelForMultipleChoice""", """TFFunnelForPreTraining""", """TFFunnelForQuestionAnswering""", """TFFunnelForSequenceClassification""", """TFFunnelForTokenClassification""", """TFFunnelModel""", """TFFunnelPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations import json import requests from bsa import BeautifulSoup from fake_useragent import UserAgent lowercase : Tuple = {"""UserAgent""": UserAgent().random} def _snake_case( SCREAMING_SNAKE_CASE__ ) -> dict: lowercase : Any = script.contents[0] lowercase : Union[str, Any] = json.loads(data[data.find("""{\"config\"""" ) : -1] ) return info["entry_data"]["ProfilePage"][0]["graphql"]["user"] class __snake_case : def __init__( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = f"https://www.instagram.com/{username}/" lowercase : str = self.get_json() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = requests.get(self.url ,headers=snake_case ).text lowercase : Dict = BeautifulSoup(snake_case ,"""html.parser""" ).find_all("""script""" ) try: return extract_user_profile(scripts[4] ) except (json.decoder.JSONDecodeError, KeyError): return extract_user_profile(scripts[3] ) def __repr__( self ): '''simple docstring''' return f"{self.__class__.__name__}('{self.username}')" def __str__( self ): '''simple docstring''' return f"{self.fullname} ({self.username}) is {self.biography}" @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["username"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["full_name"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["biography"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["business_email"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["external_url"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["edge_followed_by"]["count"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["edge_follow"]["count"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["edge_owner_to_timeline_media"]["count"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["profile_pic_url_hd"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["is_verified"] @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.user_data["is_private"] def _snake_case( SCREAMING_SNAKE_CASE__ = "github" ) -> None: import os if os.environ.get("""CI""" ): return # test failing on GitHub Actions lowercase : Tuple = InstagramUser(SCREAMING_SNAKE_CASE__ ) assert instagram_user.user_data assert isinstance(instagram_user.user_data , SCREAMING_SNAKE_CASE__ ) assert instagram_user.username == username if username != "github": return assert instagram_user.fullname == "GitHub" assert instagram_user.biography == "Built for developers." assert instagram_user.number_of_posts > 150 assert instagram_user.number_of_followers > 120_000 assert instagram_user.number_of_followings > 15 assert instagram_user.email == "[email protected]" assert instagram_user.website == "https://github.com/readme" assert instagram_user.profile_picture_url.startswith("""https://instagram.""" ) assert instagram_user.is_verified is True assert instagram_user.is_private is False if __name__ == "__main__": import doctest doctest.testmod() lowercase : List[str] = InstagramUser("""github""") print(instagram_user) print(F'''{instagram_user.number_of_posts = }''') print(F'''{instagram_user.number_of_followers = }''') print(F'''{instagram_user.number_of_followings = }''') print(F'''{instagram_user.email = }''') print(F'''{instagram_user.website = }''') print(F'''{instagram_user.profile_picture_url = }''') print(F'''{instagram_user.is_verified = }''') print(F'''{instagram_user.is_private = }''')
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Any: lowercase : Dict = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } lowercase , lowercase : Optional[Any] = input_paths_and_base_extractors[compression_format] if input_path is None: lowercase : Dict = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) assert base_extractor.is_extractable(SCREAMING_SNAKE_CASE__ ) lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : str = file_path.read_text(encoding="""utf-8""" ) else: lowercase : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) lowercase : Tuple = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Dict: lowercase : str = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } lowercase : Optional[Any] = input_paths[compression_format] if input_path is None: lowercase : int = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = Extractor.infer_extractor_format(SCREAMING_SNAKE_CASE__ ) assert extractor_format is not None lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : Dict = file_path.read_text(encoding="""utf-8""" ) else: lowercase : int = output_path.read_text(encoding="""utf-8""" ) lowercase : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: import tarfile lowercase : Tuple = tmp_path / """data_dot_dot""" directory.mkdir() lowercase : str = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(SCREAMING_SNAKE_CASE__ , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: import tarfile lowercase : Tuple = tmp_path / """data_sym_link""" directory.mkdir() lowercase : int = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=SCREAMING_SNAKE_CASE__ ) with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : List[Any] = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } lowercase : Optional[int] = insecure_tar_files[insecure_tar_file] lowercase : List[str] = tmp_path / """extracted""" TarExtractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number lowercase : Any = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 lowercase : str = ( B"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" B"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" B"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" B"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(SCREAMING_SNAKE_CASE__ ) assert zipfile.is_zipfile(str(SCREAMING_SNAKE_CASE__ ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(SCREAMING_SNAKE_CASE__ ) # but we're right
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: return 1 if digit in (0, 1) else (digit * factorial(digit - 1 )) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: lowercase : Optional[int] = 0 lowercase : str = number while duplicate > 0: lowercase , lowercase : List[Any] = divmod(SCREAMING_SNAKE_CASE__ , 10 ) fact_sum += factorial(SCREAMING_SNAKE_CASE__ ) return fact_sum == number if __name__ == "__main__": print("""Program to check whether a number is a Krisnamurthy Number or not.""") lowercase : List[str] = int(input("""Enter number: """).strip()) print( F'''{number} is {"" if krishnamurthy(number) else "not "}a Krishnamurthy Number.''' )
20
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 lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[Any] = { """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 ( lowerCAmelCase ): _a : str= "gpt_neo" _a : Optional[int]= ["past_key_values"] _a : Dict= {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self ,snake_case=50257 ,snake_case=2048 ,snake_case=2048 ,snake_case=24 ,snake_case=[[["global", "local"], 12]] ,snake_case=16 ,snake_case=None ,snake_case=256 ,snake_case="gelu_new" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=1e-5 ,snake_case=0.02 ,snake_case=True ,snake_case=50256 ,snake_case=50256 ,**snake_case ,): '''simple docstring''' lowercase : int = vocab_size lowercase : Union[str, Any] = max_position_embeddings lowercase : Dict = hidden_size lowercase : Union[str, Any] = num_layers lowercase : Union[str, Any] = num_heads lowercase : Optional[int] = intermediate_size lowercase : List[str] = window_size lowercase : Optional[int] = activation_function lowercase : List[str] = resid_dropout lowercase : int = embed_dropout lowercase : Optional[int] = attention_dropout lowercase : Tuple = classifier_dropout lowercase : Optional[int] = layer_norm_epsilon lowercase : Dict = initializer_range lowercase : List[str] = use_cache lowercase : Optional[int] = bos_token_id lowercase : int = eos_token_id lowercase : Union[str, Any] = attention_types lowercase : Dict = self.expand_attention_types_params(snake_case ) 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=snake_case ,eos_token_id=snake_case ,**snake_case ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : List[Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: import torch lowercase : Tuple = input.size() lowercase : int = len(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = shape[dimension] lowercase : int = torch.arange(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.div(sizedim - size , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) + 1 lowercase : Dict = torch.arange(SCREAMING_SNAKE_CASE__ ) + low_indices[:min_length][:, None] lowercase : Union[str, Any] = [slice(SCREAMING_SNAKE_CASE__ )] * rank lowercase : Optional[Any] = indices lowercase : List[str] = input[s] lowercase : Optional[int] = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import torch lowercase : Union[str, Any] = torch.arange(1 , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.remainder(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = remainders == 0 lowercase : Optional[int] = candidates[divisor_indices] lowercase : List[Any] = torch.max(SCREAMING_SNAKE_CASE__ ) return largest_divisor, torch.div(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(snake_case ,direction="""inputs""" ) lowercase : Dict = {0: """batch""", 1: """past_sequence + sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} return common_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self._config.num_heads def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,): '''simple docstring''' lowercase : Any = super(snake_case ,self ).generate_dummy_inputs( snake_case ,batch_size=snake_case ,seq_length=snake_case ,is_pair=snake_case ,framework=snake_case ) # We need to order the input in the way they appears in the forward() lowercase : List[str] = 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 lowercase , lowercase : List[Any] = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowercase : Optional[int] = seqlen + 2 lowercase : int = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowercase : Optional[Any] = [ (torch.zeros(snake_case ), torch.zeros(snake_case )) for _ in range(self.num_layers ) ] lowercase : Optional[Any] = common_inputs["""attention_mask"""] if self.use_past: lowercase : Any = ordered_inputs["""attention_mask"""].dtype lowercase : Union[str, Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(snake_case ,snake_case ,dtype=snake_case )] ,dim=1 ) return ordered_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 13
20
1
from jiwer import compute_measures import datasets lowercase : Optional[int] = """\ @inproceedings{inproceedings, author = {Morris, Andrew and Maier, Viktoria and Green, Phil}, year = {2004}, month = {01}, pages = {}, title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.} } """ lowercase : int = """\ Word error rate (WER) is a common metric of the performance of an automatic speech recognition system. The general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort. This problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate. Word error rate can then be computed as: WER = (S + D + I) / N = (S + D + I) / (S + D + C) where S is the number of substitutions, D is the number of deletions, I is the number of insertions, C is the number of correct words, N is the number of words in the reference (N=S+D+C). This value indicates the average number of errors per reference word. The lower the value, the better the performance of the ASR system with a WER of 0 being a perfect score. """ lowercase : Optional[int] = """ Compute WER score of transcribed segments against references. Args: references: List of references for each speech input. predictions: List of transcriptions to score. concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively. Returns: (float): the word error rate Examples: >>> predictions = [\"this is the prediction\", \"there is an other sample\"] >>> references = [\"this is the reference\", \"there is another one\"] >>> wer = datasets.load_metric(\"wer\") >>> wer_score = wer.compute(predictions=predictions, references=references) >>> print(wer_score) 0.5 """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""string""" ,id="""sequence""" ), """references""": datasets.Value("""string""" ,id="""sequence""" ), } ) ,codebase_urls=["""https://github.com/jitsi/jiwer/"""] ,reference_urls=[ """https://en.wikipedia.org/wiki/Word_error_rate""", ] ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ,snake_case=False ): '''simple docstring''' if concatenate_texts: return compute_measures(snake_case ,snake_case )["wer"] else: lowercase : Optional[Any] = 0 lowercase : Tuple = 0 for prediction, reference in zip(snake_case ,snake_case ): lowercase : Tuple = compute_measures(snake_case ,snake_case ) incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"] total += measures["substitutions"] + measures["deletions"] + measures["hits"] return incorrect / total
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING lowercase : Any = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == """tf""" else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = {} if top_k is not None: lowercase : int = top_k return {}, {}, postprocess_params def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = load_image(snake_case ) lowercase : List[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = self.model(**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ): '''simple docstring''' if top_k > self.model.config.num_labels: lowercase : Tuple = self.model.config.num_labels if self.framework == "pt": lowercase : str = model_outputs.logits.softmax(-1 )[0] lowercase , lowercase : Dict = probs.topk(snake_case ) elif self.framework == "tf": lowercase : Optional[int] = stable_softmax(model_outputs.logits ,axis=-1 )[0] lowercase : Union[str, Any] = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : List[str] = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f"Unsupported framework: {self.framework}" ) lowercase : Tuple = scores.tolist() lowercase : Dict = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case ,snake_case )]
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> float: if density <= 0: raise ValueError("""Impossible fluid density""" ) if bulk_modulus <= 0: raise ValueError("""Impossible bulk modulus""" ) return (bulk_modulus / density) ** 0.5 if __name__ == "__main__": import doctest doctest.testmod()
20
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) lowercase : Dict = { """configuration_resnet""": ["""RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ResNetConfig""", """ResNetOnnxConfig"""] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Union[str, Any] = [ """RESNET_PRETRAINED_MODEL_ARCHIVE_LIST""", """ResNetForImageClassification""", """ResNetModel""", """ResNetPreTrainedModel""", """ResNetBackbone""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[int] = [ """TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFResNetForImageClassification""", """TFResNetModel""", """TFResNetPreTrainedModel""", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """FlaxResNetForImageClassification""", """FlaxResNetModel""", """FlaxResNetPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_resnet import ( RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, ResNetBackbone, ResNetForImageClassification, ResNetModel, ResNetPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_resnet import ( TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFResNetForImageClassification, TFResNetModel, TFResNetPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel else: import sys lowercase : Optional[int] = _LazyModule(__name__, globals()["""__file__"""], _import_structure)
20
import json import os from dataclasses import dataclass from functools import partial from typing import Callable import flax.linen as nn import jax import jax.numpy as jnp import joblib import optax import wandb from flax import jax_utils, struct, traverse_util from flax.serialization import from_bytes, to_bytes from flax.training import train_state from flax.training.common_utils import shard from tqdm.auto import tqdm from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule class __snake_case ( lowerCAmelCase ): _a : BigBirdConfig _a : jnp.dtype= jnp.floataa _a : bool= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setup() lowercase : List[str] = nn.Dense(5 ,dtype=self.dtype ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = super().__call__(*snake_case ,**snake_case ) lowercase : Any = self.cls(outputs[2] ) return outputs[:2] + (cls_out,) class __snake_case ( lowerCAmelCase ): _a : List[Any]= FlaxBigBirdForNaturalQuestionsModule def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: def cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ): lowercase : int = logits.shape[-1] lowercase : Dict = (labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__ )[None]).astype("""f4""" ) lowercase : Any = jax.nn.log_softmax(SCREAMING_SNAKE_CASE__ , axis=-1 ) lowercase : Optional[Any] = -jnp.sum(labels * logits , axis=-1 ) if reduction is not None: lowercase : Any = reduction(SCREAMING_SNAKE_CASE__ ) return loss lowercase : Optional[Any] = partial(SCREAMING_SNAKE_CASE__ , reduction=jnp.mean ) lowercase : Optional[int] = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Dict = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return (start_loss + end_loss + pooled_loss) / 3 @dataclass class __snake_case : _a : str= "google/bigbird-roberta-base" _a : int= 3000 _a : int= 1_0500 _a : int= 128 _a : int= 3 _a : int= 1 _a : int= 5 # tx_args _a : float= 3E-5 _a : float= 0.0 _a : int= 2_0000 _a : float= 0.00_95 _a : str= "bigbird-roberta-natural-questions" _a : str= "training-expt" _a : str= "data/nq-training.jsonl" _a : str= "data/nq-validation.jsonl" def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' os.makedirs(self.base_dir ,exist_ok=snake_case ) lowercase : Optional[int] = os.path.join(self.base_dir ,self.save_dir ) lowercase : Optional[int] = self.batch_size_per_device * jax.device_count() @dataclass class __snake_case : _a : int _a : int= 4096 # no dynamic padding on TPUs def __call__( self ,snake_case ): '''simple docstring''' lowercase : int = self.collate_fn(snake_case ) lowercase : Union[str, Any] = jax.tree_util.tree_map(snake_case ,snake_case ) return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Union[str, Any] = self.fetch_inputs(features["""input_ids"""] ) lowercase : Tuple = { """input_ids""": jnp.array(snake_case ,dtype=jnp.intaa ), """attention_mask""": jnp.array(snake_case ,dtype=jnp.intaa ), """start_labels""": jnp.array(features["""start_token"""] ,dtype=jnp.intaa ), """end_labels""": jnp.array(features["""end_token"""] ,dtype=jnp.intaa ), """pooled_labels""": jnp.array(features["""category"""] ,dtype=jnp.intaa ), } return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = [self._fetch_inputs(snake_case ) for ids in input_ids] return zip(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [1 for _ in range(len(snake_case ) )] while len(snake_case ) < self.max_length: input_ids.append(self.pad_id ) attention_mask.append(0 ) return input_ids, attention_mask def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> Any: if seed is not None: lowercase : Optional[int] = dataset.shuffle(seed=SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) // batch_size ): lowercase : Optional[Any] = dataset[i * batch_size : (i + 1) * batch_size] yield dict(SCREAMING_SNAKE_CASE__ ) @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[Any]: def loss_fn(SCREAMING_SNAKE_CASE__ ): lowercase : List[str] = model_inputs.pop("""start_labels""" ) lowercase : Optional[int] = model_inputs.pop("""end_labels""" ) lowercase : str = model_inputs.pop("""pooled_labels""" ) lowercase : Union[str, Any] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=SCREAMING_SNAKE_CASE__ , dropout_rng=SCREAMING_SNAKE_CASE__ , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[str] = outputs return state.loss_fn( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) lowercase , lowercase : int = jax.random.split(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = jax.value_and_grad(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : Union[str, Any] = grad_fn(state.params ) lowercase : List[Any] = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) lowercase : List[Any] = jax.lax.pmean(SCREAMING_SNAKE_CASE__ , """batch""" ) lowercase : str = state.apply_gradients(grads=SCREAMING_SNAKE_CASE__ ) return state, metrics, new_drp_rng @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = model_inputs.pop("""start_labels""" ) lowercase : Dict = model_inputs.pop("""end_labels""" ) lowercase : Optional[Any] = model_inputs.pop("""pooled_labels""" ) lowercase : Optional[int] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=state.params , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[Any] = outputs lowercase : Dict = state.loss_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : str = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) return metrics class __snake_case ( train_state.TrainState ): _a : Callable= struct.field(pytree_node=lowerCAmelCase ) @dataclass class __snake_case : _a : Args _a : Callable _a : Callable _a : Callable _a : Callable _a : wandb _a : Callable= None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = model.params lowercase : Any = TrainState.create( apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,loss_fn=snake_case ,) if ckpt_dir is not None: lowercase , lowercase , lowercase , lowercase , lowercase : Tuple = restore_checkpoint(snake_case ,snake_case ) lowercase : List[str] = { """lr""": args.lr, """init_lr""": args.init_lr, """warmup_steps""": args.warmup_steps, """num_train_steps""": num_train_steps, """weight_decay""": args.weight_decay, } lowercase , lowercase : Tuple = build_tx(**snake_case ) lowercase : str = train_state.TrainState( step=snake_case ,apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,opt_state=snake_case ,) lowercase : Any = args lowercase : Optional[Any] = data_collator lowercase : List[str] = lr lowercase : str = params lowercase : Tuple = jax_utils.replicate(snake_case ) return state def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = self.args lowercase : Optional[Any] = len(snake_case ) // args.batch_size lowercase : int = jax.random.PRNGKey(0 ) lowercase : List[str] = jax.random.split(snake_case ,jax.device_count() ) for epoch in range(args.max_epochs ): lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : List[str] = get_batched_dataset(snake_case ,args.batch_size ,seed=snake_case ) lowercase : int = 0 for batch in tqdm(snake_case ,total=snake_case ,desc=f"Running EPOCH-{epoch}" ): lowercase : Dict = self.data_collator(snake_case ) lowercase , lowercase , lowercase : Optional[int] = self.train_step_fn(snake_case ,snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 if i % args.logging_steps == 0: lowercase : Optional[Any] = jax_utils.unreplicate(state.step ) lowercase : List[str] = running_loss.item() / i lowercase : List[str] = self.scheduler_fn(state_step - 1 ) lowercase : int = self.evaluate(snake_case ,snake_case ) lowercase : Tuple = { """step""": state_step.item(), """eval_loss""": eval_loss.item(), """tr_loss""": tr_loss, """lr""": lr.item(), } tqdm.write(str(snake_case ) ) self.logger.log(snake_case ,commit=snake_case ) if i % args.save_steps == 0: self.save_checkpoint(args.save_dir + f"-e{epoch}-s{i}" ,state=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = get_batched_dataset(snake_case ,self.args.batch_size ) lowercase : Any = len(snake_case ) // self.args.batch_size lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : Optional[int] = 0 for batch in tqdm(snake_case ,total=snake_case ,desc="""Evaluating ... """ ): lowercase : Tuple = self.data_collator(snake_case ) lowercase : Optional[int] = self.val_step_fn(snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 return running_loss / i def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = jax_utils.unreplicate(snake_case ) print(f"SAVING CHECKPOINT IN {save_dir}" ,end=""" ... """ ) self.model_save_fn(snake_case ,params=state.params ) with open(os.path.join(snake_case ,"""opt_state.msgpack""" ) ,"""wb""" ) as f: f.write(to_bytes(state.opt_state ) ) joblib.dump(self.args ,os.path.join(snake_case ,"""args.joblib""" ) ) joblib.dump(self.data_collator ,os.path.join(snake_case ,"""data_collator.joblib""" ) ) with open(os.path.join(snake_case ,"""training_state.json""" ) ,"""w""" ) as f: json.dump({"""step""": state.step.item()} ,snake_case ) print("""DONE""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: print(f"RESTORING CHECKPOINT FROM {save_dir}" , end=""" ... """ ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """flax_model.msgpack""" ) , """rb""" ) as f: lowercase : str = from_bytes(state.params , f.read() ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """opt_state.msgpack""" ) , """rb""" ) as f: lowercase : Optional[int] = from_bytes(state.opt_state , f.read() ) lowercase : Optional[Any] = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """args.joblib""" ) ) lowercase : int = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """data_collator.joblib""" ) ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """training_state.json""" ) , """r""" ) as f: lowercase : Tuple = json.load(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = training_state["""step"""] print("""DONE""" ) return params, opt_state, step, args, data_collator def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : List[str] = num_train_steps - warmup_steps lowercase : Dict = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=SCREAMING_SNAKE_CASE__ , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=1e-7 , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = optax.join_schedules(schedules=[warmup_fn, decay_fn] , boundaries=[warmup_steps] ) return lr def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: def weight_decay_mask(SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = {k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()} return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = scheduler_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__ , weight_decay=SCREAMING_SNAKE_CASE__ , mask=SCREAMING_SNAKE_CASE__ ) return tx, lr
20
1
from __future__ import annotations from typing import Any def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if not postfix_notation: return 0 lowercase : int = {"""+""", """-""", """*""", """/"""} lowercase : list[Any] = [] for token in postfix_notation: if token in operations: lowercase , lowercase : Dict = stack.pop(), stack.pop() if token == "+": stack.append(a + b ) elif token == "-": stack.append(a - b ) elif token == "*": stack.append(a * b ) else: if a * b < 0 and a % b != 0: stack.append(a // b + 1 ) else: stack.append(a // b ) else: stack.append(int(SCREAMING_SNAKE_CASE__ ) ) return stack.pop() if __name__ == "__main__": import doctest doctest.testmod()
20
from math import sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' must been an int and positive" lowercase : Union[str, Any] = True # 0 and 1 are none primes. if number <= 1: lowercase : str = False for divisor in range(2 , int(round(sqrt(SCREAMING_SNAKE_CASE__ ) ) ) + 1 ): # if 'number' divisible by 'divisor' then sets 'status' # of false and break up the loop. if number % divisor == 0: lowercase : Any = False break # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'status' must been from type bool" return status def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" # beginList: contains all natural numbers from 2 up to N lowercase : str = list(range(2 , n + 1 ) ) lowercase : Tuple = [] # this list will be returns. # actual sieve of erathostenes for i in range(len(SCREAMING_SNAKE_CASE__ ) ): for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0): lowercase : Tuple = 0 # filters actual prime numbers. lowercase : int = [x for x in begin_list if x != 0] # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" lowercase : Dict = [] # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2 , n + 1 ): if is_prime(SCREAMING_SNAKE_CASE__ ): ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and number >= 0, "'number' must been an int and >= 0" lowercase : Tuple = [] # this list will be returns of the function. # potential prime number factors. lowercase : Optional[Any] = 2 lowercase : Any = number if number == 0 or number == 1: ans.append(SCREAMING_SNAKE_CASE__ ) # if 'number' not prime then builds the prime factorization of 'number' elif not is_prime(SCREAMING_SNAKE_CASE__ ): while quotient != 1: if is_prime(SCREAMING_SNAKE_CASE__ ) and (quotient % factor == 0): ans.append(SCREAMING_SNAKE_CASE__ ) quotient /= factor else: factor += 1 else: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Tuple = 0 # prime factorization of 'number' lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = max(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Union[str, Any] = 0 # prime factorization of 'number' lowercase : Tuple = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = min(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 == 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 == 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 != 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 != 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__ ) ), "'number' must been an int, even and > 2" lowercase : Union[str, Any] = [] # this list will returned # creates a list of prime numbers between 2 up to 'number' lowercase : str = get_prime_numbers(SCREAMING_SNAKE_CASE__ ) lowercase : Any = len(SCREAMING_SNAKE_CASE__ ) # run variable for while-loops. lowercase : Optional[Any] = 0 lowercase : List[Any] = None # exit variable. for break up the loops lowercase : Any = True while i < len_pn and loop: lowercase : str = i + 1 while j < len_pn and loop: if prime_numbers[i] + prime_numbers[j] == number: lowercase : Union[str, Any] = False ans.append(prime_numbers[i] ) ans.append(prime_numbers[j] ) j += 1 i += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (len(SCREAMING_SNAKE_CASE__ ) == 2) and (ans[0] + ans[1] == number) and is_prime(ans[0] ) and is_prime(ans[1] ) ), "'ans' must contains two primes. And sum of elements must been eq 'number'" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 0) and (numbera >= 0) ), "'number1' and 'number2' must been positive integer." lowercase : Union[str, Any] = 0 while numbera != 0: lowercase : Optional[int] = numbera % numbera lowercase : Optional[int] = numbera lowercase : Dict = rest # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( numbera >= 0 ), "'number' must been from type int and positive" return numbera def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 1) and (numbera >= 1) ), "'number1' and 'number2' must been positive integer." lowercase : Dict = 1 # actual answer that will be return. # for kgV (x,1) if numbera > 1 and numbera > 1: # builds the prime factorization of 'number1' and 'number2' lowercase : Optional[Any] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) elif numbera == 1 or numbera == 1: lowercase : Union[str, Any] = [] lowercase : List[str] = [] lowercase : Dict = max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = 0 lowercase : Optional[Any] = 0 lowercase : List[str] = [] # captured numbers int both 'primeFac1' and 'primeFac2' # iterates through primeFac1 for n in prime_fac_a: if n not in done: if n in prime_fac_a: lowercase : Dict = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ): ans *= n else: lowercase : List[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # iterates through primeFac2 for n in prime_fac_a: if n not in done: lowercase : Optional[int] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( ans >= 0 ), "'ans' must been from type int and positive" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'number' must been a positive int" lowercase : Dict = 0 lowercase : List[str] = 2 # this variable holds the answer while index < n: index += 1 ans += 1 # counts to the next number # if ans not prime then # runs to the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): ans += 1 # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and is_prime( SCREAMING_SNAKE_CASE__ ), "'ans' must been a prime number and from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert ( is_prime(SCREAMING_SNAKE_CASE__ ) and is_prime(SCREAMING_SNAKE_CASE__ ) and (p_number_a < p_number_a) ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" lowercase : List[str] = p_number_a + 1 # jump to the next number lowercase : List[Any] = [] # this list will be returns. # if number is not prime then # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 while number < p_number_a: ans.append(SCREAMING_SNAKE_CASE__ ) number += 1 # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ans[0] != p_number_a and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] != p_number_a ), "'ans' must been a list without the arguments" # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 1), "'n' must been int and >= 1" lowercase : Optional[Any] = [] # will be returned. for divisor in range(1 , n + 1 ): if n % divisor == 0: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] == n, "Error in function getDivisiors(...)" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number > 1 ), "'number' must been an int and >= 1" lowercase : str = get_divisors(SCREAMING_SNAKE_CASE__ ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (divisors[0] == 1) and (divisors[len(SCREAMING_SNAKE_CASE__ ) - 1] == number) ), "Error in help-function getDivisiors(...)" # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1] ) == number def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (denominator != 0) ), "The arguments must been from type int and 'denominator' != 0" # build the greatest common divisor of numerator and denominator. lowercase : Tuple = gcd(abs(SCREAMING_SNAKE_CASE__ ) , abs(SCREAMING_SNAKE_CASE__ ) ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numerator % gcd_of_fraction == 0) and (denominator % gcd_of_fraction == 0) ), "Error in function gcd(...,...)" return (numerator // gcd_of_fraction, denominator // gcd_of_fraction) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been a int and >= 0" lowercase : List[str] = 1 # this will be return. for factor in range(1 , n + 1 ): ans *= factor return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been an int and >= 0" lowercase : int = 0 lowercase : Union[str, Any] = 1 lowercase : int = 1 # this will be return for _ in range(n - 1 ): lowercase : Optional[int] = ans ans += fiba lowercase : Optional[int] = tmp return ans
20
1
from math import pi, sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> float: if num <= 0: raise ValueError("""math domain error""" ) if num > 171.5: raise OverflowError("""math range error""" ) elif num - int(SCREAMING_SNAKE_CASE__ ) not in (0, 0.5): raise NotImplementedError("""num must be an integer or a half-integer""" ) elif num == 0.5: return sqrt(SCREAMING_SNAKE_CASE__ ) else: return 1.0 if num == 1 else (num - 1) * gamma(num - 1 ) def _snake_case( ) -> None: assert gamma(0.5 ) == sqrt(SCREAMING_SNAKE_CASE__ ) assert gamma(1 ) == 1.0 assert gamma(2 ) == 1.0 if __name__ == "__main__": from doctest import testmod testmod() lowercase : Optional[Any] = 1.0 while num: lowercase : Dict = float(input("""Gamma of: """)) print(F'''gamma({num}) = {gamma(num)}''') print("""\nEnter 0 to exit...""")
20
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
1
# DISCLAIMER: This file is strongly influenced by https://github.com/yang-song/score_sde_pytorch import math from dataclasses import dataclass from typing import Optional, Tuple, Union import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin, SchedulerOutput @dataclass class __snake_case ( lowerCAmelCase ): _a : torch.FloatTensor _a : torch.FloatTensor class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Optional[int]= 1 @register_to_config def __init__( self ,snake_case = 2000 ,snake_case = 0.15 ,snake_case = 0.01 ,snake_case = 1_348.0 ,snake_case = 1e-5 ,snake_case = 1 ,): '''simple docstring''' lowercase : int = sigma_max # setable values lowercase : Optional[int] = None self.set_sigmas(snake_case ,snake_case ,snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ): '''simple docstring''' lowercase : int = sampling_eps if sampling_eps is not None else self.config.sampling_eps lowercase : Any = torch.linspace(1 ,snake_case ,snake_case ,device=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,snake_case = None ): '''simple docstring''' lowercase : Optional[int] = sigma_min if sigma_min is not None else self.config.sigma_min lowercase : Dict = sigma_max if sigma_max is not None else self.config.sigma_max lowercase : Dict = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(snake_case ,snake_case ) lowercase : str = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) lowercase : List[str] = torch.exp(torch.linspace(math.log(snake_case ) ,math.log(snake_case ) ,snake_case ) ) lowercase : List[Any] = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' return torch.where( timesteps == 0 ,torch.zeros_like(t.to(timesteps.device ) ) ,self.discrete_sigmas[timesteps - 1].to(timesteps.device ) ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = None ,snake_case = True ,): '''simple docstring''' if self.timesteps is None: raise ValueError( """`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler""" ) lowercase : str = timestep * torch.ones( sample.shape[0] ,device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) lowercase : Tuple = (timestep * (len(self.timesteps ) - 1)).long() # mps requires indices to be in the same device, so we use cpu as is the default with cuda lowercase : Union[str, Any] = timesteps.to(self.discrete_sigmas.device ) lowercase : Optional[int] = self.discrete_sigmas[timesteps].to(sample.device ) lowercase : Dict = self.get_adjacent_sigma(snake_case ,snake_case ).to(sample.device ) lowercase : List[str] = torch.zeros_like(snake_case ) lowercase : List[Any] = (sigma**2 - adjacent_sigma**2) ** 0.5 # equation 6 in the paper: the model_output modeled by the network is grad_x log pt(x) # also equation 47 shows the analog from SDE models to ancestral sampling methods lowercase : Dict = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): lowercase : List[Any] = diffusion.unsqueeze(-1 ) lowercase : int = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of lowercase : Any = randn_tensor( sample.shape ,layout=sample.layout ,generator=snake_case ,device=sample.device ,dtype=sample.dtype ) lowercase : List[Any] = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? lowercase : int = prev_sample_mean + diffusion * noise # add impact of diffusion field g if not return_dict: return (prev_sample, prev_sample_mean) return SdeVeOutput(prev_sample=snake_case ,prev_sample_mean=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case = None ,snake_case = True ,): '''simple docstring''' if self.timesteps is None: raise ValueError( """`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler""" ) # For small batch sizes, the paper "suggest replacing norm(z) with sqrt(d), where d is the dim. of z" # sample noise for correction lowercase : Tuple = randn_tensor(sample.shape ,layout=sample.layout ,generator=snake_case ).to(sample.device ) # compute step size from the model_output, the noise, and the snr lowercase : Any = torch.norm(model_output.reshape(model_output.shape[0] ,-1 ) ,dim=-1 ).mean() lowercase : Optional[int] = torch.norm(noise.reshape(noise.shape[0] ,-1 ) ,dim=-1 ).mean() lowercase : Optional[int] = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 lowercase : str = step_size * torch.ones(sample.shape[0] ).to(sample.device ) # self.repeat_scalar(step_size, sample.shape[0]) # compute corrected sample: model_output term and noise term lowercase : Union[str, Any] = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): lowercase : Optional[Any] = step_size.unsqueeze(-1 ) lowercase : Tuple = sample + step_size * model_output lowercase : Union[str, Any] = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = timesteps.to(original_samples.device ) lowercase : Optional[Any] = self.discrete_sigmas.to(original_samples.device )[timesteps] lowercase : List[Any] = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(snake_case ) * sigmas[:, None, None, None] ) lowercase : Tuple = noise + original_samples return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
import argparse import requests import torch from PIL import Image from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: if "cls_token" in name: lowercase : List[Any] = name.replace("""cls_token""" , """vit.embeddings.cls_token""" ) if "mask_token" in name: lowercase : Any = name.replace("""mask_token""" , """decoder.mask_token""" ) if "decoder_pos_embed" in name: lowercase : str = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : List[str] = name.replace("""pos_embed""" , """vit.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """vit.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : int = name.replace("""patch_embed.norm""" , """vit.embeddings.norm""" ) if "decoder_blocks" in name: lowercase : Tuple = name.replace("""decoder_blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[Any] = name.replace("""blocks""" , """vit.encoder.layer""" ) if "attn.proj" in name: lowercase : List[str] = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "norm1" in name: lowercase : Optional[Any] = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Union[str, Any] = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : Dict = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : Dict = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Dict = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : List[str] = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name: lowercase : Tuple = name.replace("""norm.weight""" , """vit.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name: lowercase : int = name.replace("""norm.bias""" , """vit.layernorm.bias""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: for key in orig_state_dict.copy().keys(): lowercase : List[Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if "qkv" in key: lowercase : int = key.split(""".""" ) lowercase : List[str] = int(key_split[1] ) if "decoder_blocks" in key: lowercase : Tuple = config.decoder_hidden_size lowercase : int = """decoder.decoder_layers.""" if "weight" in key: lowercase : List[Any] = val[:dim, :] lowercase : Tuple = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] elif "bias" in key: lowercase : str = val[:dim] lowercase : Dict = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Tuple = config.hidden_size lowercase : Union[str, Any] = """vit.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : Dict = val[-dim:, :] elif "bias" in key: lowercase : Any = val[:dim] lowercase : str = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Union[str, Any] = val return orig_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : int = ViTMAEConfig() if "large" in checkpoint_url: lowercase : Dict = 1_024 lowercase : str = 4_096 lowercase : Optional[Any] = 24 lowercase : Optional[Any] = 16 elif "huge" in checkpoint_url: lowercase : int = 14 lowercase : List[Any] = 1_280 lowercase : int = 5_120 lowercase : List[Any] = 32 lowercase : Any = 16 lowercase : List[str] = ViTMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" )["""model"""] lowercase : Tuple = ViTMAEImageProcessor(size=config.image_size ) lowercase : Optional[int] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() lowercase : Union[str, Any] = """https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg""" lowercase : Union[str, Any] = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ) lowercase : Optional[Any] = ViTMAEImageProcessor(size=config.image_size ) lowercase : List[Any] = image_processor(images=SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) # forward pass torch.manual_seed(2 ) lowercase : int = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits if "large" in checkpoint_url: lowercase : List[Any] = torch.tensor( [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]] ) elif "huge" in checkpoint_url: lowercase : Tuple = torch.tensor( [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]] ) else: lowercase : List[str] = torch.tensor( [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]] ) # verify logits assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print(f"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""", type=str, help="""URL of the checkpoint you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : List[Any] = parser.parse_args() convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
20
1
from collections import OrderedDict from typing import TYPE_CHECKING, Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging if TYPE_CHECKING: from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType lowercase : Any = logging.get_logger(__name__) lowercase : Optional[int] = { """microsoft/deberta-v2-xlarge""": """https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json""", """microsoft/deberta-v2-xxlarge""": """https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json""", """microsoft/deberta-v2-xlarge-mnli""": ( """https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json""" ), """microsoft/deberta-v2-xxlarge-mnli""": ( """https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json""" ), } class __snake_case ( lowerCAmelCase ): _a : Any= "deberta-v2" def __init__( self ,snake_case=128100 ,snake_case=1536 ,snake_case=24 ,snake_case=24 ,snake_case=6144 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=0 ,snake_case=0.02 ,snake_case=1e-7 ,snake_case=False ,snake_case=-1 ,snake_case=0 ,snake_case=True ,snake_case=None ,snake_case=0 ,snake_case="gelu" ,**snake_case ,): '''simple docstring''' super().__init__(**snake_case ) lowercase : Union[str, Any] = hidden_size lowercase : int = num_hidden_layers lowercase : str = num_attention_heads lowercase : Any = intermediate_size lowercase : Any = hidden_act lowercase : Optional[Any] = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Optional[Any] = max_position_embeddings lowercase : Optional[int] = type_vocab_size lowercase : Optional[int] = initializer_range lowercase : Tuple = relative_attention lowercase : Any = max_relative_positions lowercase : Any = pad_token_id lowercase : Optional[int] = position_biased_input # Backwards compatibility if type(snake_case ) == str: lowercase : Tuple = [x.strip() for x in pos_att_type.lower().split("""|""" )] lowercase : List[str] = pos_att_type lowercase : Dict = vocab_size lowercase : int = layer_norm_eps lowercase : Union[str, Any] = kwargs.get("""pooler_hidden_size""" ,snake_case ) lowercase : Any = pooler_dropout lowercase : Dict = pooler_hidden_act class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.task == "multiple-choice": lowercase : Union[str, Any] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} if self._config.type_vocab_size > 0: return OrderedDict( [("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis)] ) else: return OrderedDict([("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis)] ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 12 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,snake_case = 3 ,snake_case = 40 ,snake_case = 40 ,snake_case = None ,): '''simple docstring''' lowercase : Union[str, Any] = super().generate_dummy_inputs(preprocessor=snake_case ,framework=snake_case ) if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs: del dummy_inputs["token_type_ids"] return dummy_inputs
20
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=0.999 , SCREAMING_SNAKE_CASE__="cosine" , ) -> List[Any]: if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.exp(t * -12.0 ) else: raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}" ) lowercase : int = [] for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = i / num_diffusion_timesteps lowercase : Optional[int] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) / alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ) ) return torch.tensor(SCREAMING_SNAKE_CASE__ , dtype=torch.floataa ) class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Tuple= [e.name for e in KarrasDiffusionSchedulers] _a : int= 2 @register_to_config def __init__( self ,snake_case = 1000 ,snake_case = 0.00_085 ,snake_case = 0.012 ,snake_case = "linear" ,snake_case = None ,snake_case = "epsilon" ,snake_case = False ,snake_case = False ,snake_case = 1.0 ,snake_case = "linspace" ,snake_case = 0 ,): '''simple docstring''' if trained_betas is not None: lowercase : List[str] = torch.tensor(snake_case ,dtype=torch.floataa ) elif beta_schedule == "linear": lowercase : Optional[Any] = torch.linspace(snake_case ,snake_case ,snake_case ,dtype=torch.floataa ) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. lowercase : int = ( torch.linspace(beta_start**0.5 ,beta_end**0.5 ,snake_case ,dtype=torch.floataa ) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule lowercase : Union[str, Any] = betas_for_alpha_bar(snake_case ,alpha_transform_type="""cosine""" ) elif beta_schedule == "exp": lowercase : int = betas_for_alpha_bar(snake_case ,alpha_transform_type="""exp""" ) else: raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}" ) lowercase : Any = 1.0 - self.betas lowercase : Dict = torch.cumprod(self.alphas ,dim=0 ) # set all values self.set_timesteps(snake_case ,snake_case ,snake_case ) lowercase : Tuple = use_karras_sigmas def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if schedule_timesteps is None: lowercase : Union[str, Any] = self.timesteps lowercase : Dict = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter ) == 0: lowercase : Dict = 1 if len(snake_case ) > 1 else 0 else: lowercase : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep lowercase : str = self._index_counter[timestep_int] return indices[pos].item() @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[Any] = self.index_for_timestep(snake_case ) lowercase : Dict = self.sigmas[step_index] lowercase : List[str] = sample / ((sigma**2 + 1) ** 0.5) return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,): '''simple docstring''' lowercase : Any = num_inference_steps lowercase : List[Any] = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": lowercase : Optional[int] = np.linspace(0 ,num_train_timesteps - 1 ,snake_case ,dtype=snake_case )[::-1].copy() elif self.config.timestep_spacing == "leading": lowercase : int = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : List[str] = (np.arange(0 ,snake_case ) * step_ratio).round()[::-1].copy().astype(snake_case ) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": lowercase : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : Optional[int] = (np.arange(snake_case ,0 ,-step_ratio )).round().copy().astype(snake_case ) timesteps -= 1 else: raise ValueError( f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." ) lowercase : Optional[int] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 ) lowercase : Dict = np.log(snake_case ) lowercase : Union[str, Any] = np.interp(snake_case ,np.arange(0 ,len(snake_case ) ) ,snake_case ) if self.config.use_karras_sigmas: lowercase : List[Any] = self._convert_to_karras(in_sigmas=snake_case ,num_inference_steps=self.num_inference_steps ) lowercase : Tuple = np.array([self._sigma_to_t(snake_case ,snake_case ) for sigma in sigmas] ) lowercase : Any = np.concatenate([sigmas, [0.0]] ).astype(np.floataa ) lowercase : List[Any] = torch.from_numpy(snake_case ).to(device=snake_case ) lowercase : List[Any] = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2 ), sigmas[-1:]] ) lowercase : Dict = torch.from_numpy(snake_case ) lowercase : List[Any] = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2 )] ) if str(snake_case ).startswith("""mps""" ): # mps does not support float64 lowercase : Any = timesteps.to(snake_case ,dtype=torch.floataa ) else: lowercase : str = timesteps.to(device=snake_case ) # empty dt and derivative lowercase : Union[str, Any] = None lowercase : Any = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter lowercase : str = defaultdict(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = np.log(snake_case ) # get distribution lowercase : Union[str, Any] = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range lowercase : Optional[int] = np.cumsum((dists >= 0) ,axis=0 ).argmax(axis=0 ).clip(max=log_sigmas.shape[0] - 2 ) lowercase : Any = low_idx + 1 lowercase : str = log_sigmas[low_idx] lowercase : Dict = log_sigmas[high_idx] # interpolate sigmas lowercase : int = (low - log_sigma) / (low - high) lowercase : Dict = np.clip(snake_case ,0 ,1 ) # transform interpolation to time range lowercase : Optional[Any] = (1 - w) * low_idx + w * high_idx lowercase : Tuple = t.reshape(sigma.shape ) return t def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : float = in_sigmas[-1].item() lowercase : float = in_sigmas[0].item() lowercase : Dict = 7.0 # 7.0 is the value used in the paper lowercase : Optional[int] = np.linspace(0 ,1 ,snake_case ) lowercase : int = sigma_min ** (1 / rho) lowercase : Any = sigma_max ** (1 / rho) lowercase : Tuple = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.dt is None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = True ,): '''simple docstring''' lowercase : Union[str, Any] = self.index_for_timestep(snake_case ) # advance index counter by 1 lowercase : Optional[int] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: lowercase : str = self.sigmas[step_index] lowercase : Optional[int] = self.sigmas[step_index + 1] else: # 2nd order / Heun's method lowercase : Dict = self.sigmas[step_index - 1] lowercase : Optional[Any] = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API lowercase : Union[str, Any] = 0 lowercase : Any = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": lowercase : Any = sigma_hat if self.state_in_first_order else sigma_next lowercase : int = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": lowercase : Union[str, Any] = sigma_hat if self.state_in_first_order else sigma_next lowercase : Optional[Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": lowercase : Optional[Any] = model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`" ) if self.config.clip_sample: lowercase : str = pred_original_sample.clamp( -self.config.clip_sample_range ,self.config.clip_sample_range ) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order lowercase : Optional[int] = (sample - pred_original_sample) / sigma_hat # 3. delta timestep lowercase : Union[str, Any] = sigma_next - sigma_hat # store for 2nd order step lowercase : Optional[int] = derivative lowercase : Union[str, Any] = dt lowercase : Union[str, Any] = sample else: # 2. 2nd order / Heun's method lowercase : Tuple = (sample - pred_original_sample) / sigma_next lowercase : Dict = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample lowercase : Tuple = self.dt lowercase : Optional[Any] = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" lowercase : List[str] = None lowercase : Tuple = None lowercase : Dict = None lowercase : List[Any] = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[int] = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype ) if original_samples.device.type == "mps" and torch.is_floating_point(snake_case ): # mps does not support float64 lowercase : List[Any] = self.timesteps.to(original_samples.device ,dtype=torch.floataa ) lowercase : List[str] = timesteps.to(original_samples.device ,dtype=torch.floataa ) else: lowercase : List[str] = self.timesteps.to(original_samples.device ) lowercase : Tuple = timesteps.to(original_samples.device ) lowercase : Any = [self.index_for_timestep(snake_case ,snake_case ) for t in timesteps] lowercase : int = sigmas[step_indices].flatten() while len(sigma.shape ) < len(original_samples.shape ): lowercase : Any = sigma.unsqueeze(-1 ) lowercase : Optional[int] = original_samples + noise * sigma return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
1
from string import ascii_lowercase, ascii_uppercase def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: if not sentence: return "" lowercase : Optional[int] = dict(zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) return lower_to_upper.get(sentence[0] , sentence[0] ) + sentence[1:] if __name__ == "__main__": from doctest import testmod testmod()
20
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch lowercase : List[str] = logging.get_logger(__name__) @add_end_docstrings( lowerCAmelCase , R"\n top_k (`int`, defaults to 5):\n The number of predictions to return.\n targets (`str` or `List[str]`, *optional*):\n When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n token will be used (with a warning, and that might be slower).\n\n " , ) class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if self.framework == "tf": lowercase : str = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": lowercase : Optional[int] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ) else: raise ValueError("""Unsupported framework""" ) return masked_index def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = self.get_masked_index(snake_case ) lowercase : Dict = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,f"No mask_token ({self.tokenizer.mask_token}) found on the input" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if isinstance(snake_case ,snake_case ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,**snake_case ): '''simple docstring''' if return_tensors is None: lowercase : int = self.framework lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=snake_case ) self.ensure_exactly_one_mask_token(snake_case ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[int] = self.model(**snake_case ) lowercase : Tuple = model_inputs["""input_ids"""] return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ,snake_case=None ): '''simple docstring''' if target_ids is not None and target_ids.shape[0] < top_k: lowercase : str = target_ids.shape[0] lowercase : Optional[Any] = model_outputs["""input_ids"""][0] lowercase : List[str] = model_outputs["""logits"""] if self.framework == "tf": lowercase : List[str] = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] lowercase : Tuple = outputs.numpy() lowercase : Tuple = outputs[0, masked_index, :] lowercase : Any = stable_softmax(snake_case ,axis=-1 ) if target_ids is not None: lowercase : Union[str, Any] = tf.gather_nd(tf.squeeze(snake_case ,0 ) ,target_ids.reshape(-1 ,1 ) ) lowercase : int = tf.expand_dims(snake_case ,0 ) lowercase : Tuple = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : int = topk.values.numpy(), topk.indices.numpy() else: lowercase : Optional[Any] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample lowercase : Union[str, Any] = outputs[0, masked_index, :] lowercase : Tuple = logits.softmax(dim=-1 ) if target_ids is not None: lowercase : List[str] = probs[..., target_ids] lowercase , lowercase : Union[str, Any] = probs.topk(snake_case ) lowercase : Any = [] lowercase : List[Any] = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() ,predictions.tolist() ) ): lowercase : Dict = [] for v, p in zip(_values ,_predictions ): # Copy is important since we're going to modify this array in place lowercase : Dict = input_ids.numpy().copy() if target_ids is not None: lowercase : Union[str, Any] = target_ids[p].tolist() lowercase : Tuple = p # Filter padding out: lowercase : List[str] = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back lowercase : Tuple = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : Optional[Any] = {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p] ), """sequence""": sequence} row.append(snake_case ) result.append(snake_case ) if single_mask: return result[0] return result def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if isinstance(snake_case ,snake_case ): lowercase : List[Any] = [targets] try: lowercase : List[str] = self.tokenizer.get_vocab() except Exception: lowercase : Any = {} lowercase : Dict = [] for target in targets: lowercase : Dict = vocab.get(snake_case ,snake_case ) if id_ is None: lowercase : Optional[int] = self.tokenizer( snake_case ,add_special_tokens=snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,max_length=1 ,truncation=snake_case ,)["""input_ids"""] if len(snake_case ) == 0: logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " """We cannot replace it with anything meaningful, ignoring it""" ) continue lowercase : Union[str, Any] = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`." ) target_ids.append(id_ ) lowercase : Optional[Any] = list(set(snake_case ) ) if len(snake_case ) == 0: raise ValueError("""At least one target must be provided when passed.""" ) lowercase : Optional[Any] = np.array(snake_case ) return target_ids def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : Dict = {} if targets is not None: lowercase : str = self.get_target_ids(snake_case ,snake_case ) lowercase : List[Any] = target_ids if top_k is not None: lowercase : List[str] = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,"""The tokenizer does not define a `mask_token`.""" ) return {}, {}, postprocess_params def __call__( self ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Tuple = super().__call__(snake_case ,**snake_case ) if isinstance(snake_case ,snake_case ) and len(snake_case ) == 1: return outputs[0] return outputs
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase : Optional[int] = logging.get_logger(__name__) lowercase : Union[str, Any] = {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""} lowercase : Optional[int] = { """vocab_file""": { """junnyu/roformer_chinese_small""": """https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt""", """junnyu/roformer_chinese_base""": """https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt""", """junnyu/roformer_chinese_char_small""": ( """https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt""" ), """junnyu/roformer_chinese_char_base""": ( """https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt""" ), """junnyu/roformer_small_discriminator""": ( """https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt""" ), """junnyu/roformer_small_generator""": ( """https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt""" ), } } lowercase : Optional[int] = { """junnyu/roformer_chinese_small""": 1536, """junnyu/roformer_chinese_base""": 1536, """junnyu/roformer_chinese_char_small""": 512, """junnyu/roformer_chinese_char_base""": 512, """junnyu/roformer_small_discriminator""": 128, """junnyu/roformer_small_generator""": 128, } lowercase : Tuple = { """junnyu/roformer_chinese_small""": {"""do_lower_case""": True}, """junnyu/roformer_chinese_base""": {"""do_lower_case""": True}, """junnyu/roformer_chinese_char_small""": {"""do_lower_case""": True}, """junnyu/roformer_chinese_char_base""": {"""do_lower_case""": True}, """junnyu/roformer_small_discriminator""": {"""do_lower_case""": True}, """junnyu/roformer_small_generator""": {"""do_lower_case""": True}, } class __snake_case ( lowerCAmelCase ): _a : str= VOCAB_FILES_NAMES _a : List[str]= PRETRAINED_VOCAB_FILES_MAP _a : List[str]= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : List[Any]= PRETRAINED_INIT_CONFIGURATION _a : str= RoFormerTokenizer def __init__( self ,snake_case=None ,snake_case=None ,snake_case=True ,snake_case="[UNK]" ,snake_case="[SEP]" ,snake_case="[PAD]" ,snake_case="[CLS]" ,snake_case="[MASK]" ,snake_case=True ,snake_case=None ,**snake_case ,): '''simple docstring''' super().__init__( snake_case ,tokenizer_file=snake_case ,do_lower_case=snake_case ,unk_token=snake_case ,sep_token=snake_case ,pad_token=snake_case ,cls_token=snake_case ,mask_token=snake_case ,tokenize_chinese_chars=snake_case ,strip_accents=snake_case ,**snake_case ,) lowercase : Optional[int] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" ,snake_case ) != do_lower_case or pre_tok_state.get("""strip_accents""" ,snake_case ) != strip_accents ): lowercase : List[str] = getattr(snake_case ,pre_tok_state.pop("""type""" ) ) lowercase : Union[str, Any] = do_lower_case lowercase : int = strip_accents lowercase : Tuple = pre_tok_class(**snake_case ) lowercase : List[str] = do_lower_case def __getstate__( self ): '''simple docstring''' lowercase : Tuple = self.__dict__.copy() lowercase : Tuple = BertPreTokenizer() return state def __setstate__( self ,snake_case ): '''simple docstring''' lowercase : Any = d lowercase : Dict = self.__dict__["""_tokenizer"""].get_vocab() lowercase : Tuple = PreTokenizer.custom(JiebaPreTokenizer(snake_case ) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = [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 _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Union[str, Any] = [self.sep_token_id] lowercase : 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 ) * [0] + len(token_ids_a + sep ) * [1] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Union[str, Any] = self._tokenizer.model.save(snake_case ,name=snake_case ) return tuple(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case=None ,snake_case=False ,**snake_case ,): '''simple docstring''' lowercase : Optional[int] = BertPreTokenizer() return super().save_pretrained(snake_case ,snake_case ,snake_case ,snake_case ,**snake_case )
20
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 MobileNetVaImageProcessor class __snake_case ( unittest.TestCase ): def __init__( self ,snake_case ,snake_case=7 ,snake_case=3 ,snake_case=18 ,snake_case=30 ,snake_case=400 ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=None ,): '''simple docstring''' lowercase : Dict = size if size is not None else {"""shortest_edge""": 20} lowercase : Union[str, Any] = crop_size if crop_size is not None else {"""height""": 18, """width""": 18} lowercase : str = parent lowercase : int = batch_size lowercase : str = num_channels lowercase : int = image_size lowercase : List[str] = min_resolution lowercase : str = max_resolution lowercase : Dict = do_resize lowercase : Dict = size lowercase : Dict = do_center_crop lowercase : str = crop_size def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, } @require_torch @require_vision class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Any= MobileNetVaImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = MobileNetVaImageProcessingTester(self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case ,"""do_resize""" ) ) self.assertTrue(hasattr(snake_case ,"""size""" ) ) self.assertTrue(hasattr(snake_case ,"""do_center_crop""" ) ) self.assertTrue(hasattr(snake_case ,"""crop_size""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 20} ) self.assertEqual(image_processor.crop_size ,{"""height""": 18, """width""": 18} ) lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 ,crop_size=84 ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 42} ) self.assertEqual(image_processor.crop_size ,{"""height""": 84, """width""": 84} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowercase : str = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,Image.Image ) # Test not batched input lowercase : Dict = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : Tuple = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,numpify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,np.ndarray ) # Test not batched input lowercase : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,torchify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,torch.Tensor ) # Test not batched input lowercase : Optional[int] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,)
20
1
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 _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = tempfile.mkdtemp() # fmt: off lowercase : int = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""] # fmt: on lowercase : List[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] ) ) lowercase : Dict = { """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], } lowercase : Dict = os.path.join(self.tmpdirname ,snake_case ) with open(self.image_processor_file ,"""w""" ,encoding="""utf-8""" ) as fp: json.dump(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return BertTokenizer.from_pretrained(self.tmpdirname ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return ViTImageProcessor.from_pretrained(self.tmpdirname ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )] lowercase : Optional[Any] = [Image.fromarray(np.moveaxis(snake_case ,0 ,-1 ) ) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.get_tokenizer() lowercase : Optional[int] = self.get_image_processor() lowercase : Any = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) processor.save_pretrained(self.tmpdirname ) lowercase : Optional[int] = 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 ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = VisionTextDualEncoderProcessor( tokenizer=self.get_tokenizer() ,image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) lowercase : Tuple = self.get_tokenizer(bos_token="""(BOS)""" ,eos_token="""(EOS)""" ) lowercase : Tuple = self.get_image_processor(do_normalize=snake_case ,padding_value=1.0 ) lowercase : Dict = VisionTextDualEncoderProcessor.from_pretrained( self.tmpdirname ,bos_token="""(BOS)""" ,eos_token="""(EOS)""" ,do_normalize=snake_case ,padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer ,(BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.get_image_processor() lowercase : List[str] = self.get_tokenizer() lowercase : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Optional[int] = self.prepare_image_inputs() lowercase : int = image_processor(snake_case ,return_tensors="""np""" ) lowercase : Dict = processor(images=snake_case ,return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_image_processor() lowercase : str = self.get_tokenizer() lowercase : str = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : int = """lower newer""" lowercase : Tuple = processor(text=snake_case ) lowercase : Optional[int] = tokenizer(snake_case ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] ,encoded_processor[key] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.get_image_processor() lowercase : int = self.get_tokenizer() lowercase : List[str] = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : str = """lower newer""" lowercase : Tuple = self.prepare_image_inputs() lowercase : Optional[int] = processor(text=snake_case ,images=snake_case ) 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(snake_case ): processor() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.get_image_processor() lowercase : Optional[int] = self.get_tokenizer() lowercase : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Optional[int] = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] lowercase : List[str] = processor.batch_decode(snake_case ) lowercase : str = tokenizer.batch_decode(snake_case ) self.assertListEqual(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.get_image_processor() lowercase : Optional[Any] = self.get_tokenizer() lowercase : Any = VisionTextDualEncoderProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : int = """lower newer""" lowercase : int = self.prepare_image_inputs() lowercase : Optional[int] = processor(text=snake_case ,images=snake_case ) self.assertListEqual(list(inputs.keys() ) ,processor.model_input_names )
20
from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef import datasets lowercase : str = """\ @inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019} } """ lowercase : Dict = """\ GLUE, the General Language Understanding Evaluation benchmark (https://gluebenchmark.com/) is a collection of resources for training, evaluating, and analyzing natural language understanding systems. """ lowercase : int = """ Compute GLUE evaluation metric associated to each GLUE dataset. Args: predictions: list of predictions to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. Returns: depending on the GLUE subset, one or several of: \"accuracy\": Accuracy \"f1\": F1 score \"pearson\": Pearson Correlation \"spearmanr\": Spearman Correlation \"matthews_correlation\": Matthew Correlation Examples: >>> glue_metric = datasets.load_metric('glue', 'sst2') # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"] >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> glue_metric = datasets.load_metric('glue', 'mrpc') # 'mrpc' or 'qqp' >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> glue_metric = datasets.load_metric('glue', 'stsb') >>> references = [0., 1., 2., 3., 4., 5.] >>> predictions = [0., 1., 2., 3., 4., 5.] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)}) {'pearson': 1.0, 'spearmanr': 1.0} >>> glue_metric = datasets.load_metric('glue', 'cola') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: return float((preds == labels).mean() ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = simple_accuracy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = float(fa_score(y_true=SCREAMING_SNAKE_CASE__ , y_pred=SCREAMING_SNAKE_CASE__ ) ) return { "accuracy": acc, "f1": fa, } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = float(pearsonr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) lowercase : Dict = float(spearmanr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) return { "pearson": pearson_corr, "spearmanr": spearman_corr, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config_name not in [ "sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans", ]: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), } ) ,codebase_urls=[] ,reference_urls=[] ,format="""numpy""" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if self.config_name == "cola": return {"matthews_correlation": matthews_corrcoef(snake_case ,snake_case )} elif self.config_name == "stsb": return pearson_and_spearman(snake_case ,snake_case ) elif self.config_name in ["mrpc", "qqp"]: return acc_and_fa(snake_case ,snake_case ) elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]: return {"accuracy": simple_accuracy(snake_case ,snake_case )} else: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" )
20
1
import time import warnings from abc import ABC from copy import deepcopy from typing import Optional import torch from ..utils import add_start_docstrings, logging lowercase : Optional[int] = logging.get_logger(__name__) lowercase : Dict = R""" Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) scores (`torch.FloatTensor` of shape `(batch_size, config.vocab_size)`): Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax or scores for each vocabulary token after SoftMax. kwargs (`Dict[str, Any]`, *optional*): Additional stopping criteria specific kwargs. Return: `bool`. `False` indicates we should continue, `True` indicates we should stop. """ class __snake_case ( lowerCAmelCase ): @add_start_docstrings(snake_case ) def __call__( self ,snake_case ,snake_case ,**snake_case ): '''simple docstring''' raise NotImplementedError("""StoppingCriteria needs to be subclassed""" ) class __snake_case ( lowerCAmelCase ): def __init__( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Optional[int] = max_length lowercase : Union[str, Any] = max_position_embeddings @add_start_docstrings(snake_case ) def __call__( self ,snake_case ,snake_case ,**snake_case ): '''simple docstring''' lowercase : Optional[int] = input_ids.shape[-1] lowercase : Dict = cur_len >= self.max_length if self.max_position_embeddings is not None and not is_done and cur_len >= self.max_position_embeddings: logger.warning_once( """This is a friendly reminder - the current text generation call will exceed the model's predefined """ f"maximum length ({self.max_position_embeddings}). Depending on the model, you may observe " """exceptions, performance degradation, or nothing at all.""" ) return is_done class __snake_case ( lowerCAmelCase ): def __init__( self ,snake_case ,snake_case ): '''simple docstring''' warnings.warn( """The class `MaxNewTokensCriteria` is deprecated. """ f"Please use `MaxLengthCriteria(max_length={start_length + max_new_tokens})` " """with `max_length = start_length + max_new_tokens` instead.""" ,snake_case ,) lowercase : Dict = start_length lowercase : Any = max_new_tokens lowercase : List[Any] = start_length + max_new_tokens @add_start_docstrings(snake_case ) def __call__( self ,snake_case ,snake_case ,**snake_case ): '''simple docstring''' return input_ids.shape[-1] >= self.max_length class __snake_case ( lowerCAmelCase ): def __init__( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : List[Any] = max_time lowercase : Optional[Any] = time.time() if initial_timestamp is None else initial_timestamp @add_start_docstrings(snake_case ) def __call__( self ,snake_case ,snake_case ,**snake_case ): '''simple docstring''' return time.time() - self.initial_timestamp > self.max_time class __snake_case ( lowerCAmelCase ): @add_start_docstrings(snake_case ) def __call__( self ,snake_case ,snake_case ,**snake_case ): '''simple docstring''' return any(criteria(snake_case ,snake_case ) for criteria in self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for stopping_criterium in self: if isinstance(snake_case ,snake_case ): return stopping_criterium.max_length elif isinstance(snake_case ,snake_case ): return stopping_criterium.max_length return None def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> StoppingCriteriaList: lowercase : str = stopping_criteria.max_length lowercase : int = deepcopy(SCREAMING_SNAKE_CASE__ ) if stopping_max_length is not None and stopping_max_length != max_length: warnings.warn("""You set different `max_length` for stopping criteria and `max_length` parameter""" , SCREAMING_SNAKE_CASE__ ) elif stopping_max_length is None: new_stopping_criteria.append(MaxLengthCriteria(max_length=SCREAMING_SNAKE_CASE__ ) ) return new_stopping_criteria
20
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
1
import numpy as np from matplotlib import pyplot as plt from sklearn.datasets import load_iris from sklearn.metrics import ConfusionMatrixDisplay from sklearn.model_selection import train_test_split from xgboost import XGBClassifier def _snake_case( SCREAMING_SNAKE_CASE__ ) -> tuple: return (data["data"], data["target"]) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> XGBClassifier: lowercase : Tuple = XGBClassifier() classifier.fit(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return classifier def _snake_case( ) -> None: lowercase : Optional[Any] = load_iris() lowercase , lowercase : Tuple = data_handling(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase , lowercase : Tuple = train_test_split( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , test_size=0.25 ) lowercase : Union[str, Any] = iris["""target_names"""] # Create an XGBoost Classifier from the training data lowercase : Dict = xgboost(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) # Display the confusion matrix of the classifier with both training and test sets ConfusionMatrixDisplay.from_estimator( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , display_labels=SCREAMING_SNAKE_CASE__ , cmap="""Blues""" , normalize="""true""" , ) plt.title("""Normalized Confusion Matrix - IRIS Dataset""" ) plt.show() if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
20
from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class __snake_case : _a : int _a : TreeNode | None= None _a : TreeNode | None= None lowercase : Dict = namedtuple("""CoinsDistribResult""", """moves excess""") def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if root is None: return 0 # Validation def count_nodes(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(SCREAMING_SNAKE_CASE__ ) != count_coins(SCREAMING_SNAKE_CASE__ ): raise ValueError("""The nodes number should be same as the number of coins""" ) # Main calculation def get_distrib(SCREAMING_SNAKE_CASE__ ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 , 1 ) lowercase , lowercase : int = get_distrib(node.left ) lowercase , lowercase : List[Any] = get_distrib(node.right ) lowercase : Optional[Any] = 1 - left_distrib_excess lowercase : Union[str, Any] = 1 - right_distrib_excess lowercase : List[Any] = ( left_distrib_moves + right_distrib_moves + abs(SCREAMING_SNAKE_CASE__ ) + abs(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = node.data - coins_to_left - coins_to_right return CoinsDistribResult(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return get_distrib(SCREAMING_SNAKE_CASE__ )[0] if __name__ == "__main__": import doctest doctest.testmod()
20
1
import os import sys import unittest lowercase : Optional[Any] = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, """utils""")) import get_test_info # noqa: E402 from get_test_info import ( # noqa: E402 get_model_to_test_mapping, get_model_to_tester_mapping, get_test_to_tester_mapping, ) lowercase : Optional[int] = os.path.join("""tests""", """models""", """bert""", """test_modeling_bert.py""") lowercase : List[str] = os.path.join("""tests""", """models""", """blip""", """test_modeling_blip.py""") class __snake_case ( unittest.TestCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = get_test_to_tester_mapping(snake_case ) lowercase : Dict = get_test_to_tester_mapping(snake_case ) lowercase : str = {"""BertModelTest""": """BertModelTester"""} lowercase : Dict = { """BlipModelTest""": """BlipModelTester""", """BlipTextImageModelTest""": """BlipTextImageModelsModelTester""", """BlipTextModelTest""": """BlipTextModelTester""", """BlipTextRetrievalModelTest""": """BlipTextRetrievalModelTester""", """BlipVQAModelTest""": """BlipVQAModelTester""", """BlipVisionModelTest""": """BlipVisionModelTester""", } self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case ) self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = get_model_to_test_mapping(snake_case ) lowercase : str = get_model_to_test_mapping(snake_case ) lowercase : List[Any] = { """BertForMaskedLM""": ["""BertModelTest"""], """BertForMultipleChoice""": ["""BertModelTest"""], """BertForNextSentencePrediction""": ["""BertModelTest"""], """BertForPreTraining""": ["""BertModelTest"""], """BertForQuestionAnswering""": ["""BertModelTest"""], """BertForSequenceClassification""": ["""BertModelTest"""], """BertForTokenClassification""": ["""BertModelTest"""], """BertLMHeadModel""": ["""BertModelTest"""], """BertModel""": ["""BertModelTest"""], } lowercase : List[str] = { """BlipForConditionalGeneration""": ["""BlipTextImageModelTest"""], """BlipForImageTextRetrieval""": ["""BlipTextRetrievalModelTest"""], """BlipForQuestionAnswering""": ["""BlipVQAModelTest"""], """BlipModel""": ["""BlipModelTest"""], """BlipTextModel""": ["""BlipTextModelTest"""], """BlipVisionModel""": ["""BlipVisionModelTest"""], } self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case ) self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = get_model_to_tester_mapping(snake_case ) lowercase : Any = get_model_to_tester_mapping(snake_case ) lowercase : List[str] = { """BertForMaskedLM""": ["""BertModelTester"""], """BertForMultipleChoice""": ["""BertModelTester"""], """BertForNextSentencePrediction""": ["""BertModelTester"""], """BertForPreTraining""": ["""BertModelTester"""], """BertForQuestionAnswering""": ["""BertModelTester"""], """BertForSequenceClassification""": ["""BertModelTester"""], """BertForTokenClassification""": ["""BertModelTester"""], """BertLMHeadModel""": ["""BertModelTester"""], """BertModel""": ["""BertModelTester"""], } lowercase : List[Any] = { """BlipForConditionalGeneration""": ["""BlipTextImageModelsModelTester"""], """BlipForImageTextRetrieval""": ["""BlipTextRetrievalModelTester"""], """BlipForQuestionAnswering""": ["""BlipVQAModelTester"""], """BlipModel""": ["""BlipModelTester"""], """BlipTextModel""": ["""BlipTextModelTester"""], """BlipVisionModel""": ["""BlipVisionModelTester"""], } self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case ) self.assertEqual(get_test_info.to_json(snake_case ) ,snake_case )
20
from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline lowercase : Optional[Any] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,**snake_case ): '''simple docstring''' super().__init__(**snake_case ) if self.framework != "pt": raise ValueError(f"The {self.__class__} is only available in PyTorch." ) # No specific FOR_XXX available yet def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : Union[str, Any] = {} if "candidate_labels" in kwargs: lowercase : List[str] = kwargs["""candidate_labels"""] if "hypothesis_template" in kwargs: lowercase : Dict = kwargs["""hypothesis_template"""] return preprocess_params, {}, {} def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case="This is a sound of {}." ): '''simple docstring''' if isinstance(snake_case ,snake_case ): if audio.startswith("""http://""" ) or audio.startswith("""https://""" ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png lowercase : Optional[Any] = requests.get(snake_case ).content else: with open(snake_case ,"""rb""" ) as f: lowercase : Union[str, Any] = f.read() if isinstance(snake_case ,snake_case ): lowercase : int = ffmpeg_read(snake_case ,self.feature_extractor.sampling_rate ) if not isinstance(snake_case ,np.ndarray ): raise ValueError("""We expect a numpy ndarray as input""" ) if len(audio.shape ) != 1: raise ValueError("""We expect a single channel audio input for ZeroShotAudioClassificationPipeline""" ) lowercase : Dict = self.feature_extractor( [audio] ,sampling_rate=self.feature_extractor.sampling_rate ,return_tensors="""pt""" ) lowercase : Tuple = candidate_labels lowercase : Tuple = [hypothesis_template.format(snake_case ) for x in candidate_labels] lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=self.framework ,padding=snake_case ) lowercase : Optional[Any] = [text_inputs] return inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = model_inputs.pop("""candidate_labels""" ) lowercase : Dict = model_inputs.pop("""text_inputs""" ) if isinstance(text_inputs[0] ,snake_case ): lowercase : List[Any] = text_inputs[0] else: # Batching case. lowercase : Dict = text_inputs[0][0] lowercase : Optional[Any] = self.model(**snake_case ,**snake_case ) lowercase : Any = { """candidate_labels""": candidate_labels, """logits""": outputs.logits_per_audio, } return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = model_outputs.pop("""candidate_labels""" ) lowercase : Any = model_outputs["""logits"""][0] if self.framework == "pt": lowercase : Any = logits.softmax(dim=0 ) lowercase : Tuple = probs.tolist() else: raise ValueError("""`tf` framework not supported.""" ) lowercase : Tuple = [ {"""score""": score, """label""": candidate_label} for score, candidate_label in sorted(zip(snake_case ,snake_case ) ,key=lambda snake_case : -x[0] ) ] return result
20
1
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase : Optional[List[str]] = None lowercase : List[Any] = """<""" if sys.byteorder == """little""" else """>""" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase : Dict = [ np.dtype("""|b1"""), np.dtype("""|u1"""), np.dtype("""<u2"""), np.dtype(""">u2"""), np.dtype("""<i2"""), np.dtype(""">i2"""), np.dtype("""<u4"""), np.dtype(""">u4"""), np.dtype("""<i4"""), np.dtype(""">i4"""), np.dtype("""<f4"""), np.dtype(""">f4"""), np.dtype("""<f8"""), np.dtype(""">f8"""), ] @dataclass class __snake_case : _a : bool= True _a : Optional[str]= None # Automatically constructed _a : ClassVar[str]= "PIL.Image.Image" _a : ClassVar[Any]= pa.struct({"bytes": pa.binary(), "path": pa.string()} ) _a : str= field(default="Image" , init=lowerCAmelCase , repr=lowerCAmelCase ) def __call__( self ): '''simple docstring''' return self.pa_type def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(snake_case ,snake_case ): lowercase : int = np.array(snake_case ) if isinstance(snake_case ,snake_case ): return {"path": value, "bytes": None} elif isinstance(snake_case ,snake_case ): return {"path": None, "bytes": value} elif isinstance(snake_case ,np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(snake_case ) elif isinstance(snake_case ,PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(snake_case ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f"An image sample should have one of 'path' or 'bytes' but they are missing or None in {value}." ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: lowercase : List[Any] = {} lowercase , lowercase : Tuple = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f"An image should have one of 'path' or 'bytes' but both are None in {value}." ) else: if is_local_path(snake_case ): lowercase : List[str] = PIL.Image.open(snake_case ) else: lowercase : str = path.split("""::""" )[-1] try: lowercase : Any = string_to_dict(snake_case ,config.HUB_DATASETS_URL )["""repo_id"""] lowercase : str = token_per_repo_id.get(snake_case ) except ValueError: lowercase : Optional[int] = None with xopen(snake_case ,"""rb""" ,use_auth_token=snake_case ) as f: lowercase : Any = BytesIO(f.read() ) lowercase : int = PIL.Image.open(bytes_ ) else: lowercase : str = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if pa.types.is_string(storage.type ): lowercase : Dict = pa.array([None] * len(snake_case ) ,type=pa.binary() ) lowercase : List[str] = pa.StructArray.from_arrays([bytes_array, storage] ,["""bytes""", """path"""] ,mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): lowercase : Union[str, Any] = pa.array([None] * len(snake_case ) ,type=pa.string() ) lowercase : Optional[int] = pa.StructArray.from_arrays([storage, path_array] ,["""bytes""", """path"""] ,mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: lowercase : str = storage.field("""bytes""" ) else: lowercase : Tuple = pa.array([None] * len(snake_case ) ,type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: lowercase : int = storage.field("""path""" ) else: lowercase : Optional[int] = pa.array([None] * len(snake_case ) ,type=pa.string() ) lowercase : Dict = pa.StructArray.from_arrays([bytes_array, path_array] ,["""bytes""", """path"""] ,mask=storage.is_null() ) elif pa.types.is_list(storage.type ): lowercase : List[str] = pa.array( [encode_np_array(np.array(snake_case ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] ,type=pa.binary() ,) lowercase : Any = pa.array([None] * len(snake_case ) ,type=pa.string() ) lowercase : List[Any] = pa.StructArray.from_arrays( [bytes_array, path_array] ,["""bytes""", """path"""] ,mask=bytes_array.is_null() ) return array_cast(snake_case ,self.pa_type ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' @no_op_if_value_is_null def path_to_bytes(snake_case ): with xopen(snake_case ,"""rb""" ) as f: lowercase : int = f.read() return bytes_ lowercase : List[str] = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] ,type=pa.binary() ,) lowercase : str = pa.array( [os.path.basename(snake_case ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] ,type=pa.string() ,) lowercase : List[Any] = pa.StructArray.from_arrays([bytes_array, path_array] ,["""bytes""", """path"""] ,mask=bytes_array.is_null() ) return array_cast(snake_case ,self.pa_type ) def _snake_case( ) -> List[str]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() lowercase : Optional[int] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bytes: lowercase : Optional[Any] = BytesIO() if image.format in list_image_compression_formats(): lowercase : Union[str, Any] = image.format else: lowercase : Dict = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(SCREAMING_SNAKE_CASE__ , format=SCREAMING_SNAKE_CASE__ ) return buffer.getvalue() def _snake_case( SCREAMING_SNAKE_CASE__ ) -> dict: if hasattr(SCREAMING_SNAKE_CASE__ , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(SCREAMING_SNAKE_CASE__ )} def _snake_case( SCREAMING_SNAKE_CASE__ ) -> dict: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) lowercase : Optional[int] = array.dtype lowercase : Union[str, Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER lowercase : Tuple = dtype.kind lowercase : Any = dtype.itemsize lowercase : Any = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: lowercase : Optional[Any] = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( f"Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays." ) if dtype is not dest_dtype: warnings.warn(f"Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'" ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: lowercase : Dict = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: lowercase : Optional[int] = dtype_byteorder + dtype_kind + str(SCREAMING_SNAKE_CASE__ ) lowercase : int = np.dtype(SCREAMING_SNAKE_CASE__ ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(f"Downcasting array dtype {dtype} to {dest_dtype} to be compatible with 'Pillow'" ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( f"Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}" ) lowercase : Tuple = PIL.Image.fromarray(array.astype(SCREAMING_SNAKE_CASE__ ) ) return {"path": None, "bytes": image_to_bytes(SCREAMING_SNAKE_CASE__ )} def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[dict]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: lowercase , lowercase : Optional[int] = first_non_null_value(SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(SCREAMING_SNAKE_CASE__ , np.ndarray ): lowercase : str = no_op_if_value_is_null(SCREAMING_SNAKE_CASE__ ) return [obj_to_image_dict_func(SCREAMING_SNAKE_CASE__ ) for obj in objs] elif isinstance(SCREAMING_SNAKE_CASE__ , PIL.Image.Image ): lowercase : List[str] = no_op_if_value_is_null(SCREAMING_SNAKE_CASE__ ) return [obj_to_image_dict_func(SCREAMING_SNAKE_CASE__ ) for obj in objs] else: return objs else: return objs
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def _snake_case( *SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=2 ) -> Optional[Any]: from .. import __version__ lowercase : int = take_from lowercase : Tuple = () if not isinstance(args[0] , SCREAMING_SNAKE_CASE__ ): lowercase : Dict = (args,) for attribute, version_name, message in args: if version.parse(version.parse(SCREAMING_SNAKE_CASE__ ).base_version ) >= version.parse(SCREAMING_SNAKE_CASE__ ): raise ValueError( f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'" f" version {__version__} is >= {version_name}" ) lowercase : int = None if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(SCREAMING_SNAKE_CASE__ ),) lowercase : Union[str, Any] = f"The `{attribute}` argument is deprecated and will be removed in version {version_name}." elif hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): values += (getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ),) lowercase : int = f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}." elif deprecated_kwargs is None: lowercase : Dict = f"`{attribute}` is deprecated and will be removed in version {version_name}." if warning is not None: lowercase : Dict = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , SCREAMING_SNAKE_CASE__ , stacklevel=SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and len(SCREAMING_SNAKE_CASE__ ) > 0: lowercase : str = inspect.getouterframes(inspect.currentframe() )[1] lowercase : List[str] = call_frame.filename lowercase : Tuple = call_frame.lineno lowercase : List[str] = call_frame.function lowercase , lowercase : Optional[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: return elif len(SCREAMING_SNAKE_CASE__ ) == 1: return values[0] return values
20
1
import argparse import re import requests import torch # git clone https://github.com/salesforce/BLIP.git from models.blip import blip_decoder from models.blip_itm import blip_itm from models.blip_vqa import blip_vqa from PIL import Image from torchvision import transforms from torchvision.transforms.functional import InterpolationMode from transformers import ( BertTokenizer, BlipConfig, BlipForConditionalGeneration, BlipForImageTextRetrieval, BlipForQuestionAnswering, ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : List[Any] = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg""" lowercase : Dict = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ).convert("""RGB""" ) lowercase : int = transforms.Compose( [ transforms.Resize((image_size, image_size) , interpolation=InterpolationMode.BICUBIC ), transforms.ToTensor(), transforms.Normalize((0.48145466, 0.4578275, 0.40821073) , (0.26862954, 0.26130258, 0.27577711) ), ] ) lowercase : Optional[Any] = transform(SCREAMING_SNAKE_CASE__ ).unsqueeze(0 ).to(SCREAMING_SNAKE_CASE__ ) return image def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if "visual_encoder" in key: lowercase : Optional[int] = re.sub("""visual_encoder*""" , """vision_model.encoder""" , SCREAMING_SNAKE_CASE__ ) if "blocks" in key: lowercase : Any = re.sub(R"""blocks""" , """layers""" , SCREAMING_SNAKE_CASE__ ) if "attn" in key: lowercase : Dict = re.sub(R"""attn""" , """self_attn""" , SCREAMING_SNAKE_CASE__ ) if "norm1" in key: lowercase : Any = re.sub(R"""norm1""" , """layer_norm1""" , SCREAMING_SNAKE_CASE__ ) if "norm2" in key: lowercase : str = re.sub(R"""norm2""" , """layer_norm2""" , SCREAMING_SNAKE_CASE__ ) if "encoder.norm" in key: lowercase : Union[str, Any] = re.sub(R"""encoder.norm""" , """post_layernorm""" , SCREAMING_SNAKE_CASE__ ) if "encoder.patch_embed.proj" in key: lowercase : Union[str, Any] = re.sub(R"""encoder.patch_embed.proj""" , """embeddings.patch_embedding""" , SCREAMING_SNAKE_CASE__ ) if "encoder.pos_embed" in key: lowercase : Tuple = re.sub(R"""encoder.pos_embed""" , """embeddings.position_embedding""" , SCREAMING_SNAKE_CASE__ ) if "encoder.cls_token" in key: lowercase : Dict = re.sub(R"""encoder.cls_token""" , """embeddings.class_embedding""" , SCREAMING_SNAKE_CASE__ ) if "self_attn" in key: lowercase : Tuple = re.sub(R"""self_attn.proj""" , """self_attn.projection""" , SCREAMING_SNAKE_CASE__ ) return key @torch.no_grad() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> int: if config_path is not None: lowercase : Dict = BlipConfig.from_pretrained(SCREAMING_SNAKE_CASE__ ) else: lowercase : Tuple = BlipConfig(projection_dim=512 , text_config={} , vision_config={} ) lowercase : List[str] = BlipForConditionalGeneration(SCREAMING_SNAKE_CASE__ ).eval() lowercase : Optional[int] = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth""" lowercase : Tuple = blip_decoder(pretrained=SCREAMING_SNAKE_CASE__ , image_size=384 , vit="""base""" ) lowercase : Optional[int] = pt_model.eval() lowercase : Union[str, Any] = pt_model.state_dict() for key in modified_state_dict.copy(): lowercase : List[Any] = modified_state_dict.pop(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = rename_key(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = value hf_model.load_state_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = 384 lowercase : Union[str, Any] = load_demo_image(image_size=SCREAMING_SNAKE_CASE__ , device="""cpu""" ) lowercase : Union[str, Any] = BertTokenizer.from_pretrained("""bert-base-uncased""" ) lowercase : str = tokenizer(["""a picture of"""] ).input_ids lowercase : Any = hf_model.generate(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert out[0].tolist() == [30_522, 1_037, 3_861, 1_997, 1_037, 2_450, 3_564, 2_006, 1_996, 3_509, 2_007, 2_014, 3_899, 102] lowercase : List[str] = hf_model.generate(SCREAMING_SNAKE_CASE__ ) assert out[0].tolist() == [30_522, 1_037, 2_450, 3_564, 2_006, 1_996, 3_509, 2_007, 2_014, 3_899, 102] if pytorch_dump_folder_path is not None: hf_model.save_pretrained(SCREAMING_SNAKE_CASE__ ) # model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_vqa.pth' lowercase : Dict = ( """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth""" ) lowercase : Dict = blip_vqa(pretrained=SCREAMING_SNAKE_CASE__ , image_size=SCREAMING_SNAKE_CASE__ , vit="""base""" ) vqa_model.eval() lowercase : str = vqa_model.state_dict() for key in modified_state_dict.copy(): lowercase : Any = modified_state_dict.pop(SCREAMING_SNAKE_CASE__ ) lowercase : int = rename_key(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = value lowercase : Dict = BlipForQuestionAnswering(SCREAMING_SNAKE_CASE__ ) hf_vqa_model.load_state_dict(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = ["""How many dogs are in this image?"""] lowercase : Any = tokenizer(SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ).input_ids lowercase : int = hf_vqa_model.generate(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) print(tokenizer.decode(answer[0] ) ) assert tokenizer.decode(answer[0] ) == "[UNK] 1 [SEP]" if pytorch_dump_folder_path is not None: hf_vqa_model.save_pretrained(pytorch_dump_folder_path + """_vqa""" ) lowercase : Any = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_retrieval_coco.pth""" lowercase : Dict = blip_itm(pretrained=SCREAMING_SNAKE_CASE__ , image_size=SCREAMING_SNAKE_CASE__ , vit="""base""" ) itm_model.eval() lowercase : int = itm_model.state_dict() for key in modified_state_dict.copy(): lowercase : List[str] = modified_state_dict.pop(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = rename_key(SCREAMING_SNAKE_CASE__ ) lowercase : int = value lowercase : Optional[int] = BlipForImageTextRetrieval(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = ["""A picture of a woman with a dog sitting in a beach"""] lowercase : Tuple = tokenizer( SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" , padding="""max_length""" , truncation=SCREAMING_SNAKE_CASE__ , max_length=35 , ).input_ids hf_itm_model.load_state_dict(SCREAMING_SNAKE_CASE__ ) hf_itm_model.eval() lowercase : Union[str, Any] = hf_itm_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , use_itm_head=SCREAMING_SNAKE_CASE__ ) lowercase : Any = hf_itm_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , use_itm_head=SCREAMING_SNAKE_CASE__ ) assert out[0].item() == 0.2110687494277954 assert torch.nn.functional.softmax(out_itm[0] , dim=1 )[:, 1].item() == 0.45698845386505127 if pytorch_dump_folder_path is not None: hf_itm_model.save_pretrained(pytorch_dump_folder_path + """_itm""" ) if __name__ == "__main__": lowercase : Optional[int] = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") lowercase : int = parser.parse_args() convert_blip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
20
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: if index == r: for j in range(SCREAMING_SNAKE_CASE__ ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location lowercase : Tuple = arr[i] combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 , SCREAMING_SNAKE_CASE__ , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # A temporary array to store all combination one by one lowercase : Optional[int] = [0] * r # Print all combination using temporary array 'data[]' combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , 0 , SCREAMING_SNAKE_CASE__ , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase : int = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
1
from math import factorial class __snake_case : def __init__( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = real if isinstance(snake_case ,snake_case ): lowercase : Any = [1] * rank else: lowercase : Optional[Any] = rank def __repr__( self ): '''simple docstring''' return ( f"{self.real}+" f"{'+'.join(str(snake_case )+'E'+str(n+1 )for n,dual in enumerate(self.duals ) )}" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.duals.copy() while cur[-1] == 0: cur.pop(-1 ) return Dual(self.real ,snake_case ) def __add__( self ,snake_case ): '''simple docstring''' if not isinstance(snake_case ,snake_case ): return Dual(self.real + other ,self.duals ) lowercase : Optional[int] = self.duals.copy() lowercase : Optional[Any] = other.duals.copy() if len(snake_case ) > len(snake_case ): o_dual.extend([1] * (len(snake_case ) - len(snake_case )) ) elif len(snake_case ) < len(snake_case ): s_dual.extend([1] * (len(snake_case ) - len(snake_case )) ) lowercase : Dict = [] for i in range(len(snake_case ) ): new_duals.append(s_dual[i] + o_dual[i] ) return Dual(self.real + other.real ,snake_case ) _a : Union[str, Any]= __add__ def __sub__( self ,snake_case ): '''simple docstring''' return self + other * -1 def __mul__( self ,snake_case ): '''simple docstring''' if not isinstance(snake_case ,snake_case ): lowercase : str = [] for i in self.duals: new_duals.append(i * other ) return Dual(self.real * other ,snake_case ) lowercase : Union[str, Any] = [0] * (len(self.duals ) + len(other.duals ) + 1) for i, item in enumerate(self.duals ): for j, jtem in enumerate(other.duals ): new_duals[i + j + 1] += item * jtem for k in range(len(self.duals ) ): new_duals[k] += self.duals[k] * other.real for index in range(len(other.duals ) ): new_duals[index] += other.duals[index] * self.real return Dual(self.real * other.real ,snake_case ) _a : int= __mul__ def __truediv__( self ,snake_case ): '''simple docstring''' if not isinstance(snake_case ,snake_case ): lowercase : Union[str, Any] = [] for i in self.duals: new_duals.append(i / other ) return Dual(self.real / other ,snake_case ) raise ValueError def __floordiv__( self ,snake_case ): '''simple docstring''' if not isinstance(snake_case ,snake_case ): lowercase : List[Any] = [] for i in self.duals: new_duals.append(i // other ) return Dual(self.real // other ,snake_case ) raise ValueError def __pow__( self ,snake_case ): '''simple docstring''' if n < 0 or isinstance(snake_case ,snake_case ): raise ValueError("""power must be a positive integer""" ) if n == 0: return 1 if n == 1: return self lowercase : str = self for _ in range(n - 1 ): x *= self return x def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: if not callable(SCREAMING_SNAKE_CASE__ ): raise ValueError("""differentiate() requires a function as input for func""" ) if not isinstance(SCREAMING_SNAKE_CASE__ , (float, int) ): raise ValueError("""differentiate() requires a float as input for position""" ) if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise ValueError("""differentiate() requires an int as input for order""" ) lowercase : List[Any] = Dual(SCREAMING_SNAKE_CASE__ , 1 ) lowercase : List[Any] = func(SCREAMING_SNAKE_CASE__ ) if order == 0: return result.real return result.duals[order - 1] * factorial(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": import doctest doctest.testmod() def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: return y**2 * y**4 print(differentiate(f, 9, 2))
20
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : Optional[Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): lowercase : Any = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ , keep_in_memory=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : int = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} lowercase : str = features.copy() if features else default_expected_features lowercase : Optional[Any] = ( Features({feature: Value(SCREAMING_SNAKE_CASE__ ) for feature, dtype in features.items()} ) if features is not None else None ) lowercase : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__ ) ) as con: lowercase : Optional[int] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = tmp_path / """cache""" lowercase : int = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() lowercase : List[str] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Dict = tmp_path / """cache""" lowercase : List[str] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() lowercase : Optional[int] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : str = tmp_path / """cache""" lowercase : Optional[int] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : Optional[Any] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() with pytest.raises(SCREAMING_SNAKE_CASE__ ): SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
1
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 ( lowerCAmelCase , unittest.TestCase ): _a : Optional[int]= ProphetNetTokenizer _a : str= False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() lowercase : Optional[int] = [ """[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] lowercase : Union[str, 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 _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = """UNwant\u00E9d,running""" lowercase : Dict = """unwanted, running""" return input_text, output_text def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.tokenizer_class(self.vocab_file ) lowercase : List[Any] = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(snake_case ,["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case ) ,[9, 6, 7, 12, 10, 11] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = BasicTokenizer() self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" ) ,["""ah""", """\u535A""", """\u63A8""", """zz"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = BasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) ,["""hello""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = BasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hällo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""h\u00E9llo"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = BasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = BasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = BasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = BasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = BasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = BasicTokenizer(do_lower_case=snake_case ,never_split=["""[UNK]"""] ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? [UNK]""" ) ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""] lowercase : Optional[Any] = {} for i, token in enumerate(snake_case ): lowercase : Union[str, Any] = i lowercase : List[str] = WordpieceTokenizer(vocab=snake_case ,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 _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased""" ) lowercase : Tuple = ["""A long paragraph for summarization.""", """Another paragraph for summarization."""] lowercase : Union[str, Any] = [1037, 2146, 20423, 2005, 7680, 7849, 3989, 1012, 102] lowercase : Optional[Any] = tokenizer(snake_case ,padding=snake_case ,return_tensors="""pt""" ) self.assertIsInstance(snake_case ,snake_case ) lowercase : Optional[int] = list(batch.input_ids.numpy()[0] ) self.assertListEqual(snake_case ,snake_case ) self.assertEqual((2, 9) ,batch.input_ids.shape ) self.assertEqual((2, 9) ,batch.attention_mask.shape ) def _SCREAMING_SNAKE_CASE ( self ): '''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 _SCREAMING_SNAKE_CASE ( self ): '''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 _SCREAMING_SNAKE_CASE ( self ): '''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 _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased""" ) lowercase : List[Any] = tokenizer.encode("""sequence builders""" ,add_special_tokens=snake_case ) lowercase : Optional[int] = tokenizer.encode("""multi-sequence build""" ,add_special_tokens=snake_case ) lowercase : Optional[Any] = tokenizer.build_inputs_with_special_tokens(snake_case ) lowercase : Tuple = tokenizer.build_inputs_with_special_tokens(snake_case ,snake_case ) assert encoded_sentence == text + [102] assert encoded_pair == text + [102] + text_a + [102]
20
import os import numpy import onnx def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : int = a.name lowercase : Any = b.name lowercase : Optional[Any] = """""" lowercase : Dict = """""" lowercase : int = a == b lowercase : int = name_a lowercase : List[str] = name_b return res def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) _graph_replace_input_with(node_proto.attribute[1].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for n in graph_proto.node: _node_replace_input_with(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Any = list(model.graph.initializer ) lowercase : Dict = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i lowercase : Union[str, Any] = inits[i].name lowercase : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Union[str, Any] = os.path.dirname(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = os.path.basename(SCREAMING_SNAKE_CASE__ ) lowercase : str = onnx.load(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) lowercase : List[str] = list(model.graph.initializer ) lowercase : Tuple = set() lowercase : int = {} lowercase : Optional[Any] = [] lowercase : Dict = 0 for i in range(len(SCREAMING_SNAKE_CASE__ ) ): if i in dup_set: continue for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(SCREAMING_SNAKE_CASE__ ) dup_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : int = inits[j].data_type lowercase : Optional[int] = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 11: mem_size *= 8 else: print("""unexpected data type: """ , SCREAMING_SNAKE_CASE__ ) total_reduced_size += mem_size lowercase : Tuple = inits[i].name lowercase : int = inits[j].name if name_i in dup_map: dup_map[name_i].append(SCREAMING_SNAKE_CASE__ ) else: lowercase : List[str] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_024 / 1_024 / 1_024 , """GB""" ) lowercase : str = sorted(SCREAMING_SNAKE_CASE__ ) _remove_dup_initializers_from_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = """optimized_""" + model_file_name lowercase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) onnx.save(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return new_model
20
1
import math def _snake_case( SCREAMING_SNAKE_CASE__ = 100 ) -> int: lowercase : Union[str, Any] = sum(i * i for i in range(1 , n + 1 ) ) lowercase : Tuple = int(math.pow(sum(range(1 , n + 1 ) ) , 2 ) ) return square_of_sum - sum_of_squares if __name__ == "__main__": print(F'''{solution() = }''')
20
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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = [] embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight", f"stage{idx}.patch_embed.proj.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias", f"stage{idx}.patch_embed.proj.bias", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight", f"stage{idx}.patch_embed.norm.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias", f"stage{idx}.patch_embed.norm.bias", ) ) return embed def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Optional[Any] = [] 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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Optional[Any] = [] token.append((f"cvt.encoder.stages.{idx}.cls_token", """stage2.cls_token""") ) return token def _snake_case( ) -> Dict: lowercase : Optional[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 _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = """imagenet-1k-id2label.json""" lowercase : List[str] = 1_000 lowercase : int = """huggingface/label-files""" lowercase : Union[str, Any] = num_labels lowercase : Optional[Any] = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) ) , """r""" ) ) lowercase : List[Any] = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Dict = idalabel lowercase : List[str] = {v: k for k, v in idalabel.items()} lowercase : List[str] = CvtConfig(num_labels=SCREAMING_SNAKE_CASE__ , idalabel=SCREAMING_SNAKE_CASE__ , labelaid=SCREAMING_SNAKE_CASE__ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": lowercase : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": lowercase : Dict = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: lowercase : int = [2, 2, 20] lowercase : Optional[int] = [3, 12, 16] lowercase : str = [192, 768, 1_024] lowercase : Union[str, Any] = CvtForImageClassification(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) lowercase : Optional[Any] = image_size lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ , map_location=torch.device("""cpu""" ) ) lowercase : Optional[Any] = OrderedDict() lowercase : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: lowercase : Optional[Any] = list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__ ) lowercase : str = list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__ ) for cnt in range(config.depth[idx] ): lowercase : List[str] = list_of_state_dict + attention(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = list_of_state_dict + final() for gg in list_of_state_dict: print(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=384, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : Optional[int] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
1
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "microsoft/speecht5_tts" _a : Tuple= ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) _a : Dict= "text_reader" _a : Optional[Any]= SpeechTaProcessor _a : Tuple= SpeechTaForTextToSpeech _a : Optional[int]= SpeechTaHifiGan _a : Union[str, Any]= ["text"] _a : Optional[int]= ["audio"] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.post_processor is None: lowercase : Any = """microsoft/speecht5_hifigan""" super().setup() def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : int = self.pre_processor(text=snake_case ,return_tensors="""pt""" ,truncation=snake_case ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) lowercase : Tuple = load_dataset("""Matthijs/cmu-arctic-xvectors""" ,split="""validation""" ) lowercase : List[str] = torch.tensor(embeddings_dataset[7305]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.model.generate_speech(**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.post_processor(snake_case ).cpu().detach()
20
1
class __snake_case : def __init__( self ): '''simple docstring''' lowercase : Optional[Any] = """""" lowercase : Tuple = """""" lowercase : List[Any] = [] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if m == -1: return n + 1 elif n == -1: return m + 1 elif self.dp[m][n] > -1: return self.dp[m][n] else: if self.worda[m] == self.worda[n]: lowercase : List[str] = self.__min_dist_top_down_dp(m - 1 ,n - 1 ) else: lowercase : Any = self.__min_dist_top_down_dp(snake_case ,n - 1 ) lowercase : List[Any] = self.__min_dist_top_down_dp(m - 1 ,snake_case ) lowercase : Tuple = self.__min_dist_top_down_dp(m - 1 ,n - 1 ) lowercase : Union[str, Any] = 1 + min(snake_case ,snake_case ,snake_case ) return self.dp[m][n] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = worda lowercase : Dict = worda lowercase : str = [[-1 for _ in range(len(snake_case ) )] for _ in range(len(snake_case ) )] return self.__min_dist_top_down_dp(len(snake_case ) - 1 ,len(snake_case ) - 1 ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = worda lowercase : int = worda lowercase : List[Any] = len(snake_case ) lowercase : Tuple = len(snake_case ) lowercase : str = [[0 for _ in range(n + 1 )] for _ in range(m + 1 )] for i in range(m + 1 ): for j in range(n + 1 ): if i == 0: # first string is empty lowercase : str = j elif j == 0: # second string is empty lowercase : Dict = i elif worda[i - 1] == worda[j - 1]: # last characters are equal lowercase : str = self.dp[i - 1][j - 1] else: lowercase : Dict = self.dp[i][j - 1] lowercase : Optional[int] = self.dp[i - 1][j] lowercase : Dict = self.dp[i - 1][j - 1] lowercase : int = 1 + min(snake_case ,snake_case ,snake_case ) return self.dp[m][n] if __name__ == "__main__": lowercase : Union[str, Any] = EditDistance() print("""****************** Testing Edit Distance DP Algorithm ******************""") print() lowercase : Optional[Any] = input("""Enter the first string: """).strip() lowercase : str = input("""Enter the second string: """).strip() print() print(F'''The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}''') print(F'''The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}''') print() print("""*************** End of Testing Edit Distance DP Algorithm ***************""")
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : str = { """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""], """convert_funnel_original_tf_checkpoint_to_pytorch""": [], """tokenization_funnel""": ["""FunnelTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Tuple = ["""FunnelTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = [ """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """FunnelBaseModel""", """FunnelForMaskedLM""", """FunnelForMultipleChoice""", """FunnelForPreTraining""", """FunnelForQuestionAnswering""", """FunnelForSequenceClassification""", """FunnelForTokenClassification""", """FunnelModel""", """FunnelPreTrainedModel""", """load_tf_weights_in_funnel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFFunnelBaseModel""", """TFFunnelForMaskedLM""", """TFFunnelForMultipleChoice""", """TFFunnelForPreTraining""", """TFFunnelForQuestionAnswering""", """TFFunnelForSequenceClassification""", """TFFunnelForTokenClassification""", """TFFunnelModel""", """TFFunnelPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations from math import pow, sqrt def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> dict[str, float]: if (resistance, reactance, impedance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if resistance == 0: return {"resistance": sqrt(pow(SCREAMING_SNAKE_CASE__ , 2 ) - pow(SCREAMING_SNAKE_CASE__ , 2 ) )} elif reactance == 0: return {"reactance": sqrt(pow(SCREAMING_SNAKE_CASE__ , 2 ) - pow(SCREAMING_SNAKE_CASE__ , 2 ) )} elif impedance == 0: return {"impedance": sqrt(pow(SCREAMING_SNAKE_CASE__ , 2 ) + pow(SCREAMING_SNAKE_CASE__ , 2 ) )} else: raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Any: lowercase : Dict = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } lowercase , lowercase : Optional[Any] = input_paths_and_base_extractors[compression_format] if input_path is None: lowercase : Dict = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) assert base_extractor.is_extractable(SCREAMING_SNAKE_CASE__ ) lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : str = file_path.read_text(encoding="""utf-8""" ) else: lowercase : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) lowercase : Tuple = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Dict: lowercase : str = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } lowercase : Optional[Any] = input_paths[compression_format] if input_path is None: lowercase : int = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = Extractor.infer_extractor_format(SCREAMING_SNAKE_CASE__ ) assert extractor_format is not None lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : Dict = file_path.read_text(encoding="""utf-8""" ) else: lowercase : int = output_path.read_text(encoding="""utf-8""" ) lowercase : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: import tarfile lowercase : Tuple = tmp_path / """data_dot_dot""" directory.mkdir() lowercase : str = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(SCREAMING_SNAKE_CASE__ , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: import tarfile lowercase : Tuple = tmp_path / """data_sym_link""" directory.mkdir() lowercase : int = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=SCREAMING_SNAKE_CASE__ ) with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : List[Any] = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } lowercase : Optional[int] = insecure_tar_files[insecure_tar_file] lowercase : List[str] = tmp_path / """extracted""" TarExtractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number lowercase : Any = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 lowercase : str = ( B"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" B"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" B"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" B"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(SCREAMING_SNAKE_CASE__ ) assert zipfile.is_zipfile(str(SCREAMING_SNAKE_CASE__ ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(SCREAMING_SNAKE_CASE__ ) # but we're right
20
1
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase : Any = { """bart""": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), """bert""": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """bert-large-uncased-whole-word-masking-finetuned-squad""": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """bert-large-cased-whole-word-masking-finetuned-squad""": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """bert-base-cased-finetuned-mrpc""": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """dpr""": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), """gpt2""": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """xlnet""": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """xlm""": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """xlm-roberta""": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """transfo-xl""": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """openai-gpt""": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """roberta""": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """layoutlm""": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), """roberta-large-mnli""": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """camembert""": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """flaubert""": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """distilbert""": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """distilbert-base-distilled-squad""": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """lxmert""": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """lxmert-visual-feature-encoder""": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """ctrl""": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """albert""": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """t5""": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """electra""": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), """wav2vec2""": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=False , SCREAMING_SNAKE_CASE__=True ) -> str: if model_type not in MODEL_CLASSES: raise ValueError(f"Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}." ) lowercase , lowercase , lowercase , lowercase : Union[str, Any] = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: lowercase : List[Any] = cached_file(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , force_download=not use_cached_models ) lowercase : List[str] = config_class.from_json_file(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = True lowercase : Optional[int] = True print(f"Building TensorFlow model from configuration: {config}" ) lowercase : Dict = model_class(SCREAMING_SNAKE_CASE__ ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): lowercase : List[str] = cached_file( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: lowercase : Any = load_pytorch_checkpoint_in_tfa_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if compare_with_pt_model: lowercase : int = tf_model(tf_model.dummy_inputs , training=SCREAMING_SNAKE_CASE__ ) # build the network lowercase : List[str] = torch.load(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" ) lowercase : Union[str, Any] = pt_model_class.from_pretrained( pretrained_model_name_or_path=SCREAMING_SNAKE_CASE__ , config=SCREAMING_SNAKE_CASE__ , state_dict=SCREAMING_SNAKE_CASE__ ) with torch.no_grad(): lowercase : str = pt_model(**pt_model.dummy_inputs ) lowercase : Optional[int] = pto[0].numpy() lowercase : Union[str, Any] = tfo[0].numpy() lowercase : int = np.amax(np.abs(np_pt - np_tf ) ) print(f"Max absolute difference between models outputs {diff}" ) assert diff <= 2e-2, f"Error, model absolute difference is >2e-2: {diff}" # Save pytorch-model print(f"Save TensorFlow model to {tf_dump_path}" ) tf_model.save_weights(SCREAMING_SNAKE_CASE__ , save_format="""h5""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None , SCREAMING_SNAKE_CASE__=None , SCREAMING_SNAKE_CASE__=False , SCREAMING_SNAKE_CASE__=False , SCREAMING_SNAKE_CASE__=False , SCREAMING_SNAKE_CASE__=False , ) -> Optional[Any]: if args_model_type is None: lowercase : Optional[int] = list(MODEL_CLASSES.keys() ) else: lowercase : int = [args_model_type] for j, model_type in enumerate(SCREAMING_SNAKE_CASE__ , start=1 ): print("""=""" * 100 ) print(f" Converting model type {j}/{len(SCREAMING_SNAKE_CASE__ )}: {model_type}" ) print("""=""" * 100 ) if model_type not in MODEL_CLASSES: raise ValueError(f"Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}." ) lowercase , lowercase , lowercase , lowercase , lowercase : List[str] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: lowercase : Optional[Any] = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: lowercase : Dict = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) , start=1 ): print("""-""" * 100 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(f" Skipping finetuned checkpoint {model_shortcut_name}" ) continue lowercase : Union[str, Any] = model_shortcut_name elif only_convert_finetuned_models: print(f" Skipping not finetuned checkpoint {model_shortcut_name}" ) continue print( f" Converting checkpoint {i}/{len(SCREAMING_SNAKE_CASE__ )}: {model_shortcut_name} - model_type {model_type}" ) print("""-""" * 100 ) if config_shortcut_name in aws_config_map: lowercase : Optional[int] = cached_file(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , force_download=not use_cached_models ) else: lowercase : Optional[Any] = config_shortcut_name if model_shortcut_name in aws_model_maps: lowercase : Dict = cached_file(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , force_download=not use_cached_models ) else: lowercase : str = model_shortcut_name if os.path.isfile(SCREAMING_SNAKE_CASE__ ): lowercase : Tuple = """converted_model""" convert_pt_checkpoint_to_tf( model_type=SCREAMING_SNAKE_CASE__ , pytorch_checkpoint_path=SCREAMING_SNAKE_CASE__ , config_file=SCREAMING_SNAKE_CASE__ , tf_dump_path=os.path.join(SCREAMING_SNAKE_CASE__ , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=SCREAMING_SNAKE_CASE__ , ) if remove_cached_files: os.remove(SCREAMING_SNAKE_CASE__ ) os.remove(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_dump_path""", default=None, type=str, required=True, help="""Path to the output Tensorflow dump file.""" ) parser.add_argument( """--model_type""", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' """convert all the models from AWS.""" ), ) parser.add_argument( """--pytorch_checkpoint_path""", default=None, type=str, help=( """Path to the PyTorch checkpoint path or shortcut name to download from AWS. """ """If not given, will download and convert all the checkpoints from AWS.""" ), ) parser.add_argument( """--config_file""", default=None, type=str, help=( """The config json file corresponding to the pre-trained model. \n""" """This specifies the model architecture. If not given and """ """--pytorch_checkpoint_path is not given or is a shortcut name """ """use the configuration associated to the shortcut name on the AWS""" ), ) parser.add_argument( """--compare_with_pt_model""", action="""store_true""", help="""Compare Tensorflow and PyTorch model predictions.""" ) parser.add_argument( """--use_cached_models""", action="""store_true""", help="""Use cached models if possible instead of updating to latest checkpoint versions.""", ) parser.add_argument( """--remove_cached_files""", action="""store_true""", help="""Remove pytorch models after conversion (save memory when converting in batches).""", ) parser.add_argument("""--only_convert_finetuned_models""", action="""store_true""", help="""Only convert finetuned models.""") lowercase : Union[str, Any] = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
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 lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[Any] = { """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 ( lowerCAmelCase ): _a : str= "gpt_neo" _a : Optional[int]= ["past_key_values"] _a : Dict= {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self ,snake_case=50257 ,snake_case=2048 ,snake_case=2048 ,snake_case=24 ,snake_case=[[["global", "local"], 12]] ,snake_case=16 ,snake_case=None ,snake_case=256 ,snake_case="gelu_new" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=1e-5 ,snake_case=0.02 ,snake_case=True ,snake_case=50256 ,snake_case=50256 ,**snake_case ,): '''simple docstring''' lowercase : int = vocab_size lowercase : Union[str, Any] = max_position_embeddings lowercase : Dict = hidden_size lowercase : Union[str, Any] = num_layers lowercase : Union[str, Any] = num_heads lowercase : Optional[int] = intermediate_size lowercase : List[str] = window_size lowercase : Optional[int] = activation_function lowercase : List[str] = resid_dropout lowercase : int = embed_dropout lowercase : Optional[int] = attention_dropout lowercase : Tuple = classifier_dropout lowercase : Optional[int] = layer_norm_epsilon lowercase : Dict = initializer_range lowercase : List[str] = use_cache lowercase : Optional[int] = bos_token_id lowercase : int = eos_token_id lowercase : Union[str, Any] = attention_types lowercase : Dict = self.expand_attention_types_params(snake_case ) 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=snake_case ,eos_token_id=snake_case ,**snake_case ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : List[Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: import torch lowercase : Tuple = input.size() lowercase : int = len(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = shape[dimension] lowercase : int = torch.arange(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.div(sizedim - size , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) + 1 lowercase : Dict = torch.arange(SCREAMING_SNAKE_CASE__ ) + low_indices[:min_length][:, None] lowercase : Union[str, Any] = [slice(SCREAMING_SNAKE_CASE__ )] * rank lowercase : Optional[Any] = indices lowercase : List[str] = input[s] lowercase : Optional[int] = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import torch lowercase : Union[str, Any] = torch.arange(1 , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.remainder(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = remainders == 0 lowercase : Optional[int] = candidates[divisor_indices] lowercase : List[Any] = torch.max(SCREAMING_SNAKE_CASE__ ) return largest_divisor, torch.div(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(snake_case ,direction="""inputs""" ) lowercase : Dict = {0: """batch""", 1: """past_sequence + sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} return common_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self._config.num_heads def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,): '''simple docstring''' lowercase : Any = super(snake_case ,self ).generate_dummy_inputs( snake_case ,batch_size=snake_case ,seq_length=snake_case ,is_pair=snake_case ,framework=snake_case ) # We need to order the input in the way they appears in the forward() lowercase : List[str] = 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 lowercase , lowercase : List[Any] = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowercase : Optional[int] = seqlen + 2 lowercase : int = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowercase : Optional[Any] = [ (torch.zeros(snake_case ), torch.zeros(snake_case )) for _ in range(self.num_layers ) ] lowercase : Optional[Any] = common_inputs["""attention_mask"""] if self.use_past: lowercase : Any = ordered_inputs["""attention_mask"""].dtype lowercase : Union[str, Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(snake_case ,snake_case ,dtype=snake_case )] ,dim=1 ) return ordered_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 13
20
1
from __future__ import annotations lowercase : Tuple = 8.988e9 # units = N * m^s * C^-2 def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> dict[str, float]: lowercase : Optional[Any] = abs(chargea * chargea ) if (force, chargea, chargea, distance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if distance < 0: raise ValueError("""Distance cannot be negative""" ) if force == 0: lowercase : Optional[int] = COULOMBS_CONSTANT * charge_product / (distance**2) return {"force": force} elif chargea == 0: lowercase : Union[str, Any] = abs(SCREAMING_SNAKE_CASE__ ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge1": chargea} elif chargea == 0: lowercase : int = abs(SCREAMING_SNAKE_CASE__ ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge2": chargea} elif distance == 0: lowercase : Dict = (COULOMBS_CONSTANT * charge_product / abs(SCREAMING_SNAKE_CASE__ )) ** 0.5 return {"distance": distance} raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING lowercase : Any = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == """tf""" else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = {} if top_k is not None: lowercase : int = top_k return {}, {}, postprocess_params def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = load_image(snake_case ) lowercase : List[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = self.model(**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ): '''simple docstring''' if top_k > self.model.config.num_labels: lowercase : Tuple = self.model.config.num_labels if self.framework == "pt": lowercase : str = model_outputs.logits.softmax(-1 )[0] lowercase , lowercase : Dict = probs.topk(snake_case ) elif self.framework == "tf": lowercase : Optional[int] = stable_softmax(model_outputs.logits ,axis=-1 )[0] lowercase : Union[str, Any] = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : List[str] = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f"Unsupported framework: {self.framework}" ) lowercase : Tuple = scores.tolist() lowercase : Dict = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case ,snake_case )]
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : str = { """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""], """convert_funnel_original_tf_checkpoint_to_pytorch""": [], """tokenization_funnel""": ["""FunnelTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Tuple = ["""FunnelTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = [ """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """FunnelBaseModel""", """FunnelForMaskedLM""", """FunnelForMultipleChoice""", """FunnelForPreTraining""", """FunnelForQuestionAnswering""", """FunnelForSequenceClassification""", """FunnelForTokenClassification""", """FunnelModel""", """FunnelPreTrainedModel""", """load_tf_weights_in_funnel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFFunnelBaseModel""", """TFFunnelForMaskedLM""", """TFFunnelForMultipleChoice""", """TFFunnelForPreTraining""", """TFFunnelForQuestionAnswering""", """TFFunnelForSequenceClassification""", """TFFunnelForTokenClassification""", """TFFunnelModel""", """TFFunnelPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
1
class __snake_case : def __init__( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = arr.split(""",""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = [int(self.array[0] )] * len(self.array ) lowercase : Any = [int(self.array[0] )] * len(self.array ) for i in range(1 ,len(self.array ) ): lowercase : Optional[int] = max( int(self.array[i] ) + sum_value[i - 1] ,int(self.array[i] ) ) lowercase : Optional[int] = max(sum_value[i] ,rear[i - 1] ) return rear[len(self.array ) - 1] if __name__ == "__main__": lowercase : Any = input("""please input some numbers:""") lowercase : Union[str, Any] = SubArray(whole_array) lowercase : Any = array.solve_sub_array() print(("""the results is:""", re))
20
import json import os from dataclasses import dataclass from functools import partial from typing import Callable import flax.linen as nn import jax import jax.numpy as jnp import joblib import optax import wandb from flax import jax_utils, struct, traverse_util from flax.serialization import from_bytes, to_bytes from flax.training import train_state from flax.training.common_utils import shard from tqdm.auto import tqdm from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule class __snake_case ( lowerCAmelCase ): _a : BigBirdConfig _a : jnp.dtype= jnp.floataa _a : bool= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setup() lowercase : List[str] = nn.Dense(5 ,dtype=self.dtype ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = super().__call__(*snake_case ,**snake_case ) lowercase : Any = self.cls(outputs[2] ) return outputs[:2] + (cls_out,) class __snake_case ( lowerCAmelCase ): _a : List[Any]= FlaxBigBirdForNaturalQuestionsModule def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: def cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ): lowercase : int = logits.shape[-1] lowercase : Dict = (labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__ )[None]).astype("""f4""" ) lowercase : Any = jax.nn.log_softmax(SCREAMING_SNAKE_CASE__ , axis=-1 ) lowercase : Optional[Any] = -jnp.sum(labels * logits , axis=-1 ) if reduction is not None: lowercase : Any = reduction(SCREAMING_SNAKE_CASE__ ) return loss lowercase : Optional[Any] = partial(SCREAMING_SNAKE_CASE__ , reduction=jnp.mean ) lowercase : Optional[int] = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Dict = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return (start_loss + end_loss + pooled_loss) / 3 @dataclass class __snake_case : _a : str= "google/bigbird-roberta-base" _a : int= 3000 _a : int= 1_0500 _a : int= 128 _a : int= 3 _a : int= 1 _a : int= 5 # tx_args _a : float= 3E-5 _a : float= 0.0 _a : int= 2_0000 _a : float= 0.00_95 _a : str= "bigbird-roberta-natural-questions" _a : str= "training-expt" _a : str= "data/nq-training.jsonl" _a : str= "data/nq-validation.jsonl" def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' os.makedirs(self.base_dir ,exist_ok=snake_case ) lowercase : Optional[int] = os.path.join(self.base_dir ,self.save_dir ) lowercase : Optional[int] = self.batch_size_per_device * jax.device_count() @dataclass class __snake_case : _a : int _a : int= 4096 # no dynamic padding on TPUs def __call__( self ,snake_case ): '''simple docstring''' lowercase : int = self.collate_fn(snake_case ) lowercase : Union[str, Any] = jax.tree_util.tree_map(snake_case ,snake_case ) return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Union[str, Any] = self.fetch_inputs(features["""input_ids"""] ) lowercase : Tuple = { """input_ids""": jnp.array(snake_case ,dtype=jnp.intaa ), """attention_mask""": jnp.array(snake_case ,dtype=jnp.intaa ), """start_labels""": jnp.array(features["""start_token"""] ,dtype=jnp.intaa ), """end_labels""": jnp.array(features["""end_token"""] ,dtype=jnp.intaa ), """pooled_labels""": jnp.array(features["""category"""] ,dtype=jnp.intaa ), } return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = [self._fetch_inputs(snake_case ) for ids in input_ids] return zip(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [1 for _ in range(len(snake_case ) )] while len(snake_case ) < self.max_length: input_ids.append(self.pad_id ) attention_mask.append(0 ) return input_ids, attention_mask def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> Any: if seed is not None: lowercase : Optional[int] = dataset.shuffle(seed=SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) // batch_size ): lowercase : Optional[Any] = dataset[i * batch_size : (i + 1) * batch_size] yield dict(SCREAMING_SNAKE_CASE__ ) @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[Any]: def loss_fn(SCREAMING_SNAKE_CASE__ ): lowercase : List[str] = model_inputs.pop("""start_labels""" ) lowercase : Optional[int] = model_inputs.pop("""end_labels""" ) lowercase : str = model_inputs.pop("""pooled_labels""" ) lowercase : Union[str, Any] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=SCREAMING_SNAKE_CASE__ , dropout_rng=SCREAMING_SNAKE_CASE__ , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[str] = outputs return state.loss_fn( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) lowercase , lowercase : int = jax.random.split(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = jax.value_and_grad(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : Union[str, Any] = grad_fn(state.params ) lowercase : List[Any] = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) lowercase : List[Any] = jax.lax.pmean(SCREAMING_SNAKE_CASE__ , """batch""" ) lowercase : str = state.apply_gradients(grads=SCREAMING_SNAKE_CASE__ ) return state, metrics, new_drp_rng @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = model_inputs.pop("""start_labels""" ) lowercase : Dict = model_inputs.pop("""end_labels""" ) lowercase : Optional[Any] = model_inputs.pop("""pooled_labels""" ) lowercase : Optional[int] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=state.params , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[Any] = outputs lowercase : Dict = state.loss_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : str = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) return metrics class __snake_case ( train_state.TrainState ): _a : Callable= struct.field(pytree_node=lowerCAmelCase ) @dataclass class __snake_case : _a : Args _a : Callable _a : Callable _a : Callable _a : Callable _a : wandb _a : Callable= None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = model.params lowercase : Any = TrainState.create( apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,loss_fn=snake_case ,) if ckpt_dir is not None: lowercase , lowercase , lowercase , lowercase , lowercase : Tuple = restore_checkpoint(snake_case ,snake_case ) lowercase : List[str] = { """lr""": args.lr, """init_lr""": args.init_lr, """warmup_steps""": args.warmup_steps, """num_train_steps""": num_train_steps, """weight_decay""": args.weight_decay, } lowercase , lowercase : Tuple = build_tx(**snake_case ) lowercase : str = train_state.TrainState( step=snake_case ,apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,opt_state=snake_case ,) lowercase : Any = args lowercase : Optional[Any] = data_collator lowercase : List[str] = lr lowercase : str = params lowercase : Tuple = jax_utils.replicate(snake_case ) return state def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = self.args lowercase : Optional[Any] = len(snake_case ) // args.batch_size lowercase : int = jax.random.PRNGKey(0 ) lowercase : List[str] = jax.random.split(snake_case ,jax.device_count() ) for epoch in range(args.max_epochs ): lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : List[str] = get_batched_dataset(snake_case ,args.batch_size ,seed=snake_case ) lowercase : int = 0 for batch in tqdm(snake_case ,total=snake_case ,desc=f"Running EPOCH-{epoch}" ): lowercase : Dict = self.data_collator(snake_case ) lowercase , lowercase , lowercase : Optional[int] = self.train_step_fn(snake_case ,snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 if i % args.logging_steps == 0: lowercase : Optional[Any] = jax_utils.unreplicate(state.step ) lowercase : List[str] = running_loss.item() / i lowercase : List[str] = self.scheduler_fn(state_step - 1 ) lowercase : int = self.evaluate(snake_case ,snake_case ) lowercase : Tuple = { """step""": state_step.item(), """eval_loss""": eval_loss.item(), """tr_loss""": tr_loss, """lr""": lr.item(), } tqdm.write(str(snake_case ) ) self.logger.log(snake_case ,commit=snake_case ) if i % args.save_steps == 0: self.save_checkpoint(args.save_dir + f"-e{epoch}-s{i}" ,state=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = get_batched_dataset(snake_case ,self.args.batch_size ) lowercase : Any = len(snake_case ) // self.args.batch_size lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : Optional[int] = 0 for batch in tqdm(snake_case ,total=snake_case ,desc="""Evaluating ... """ ): lowercase : Tuple = self.data_collator(snake_case ) lowercase : Optional[int] = self.val_step_fn(snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 return running_loss / i def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = jax_utils.unreplicate(snake_case ) print(f"SAVING CHECKPOINT IN {save_dir}" ,end=""" ... """ ) self.model_save_fn(snake_case ,params=state.params ) with open(os.path.join(snake_case ,"""opt_state.msgpack""" ) ,"""wb""" ) as f: f.write(to_bytes(state.opt_state ) ) joblib.dump(self.args ,os.path.join(snake_case ,"""args.joblib""" ) ) joblib.dump(self.data_collator ,os.path.join(snake_case ,"""data_collator.joblib""" ) ) with open(os.path.join(snake_case ,"""training_state.json""" ) ,"""w""" ) as f: json.dump({"""step""": state.step.item()} ,snake_case ) print("""DONE""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: print(f"RESTORING CHECKPOINT FROM {save_dir}" , end=""" ... """ ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """flax_model.msgpack""" ) , """rb""" ) as f: lowercase : str = from_bytes(state.params , f.read() ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """opt_state.msgpack""" ) , """rb""" ) as f: lowercase : Optional[int] = from_bytes(state.opt_state , f.read() ) lowercase : Optional[Any] = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """args.joblib""" ) ) lowercase : int = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """data_collator.joblib""" ) ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """training_state.json""" ) , """r""" ) as f: lowercase : Tuple = json.load(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = training_state["""step"""] print("""DONE""" ) return params, opt_state, step, args, data_collator def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : List[str] = num_train_steps - warmup_steps lowercase : Dict = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=SCREAMING_SNAKE_CASE__ , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=1e-7 , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = optax.join_schedules(schedules=[warmup_fn, decay_fn] , boundaries=[warmup_steps] ) return lr def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: def weight_decay_mask(SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = {k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()} return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = scheduler_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__ , weight_decay=SCREAMING_SNAKE_CASE__ , mask=SCREAMING_SNAKE_CASE__ ) return tx, lr
20
1
import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BlipaProcessor, BlipImageProcessor, GPTaTokenizer, PreTrainedTokenizerFast @require_vision class __snake_case ( unittest.TestCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = tempfile.mkdtemp() lowercase : int = BlipImageProcessor() lowercase : List[str] = GPTaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-GPT2Model""" ) lowercase : Optional[int] = BlipaProcessor(snake_case ,snake_case ) processor.save_pretrained(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return AutoProcessor.from_pretrained(self.tmpdirname ,**snake_case ).tokenizer def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return AutoProcessor.from_pretrained(self.tmpdirname ,**snake_case ).image_processor def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )] lowercase : Dict = [Image.fromarray(np.moveaxis(snake_case ,0 ,-1 ) ) for x in image_inputs] return image_inputs def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = BlipaProcessor(tokenizer=self.get_tokenizer() ,image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) lowercase : List[Any] = self.get_tokenizer(bos_token="""(BOS)""" ,eos_token="""(EOS)""" ) lowercase : Optional[Any] = self.get_image_processor(do_normalize=snake_case ,padding_value=1.0 ) lowercase : Dict = BlipaProcessor.from_pretrained( self.tmpdirname ,bos_token="""(BOS)""" ,eos_token="""(EOS)""" ,do_normalize=snake_case ,padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer ,snake_case ) self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.get_image_processor() lowercase : Tuple = self.get_tokenizer() lowercase : int = BlipaProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Union[str, Any] = self.prepare_image_inputs() lowercase : Optional[int] = image_processor(snake_case ,return_tensors="""np""" ) lowercase : Optional[int] = processor(images=snake_case ,return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.get_image_processor() lowercase : str = self.get_tokenizer() lowercase : Optional[int] = BlipaProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Dict = """lower newer""" lowercase : Optional[int] = processor(text=snake_case ) lowercase : List[str] = tokenizer(snake_case ,return_token_type_ids=snake_case ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] ,encoded_processor[key] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.get_image_processor() lowercase : List[str] = self.get_tokenizer() lowercase : Union[str, Any] = BlipaProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Optional[Any] = """lower newer""" lowercase : Optional[Any] = self.prepare_image_inputs() lowercase : List[Any] = processor(text=snake_case ,images=snake_case ) self.assertListEqual(list(inputs.keys() ) ,["""pixel_values""", """input_ids""", """attention_mask"""] ) # test if it raises when no input is passed with pytest.raises(snake_case ): processor() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = self.get_image_processor() lowercase : str = self.get_tokenizer() lowercase : Optional[int] = BlipaProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : Tuple = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] lowercase : List[str] = processor.batch_decode(snake_case ) lowercase : List[Any] = tokenizer.batch_decode(snake_case ) self.assertListEqual(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_image_processor() lowercase : List[str] = self.get_tokenizer() lowercase : List[Any] = BlipaProcessor(tokenizer=snake_case ,image_processor=snake_case ) lowercase : str = """lower newer""" lowercase : Tuple = self.prepare_image_inputs() lowercase : Optional[int] = processor(text=snake_case ,images=snake_case ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) ,["""pixel_values""", """input_ids""", """attention_mask"""] )
20
from math import sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' must been an int and positive" lowercase : Union[str, Any] = True # 0 and 1 are none primes. if number <= 1: lowercase : str = False for divisor in range(2 , int(round(sqrt(SCREAMING_SNAKE_CASE__ ) ) ) + 1 ): # if 'number' divisible by 'divisor' then sets 'status' # of false and break up the loop. if number % divisor == 0: lowercase : Any = False break # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'status' must been from type bool" return status def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" # beginList: contains all natural numbers from 2 up to N lowercase : str = list(range(2 , n + 1 ) ) lowercase : Tuple = [] # this list will be returns. # actual sieve of erathostenes for i in range(len(SCREAMING_SNAKE_CASE__ ) ): for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0): lowercase : Tuple = 0 # filters actual prime numbers. lowercase : int = [x for x in begin_list if x != 0] # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" lowercase : Dict = [] # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2 , n + 1 ): if is_prime(SCREAMING_SNAKE_CASE__ ): ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and number >= 0, "'number' must been an int and >= 0" lowercase : Tuple = [] # this list will be returns of the function. # potential prime number factors. lowercase : Optional[Any] = 2 lowercase : Any = number if number == 0 or number == 1: ans.append(SCREAMING_SNAKE_CASE__ ) # if 'number' not prime then builds the prime factorization of 'number' elif not is_prime(SCREAMING_SNAKE_CASE__ ): while quotient != 1: if is_prime(SCREAMING_SNAKE_CASE__ ) and (quotient % factor == 0): ans.append(SCREAMING_SNAKE_CASE__ ) quotient /= factor else: factor += 1 else: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Tuple = 0 # prime factorization of 'number' lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = max(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Union[str, Any] = 0 # prime factorization of 'number' lowercase : Tuple = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = min(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 == 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 == 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 != 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 != 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__ ) ), "'number' must been an int, even and > 2" lowercase : Union[str, Any] = [] # this list will returned # creates a list of prime numbers between 2 up to 'number' lowercase : str = get_prime_numbers(SCREAMING_SNAKE_CASE__ ) lowercase : Any = len(SCREAMING_SNAKE_CASE__ ) # run variable for while-loops. lowercase : Optional[Any] = 0 lowercase : List[Any] = None # exit variable. for break up the loops lowercase : Any = True while i < len_pn and loop: lowercase : str = i + 1 while j < len_pn and loop: if prime_numbers[i] + prime_numbers[j] == number: lowercase : Union[str, Any] = False ans.append(prime_numbers[i] ) ans.append(prime_numbers[j] ) j += 1 i += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (len(SCREAMING_SNAKE_CASE__ ) == 2) and (ans[0] + ans[1] == number) and is_prime(ans[0] ) and is_prime(ans[1] ) ), "'ans' must contains two primes. And sum of elements must been eq 'number'" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 0) and (numbera >= 0) ), "'number1' and 'number2' must been positive integer." lowercase : Union[str, Any] = 0 while numbera != 0: lowercase : Optional[int] = numbera % numbera lowercase : Optional[int] = numbera lowercase : Dict = rest # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( numbera >= 0 ), "'number' must been from type int and positive" return numbera def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 1) and (numbera >= 1) ), "'number1' and 'number2' must been positive integer." lowercase : Dict = 1 # actual answer that will be return. # for kgV (x,1) if numbera > 1 and numbera > 1: # builds the prime factorization of 'number1' and 'number2' lowercase : Optional[Any] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) elif numbera == 1 or numbera == 1: lowercase : Union[str, Any] = [] lowercase : List[str] = [] lowercase : Dict = max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = 0 lowercase : Optional[Any] = 0 lowercase : List[str] = [] # captured numbers int both 'primeFac1' and 'primeFac2' # iterates through primeFac1 for n in prime_fac_a: if n not in done: if n in prime_fac_a: lowercase : Dict = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ): ans *= n else: lowercase : List[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # iterates through primeFac2 for n in prime_fac_a: if n not in done: lowercase : Optional[int] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( ans >= 0 ), "'ans' must been from type int and positive" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'number' must been a positive int" lowercase : Dict = 0 lowercase : List[str] = 2 # this variable holds the answer while index < n: index += 1 ans += 1 # counts to the next number # if ans not prime then # runs to the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): ans += 1 # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and is_prime( SCREAMING_SNAKE_CASE__ ), "'ans' must been a prime number and from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert ( is_prime(SCREAMING_SNAKE_CASE__ ) and is_prime(SCREAMING_SNAKE_CASE__ ) and (p_number_a < p_number_a) ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" lowercase : List[str] = p_number_a + 1 # jump to the next number lowercase : List[Any] = [] # this list will be returns. # if number is not prime then # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 while number < p_number_a: ans.append(SCREAMING_SNAKE_CASE__ ) number += 1 # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ans[0] != p_number_a and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] != p_number_a ), "'ans' must been a list without the arguments" # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 1), "'n' must been int and >= 1" lowercase : Optional[Any] = [] # will be returned. for divisor in range(1 , n + 1 ): if n % divisor == 0: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] == n, "Error in function getDivisiors(...)" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number > 1 ), "'number' must been an int and >= 1" lowercase : str = get_divisors(SCREAMING_SNAKE_CASE__ ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (divisors[0] == 1) and (divisors[len(SCREAMING_SNAKE_CASE__ ) - 1] == number) ), "Error in help-function getDivisiors(...)" # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1] ) == number def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (denominator != 0) ), "The arguments must been from type int and 'denominator' != 0" # build the greatest common divisor of numerator and denominator. lowercase : Tuple = gcd(abs(SCREAMING_SNAKE_CASE__ ) , abs(SCREAMING_SNAKE_CASE__ ) ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numerator % gcd_of_fraction == 0) and (denominator % gcd_of_fraction == 0) ), "Error in function gcd(...,...)" return (numerator // gcd_of_fraction, denominator // gcd_of_fraction) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been a int and >= 0" lowercase : List[str] = 1 # this will be return. for factor in range(1 , n + 1 ): ans *= factor return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been an int and >= 0" lowercase : int = 0 lowercase : Union[str, Any] = 1 lowercase : int = 1 # this will be return for _ in range(n - 1 ): lowercase : Optional[int] = ans ans += fiba lowercase : Optional[int] = tmp return ans
20
1
import os def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Dict = len(grid[0] ) lowercase : Dict = len(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = 0 lowercase : str = 0 lowercase : Tuple = 0 # Check vertically, horizontally, diagonally at the same time (only works # for nxn grid) for i in range(SCREAMING_SNAKE_CASE__ ): for j in range(n_rows - 3 ): lowercase : int = grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i] lowercase : List[Any] = grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3] # Left-to-right diagonal (\) product if i < n_columns - 3: lowercase : List[str] = ( grid[i][j] * grid[i + 1][j + 1] * grid[i + 2][j + 2] * grid[i + 3][j + 3] ) # Right-to-left diagonal(/) product if i > 2: lowercase : int = ( grid[i][j] * grid[i - 1][j + 1] * grid[i - 2][j + 2] * grid[i - 3][j + 3] ) lowercase : Optional[Any] = max( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if max_product > largest: lowercase : Any = max_product return largest def _snake_case( ) -> Optional[Any]: lowercase : List[Any] = [] with open(os.path.dirname(SCREAMING_SNAKE_CASE__ ) + """/grid.txt""" ) as file: for line in file: grid.append(line.strip("""\n""" ).split(""" """ ) ) lowercase : Dict = [[int(SCREAMING_SNAKE_CASE__ ) for i in grid[j]] for j in range(len(SCREAMING_SNAKE_CASE__ ) )] return largest_product(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": print(solution())
20
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
1
import os import unittest from transformers import LxmertTokenizer, LxmertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : str= LxmertTokenizer _a : Optional[Any]= LxmertTokenizerFast _a : List[Any]= True _a : int= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() lowercase : List[str] = [ """[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] lowercase : Optional[int] = 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 _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : str = """UNwant\u00E9d,running""" lowercase : List[Any] = """unwanted, running""" return input_text, output_text def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.tokenizer_class(self.vocab_file ) lowercase : Any = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(snake_case ,["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case ) ,[7, 4, 5, 10, 8, 9] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if not self.test_rust_tokenizer: return lowercase : Union[str, Any] = self.get_tokenizer() lowercase : Optional[int] = self.get_rust_tokenizer() lowercase : str = """I was born in 92000, and this is falsé.""" lowercase : Optional[Any] = tokenizer.tokenize(snake_case ) lowercase : Tuple = rust_tokenizer.tokenize(snake_case ) self.assertListEqual(snake_case ,snake_case ) lowercase : Tuple = tokenizer.encode(snake_case ,add_special_tokens=snake_case ) lowercase : int = rust_tokenizer.encode(snake_case ,add_special_tokens=snake_case ) self.assertListEqual(snake_case ,snake_case ) lowercase : Optional[Any] = self.get_rust_tokenizer() lowercase : Any = tokenizer.encode(snake_case ) lowercase : Union[str, Any] = rust_tokenizer.encode(snake_case ) self.assertListEqual(snake_case ,snake_case )
20
import argparse import requests import torch from PIL import Image from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: if "cls_token" in name: lowercase : List[Any] = name.replace("""cls_token""" , """vit.embeddings.cls_token""" ) if "mask_token" in name: lowercase : Any = name.replace("""mask_token""" , """decoder.mask_token""" ) if "decoder_pos_embed" in name: lowercase : str = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : List[str] = name.replace("""pos_embed""" , """vit.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """vit.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : int = name.replace("""patch_embed.norm""" , """vit.embeddings.norm""" ) if "decoder_blocks" in name: lowercase : Tuple = name.replace("""decoder_blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[Any] = name.replace("""blocks""" , """vit.encoder.layer""" ) if "attn.proj" in name: lowercase : List[str] = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "norm1" in name: lowercase : Optional[Any] = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Union[str, Any] = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : Dict = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : Dict = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Dict = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : List[str] = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name: lowercase : Tuple = name.replace("""norm.weight""" , """vit.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name: lowercase : int = name.replace("""norm.bias""" , """vit.layernorm.bias""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: for key in orig_state_dict.copy().keys(): lowercase : List[Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if "qkv" in key: lowercase : int = key.split(""".""" ) lowercase : List[str] = int(key_split[1] ) if "decoder_blocks" in key: lowercase : Tuple = config.decoder_hidden_size lowercase : int = """decoder.decoder_layers.""" if "weight" in key: lowercase : List[Any] = val[:dim, :] lowercase : Tuple = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] elif "bias" in key: lowercase : str = val[:dim] lowercase : Dict = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Tuple = config.hidden_size lowercase : Union[str, Any] = """vit.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : Dict = val[-dim:, :] elif "bias" in key: lowercase : Any = val[:dim] lowercase : str = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Union[str, Any] = val return orig_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : int = ViTMAEConfig() if "large" in checkpoint_url: lowercase : Dict = 1_024 lowercase : str = 4_096 lowercase : Optional[Any] = 24 lowercase : Optional[Any] = 16 elif "huge" in checkpoint_url: lowercase : int = 14 lowercase : List[Any] = 1_280 lowercase : int = 5_120 lowercase : List[Any] = 32 lowercase : Any = 16 lowercase : List[str] = ViTMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" )["""model"""] lowercase : Tuple = ViTMAEImageProcessor(size=config.image_size ) lowercase : Optional[int] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() lowercase : Union[str, Any] = """https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg""" lowercase : Union[str, Any] = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ) lowercase : Optional[Any] = ViTMAEImageProcessor(size=config.image_size ) lowercase : List[Any] = image_processor(images=SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) # forward pass torch.manual_seed(2 ) lowercase : int = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits if "large" in checkpoint_url: lowercase : List[Any] = torch.tensor( [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]] ) elif "huge" in checkpoint_url: lowercase : Tuple = torch.tensor( [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]] ) else: lowercase : List[str] = torch.tensor( [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]] ) # verify logits assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print(f"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""", type=str, help="""URL of the checkpoint you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : List[Any] = parser.parse_args() convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_mobilebert import MobileBertTokenizer lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[int] = {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""} lowercase : Dict = { """vocab_file""": {"""mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt"""}, """tokenizer_file""": { """mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json""" }, } lowercase : Dict = {"""mobilebert-uncased""": 512} lowercase : int = {} class __snake_case ( lowerCAmelCase ): _a : Optional[Any]= VOCAB_FILES_NAMES _a : Tuple= PRETRAINED_VOCAB_FILES_MAP _a : List[Any]= PRETRAINED_INIT_CONFIGURATION _a : Dict= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : int= MobileBertTokenizer def __init__( self ,snake_case=None ,snake_case=None ,snake_case=True ,snake_case="[UNK]" ,snake_case="[SEP]" ,snake_case="[PAD]" ,snake_case="[CLS]" ,snake_case="[MASK]" ,snake_case=True ,snake_case=None ,**snake_case ,): '''simple docstring''' super().__init__( snake_case ,tokenizer_file=snake_case ,do_lower_case=snake_case ,unk_token=snake_case ,sep_token=snake_case ,pad_token=snake_case ,cls_token=snake_case ,mask_token=snake_case ,tokenize_chinese_chars=snake_case ,strip_accents=snake_case ,**snake_case ,) lowercase : Tuple = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get("""lowercase""" ,snake_case ) != do_lower_case or normalizer_state.get("""strip_accents""" ,snake_case ) != strip_accents or normalizer_state.get("""handle_chinese_chars""" ,snake_case ) != tokenize_chinese_chars ): lowercase : List[Any] = getattr(snake_case ,normalizer_state.pop("""type""" ) ) lowercase : int = do_lower_case lowercase : int = strip_accents lowercase : int = tokenize_chinese_chars lowercase : int = normalizer_class(**snake_case ) lowercase : Any = do_lower_case def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = [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 _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : List[Any] = [self.sep_token_id] lowercase : 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 ) * [0] + len(token_ids_a + sep ) * [1] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Dict = self._tokenizer.model.save(snake_case ,name=snake_case ) return tuple(snake_case )
20
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=0.999 , SCREAMING_SNAKE_CASE__="cosine" , ) -> List[Any]: if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.exp(t * -12.0 ) else: raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}" ) lowercase : int = [] for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = i / num_diffusion_timesteps lowercase : Optional[int] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) / alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ) ) return torch.tensor(SCREAMING_SNAKE_CASE__ , dtype=torch.floataa ) class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Tuple= [e.name for e in KarrasDiffusionSchedulers] _a : int= 2 @register_to_config def __init__( self ,snake_case = 1000 ,snake_case = 0.00_085 ,snake_case = 0.012 ,snake_case = "linear" ,snake_case = None ,snake_case = "epsilon" ,snake_case = False ,snake_case = False ,snake_case = 1.0 ,snake_case = "linspace" ,snake_case = 0 ,): '''simple docstring''' if trained_betas is not None: lowercase : List[str] = torch.tensor(snake_case ,dtype=torch.floataa ) elif beta_schedule == "linear": lowercase : Optional[Any] = torch.linspace(snake_case ,snake_case ,snake_case ,dtype=torch.floataa ) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. lowercase : int = ( torch.linspace(beta_start**0.5 ,beta_end**0.5 ,snake_case ,dtype=torch.floataa ) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule lowercase : Union[str, Any] = betas_for_alpha_bar(snake_case ,alpha_transform_type="""cosine""" ) elif beta_schedule == "exp": lowercase : int = betas_for_alpha_bar(snake_case ,alpha_transform_type="""exp""" ) else: raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}" ) lowercase : Any = 1.0 - self.betas lowercase : Dict = torch.cumprod(self.alphas ,dim=0 ) # set all values self.set_timesteps(snake_case ,snake_case ,snake_case ) lowercase : Tuple = use_karras_sigmas def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if schedule_timesteps is None: lowercase : Union[str, Any] = self.timesteps lowercase : Dict = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter ) == 0: lowercase : Dict = 1 if len(snake_case ) > 1 else 0 else: lowercase : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep lowercase : str = self._index_counter[timestep_int] return indices[pos].item() @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[Any] = self.index_for_timestep(snake_case ) lowercase : Dict = self.sigmas[step_index] lowercase : List[str] = sample / ((sigma**2 + 1) ** 0.5) return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,): '''simple docstring''' lowercase : Any = num_inference_steps lowercase : List[Any] = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": lowercase : Optional[int] = np.linspace(0 ,num_train_timesteps - 1 ,snake_case ,dtype=snake_case )[::-1].copy() elif self.config.timestep_spacing == "leading": lowercase : int = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : List[str] = (np.arange(0 ,snake_case ) * step_ratio).round()[::-1].copy().astype(snake_case ) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": lowercase : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : Optional[int] = (np.arange(snake_case ,0 ,-step_ratio )).round().copy().astype(snake_case ) timesteps -= 1 else: raise ValueError( f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." ) lowercase : Optional[int] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 ) lowercase : Dict = np.log(snake_case ) lowercase : Union[str, Any] = np.interp(snake_case ,np.arange(0 ,len(snake_case ) ) ,snake_case ) if self.config.use_karras_sigmas: lowercase : List[Any] = self._convert_to_karras(in_sigmas=snake_case ,num_inference_steps=self.num_inference_steps ) lowercase : Tuple = np.array([self._sigma_to_t(snake_case ,snake_case ) for sigma in sigmas] ) lowercase : Any = np.concatenate([sigmas, [0.0]] ).astype(np.floataa ) lowercase : List[Any] = torch.from_numpy(snake_case ).to(device=snake_case ) lowercase : List[Any] = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2 ), sigmas[-1:]] ) lowercase : Dict = torch.from_numpy(snake_case ) lowercase : List[Any] = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2 )] ) if str(snake_case ).startswith("""mps""" ): # mps does not support float64 lowercase : Any = timesteps.to(snake_case ,dtype=torch.floataa ) else: lowercase : str = timesteps.to(device=snake_case ) # empty dt and derivative lowercase : Union[str, Any] = None lowercase : Any = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter lowercase : str = defaultdict(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = np.log(snake_case ) # get distribution lowercase : Union[str, Any] = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range lowercase : Optional[int] = np.cumsum((dists >= 0) ,axis=0 ).argmax(axis=0 ).clip(max=log_sigmas.shape[0] - 2 ) lowercase : Any = low_idx + 1 lowercase : str = log_sigmas[low_idx] lowercase : Dict = log_sigmas[high_idx] # interpolate sigmas lowercase : int = (low - log_sigma) / (low - high) lowercase : Dict = np.clip(snake_case ,0 ,1 ) # transform interpolation to time range lowercase : Optional[Any] = (1 - w) * low_idx + w * high_idx lowercase : Tuple = t.reshape(sigma.shape ) return t def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : float = in_sigmas[-1].item() lowercase : float = in_sigmas[0].item() lowercase : Dict = 7.0 # 7.0 is the value used in the paper lowercase : Optional[int] = np.linspace(0 ,1 ,snake_case ) lowercase : int = sigma_min ** (1 / rho) lowercase : Any = sigma_max ** (1 / rho) lowercase : Tuple = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.dt is None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = True ,): '''simple docstring''' lowercase : Union[str, Any] = self.index_for_timestep(snake_case ) # advance index counter by 1 lowercase : Optional[int] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: lowercase : str = self.sigmas[step_index] lowercase : Optional[int] = self.sigmas[step_index + 1] else: # 2nd order / Heun's method lowercase : Dict = self.sigmas[step_index - 1] lowercase : Optional[Any] = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API lowercase : Union[str, Any] = 0 lowercase : Any = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": lowercase : Any = sigma_hat if self.state_in_first_order else sigma_next lowercase : int = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": lowercase : Union[str, Any] = sigma_hat if self.state_in_first_order else sigma_next lowercase : Optional[Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": lowercase : Optional[Any] = model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`" ) if self.config.clip_sample: lowercase : str = pred_original_sample.clamp( -self.config.clip_sample_range ,self.config.clip_sample_range ) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order lowercase : Optional[int] = (sample - pred_original_sample) / sigma_hat # 3. delta timestep lowercase : Union[str, Any] = sigma_next - sigma_hat # store for 2nd order step lowercase : Optional[int] = derivative lowercase : Union[str, Any] = dt lowercase : Union[str, Any] = sample else: # 2. 2nd order / Heun's method lowercase : Tuple = (sample - pred_original_sample) / sigma_next lowercase : Dict = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample lowercase : Tuple = self.dt lowercase : Optional[Any] = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" lowercase : List[str] = None lowercase : Tuple = None lowercase : Dict = None lowercase : List[Any] = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[int] = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype ) if original_samples.device.type == "mps" and torch.is_floating_point(snake_case ): # mps does not support float64 lowercase : List[Any] = self.timesteps.to(original_samples.device ,dtype=torch.floataa ) lowercase : List[str] = timesteps.to(original_samples.device ,dtype=torch.floataa ) else: lowercase : List[str] = self.timesteps.to(original_samples.device ) lowercase : Tuple = timesteps.to(original_samples.device ) lowercase : Any = [self.index_for_timestep(snake_case ,snake_case ) for t in timesteps] lowercase : int = sigmas[step_indices].flatten() while len(sigma.shape ) < len(original_samples.shape ): lowercase : Any = sigma.unsqueeze(-1 ) lowercase : Optional[int] = original_samples + noise * sigma return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
1
import math_equivalence # From: git+https://github.com/hendrycks/math.git import datasets lowercase : Optional[int] = """\ @article{hendrycksmath2021, title={Measuring Mathematical Problem Solving With the MATH Dataset}, author={Dan Hendrycks and Collin Burns and Saurav Kadavath and Akul Arora and Steven Basart and Eric Tang and Dawn Song and Jacob Steinhardt}, journal={arXiv preprint arXiv:2103.03874}, year={2021} } """ lowercase : Any = """\ This metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset. It first canonicalizes the inputs (e.g., converting \"1/2\" to \"\\frac{1}{2}\") and then computes accuracy. """ lowercase : Any = R""" Calculates accuracy after canonicalizing inputs. Args: predictions: list of predictions to score. Each prediction is a string that contains natural language and LaTex. references: list of reference for each prediction. Each reference is a string that contains natural language and LaTex. Returns: accuracy: accuracy after canonicalizing inputs (e.g., converting \"1/2\" to \"\\frac{1}{2}\") Examples: >>> metric = datasets.load_metric(\"competition_math\") >>> results = metric.compute(references=[\"\\frac{1}{2}\"], predictions=[\"1/2\"]) >>> print(results) {'accuracy': 1.0} """ @datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""string""" ), """references""": datasets.Value("""string""" ), } ) ,homepage="""https://github.com/hendrycks/math""" ,codebase_urls=["""https://github.com/hendrycks/math"""] ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = 0.0 for i, j in zip(snake_case ,snake_case ): n_correct += 1.0 if math_equivalence.is_equiv(snake_case ,snake_case ) else 0.0 lowercase : Optional[int] = n_correct / len(snake_case ) return { "accuracy": accuracy, }
20
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch lowercase : List[str] = logging.get_logger(__name__) @add_end_docstrings( lowerCAmelCase , R"\n top_k (`int`, defaults to 5):\n The number of predictions to return.\n targets (`str` or `List[str]`, *optional*):\n When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n token will be used (with a warning, and that might be slower).\n\n " , ) class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if self.framework == "tf": lowercase : str = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": lowercase : Optional[int] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ) else: raise ValueError("""Unsupported framework""" ) return masked_index def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = self.get_masked_index(snake_case ) lowercase : Dict = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,f"No mask_token ({self.tokenizer.mask_token}) found on the input" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if isinstance(snake_case ,snake_case ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,**snake_case ): '''simple docstring''' if return_tensors is None: lowercase : int = self.framework lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=snake_case ) self.ensure_exactly_one_mask_token(snake_case ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[int] = self.model(**snake_case ) lowercase : Tuple = model_inputs["""input_ids"""] return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ,snake_case=None ): '''simple docstring''' if target_ids is not None and target_ids.shape[0] < top_k: lowercase : str = target_ids.shape[0] lowercase : Optional[Any] = model_outputs["""input_ids"""][0] lowercase : List[str] = model_outputs["""logits"""] if self.framework == "tf": lowercase : List[str] = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] lowercase : Tuple = outputs.numpy() lowercase : Tuple = outputs[0, masked_index, :] lowercase : Any = stable_softmax(snake_case ,axis=-1 ) if target_ids is not None: lowercase : Union[str, Any] = tf.gather_nd(tf.squeeze(snake_case ,0 ) ,target_ids.reshape(-1 ,1 ) ) lowercase : int = tf.expand_dims(snake_case ,0 ) lowercase : Tuple = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : int = topk.values.numpy(), topk.indices.numpy() else: lowercase : Optional[Any] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample lowercase : Union[str, Any] = outputs[0, masked_index, :] lowercase : Tuple = logits.softmax(dim=-1 ) if target_ids is not None: lowercase : List[str] = probs[..., target_ids] lowercase , lowercase : Union[str, Any] = probs.topk(snake_case ) lowercase : Any = [] lowercase : List[Any] = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() ,predictions.tolist() ) ): lowercase : Dict = [] for v, p in zip(_values ,_predictions ): # Copy is important since we're going to modify this array in place lowercase : Dict = input_ids.numpy().copy() if target_ids is not None: lowercase : Union[str, Any] = target_ids[p].tolist() lowercase : Tuple = p # Filter padding out: lowercase : List[str] = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back lowercase : Tuple = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : Optional[Any] = {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p] ), """sequence""": sequence} row.append(snake_case ) result.append(snake_case ) if single_mask: return result[0] return result def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if isinstance(snake_case ,snake_case ): lowercase : List[Any] = [targets] try: lowercase : List[str] = self.tokenizer.get_vocab() except Exception: lowercase : Any = {} lowercase : Dict = [] for target in targets: lowercase : Dict = vocab.get(snake_case ,snake_case ) if id_ is None: lowercase : Optional[int] = self.tokenizer( snake_case ,add_special_tokens=snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,max_length=1 ,truncation=snake_case ,)["""input_ids"""] if len(snake_case ) == 0: logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " """We cannot replace it with anything meaningful, ignoring it""" ) continue lowercase : Union[str, Any] = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`." ) target_ids.append(id_ ) lowercase : Optional[Any] = list(set(snake_case ) ) if len(snake_case ) == 0: raise ValueError("""At least one target must be provided when passed.""" ) lowercase : Optional[Any] = np.array(snake_case ) return target_ids def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : Dict = {} if targets is not None: lowercase : str = self.get_target_ids(snake_case ,snake_case ) lowercase : List[Any] = target_ids if top_k is not None: lowercase : List[str] = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,"""The tokenizer does not define a `mask_token`.""" ) return {}, {}, postprocess_params def __call__( self ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Tuple = super().__call__(snake_case ,**snake_case ) if isinstance(snake_case ,snake_case ) and len(snake_case ) == 1: return outputs[0] return outputs
20
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase : Optional[Any] = logging.get_logger(__name__) lowercase : Optional[int] = { """camembert-base""": """https://huggingface.co/camembert-base/resolve/main/config.json""", """umberto-commoncrawl-cased-v1""": ( """https://huggingface.co/Musixmatch/umberto-commoncrawl-cased-v1/resolve/main/config.json""" ), """umberto-wikipedia-uncased-v1""": ( """https://huggingface.co/Musixmatch/umberto-wikipedia-uncased-v1/resolve/main/config.json""" ), } class __snake_case ( lowerCAmelCase ): _a : Any= "camembert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=1 ,snake_case=0 ,snake_case=2 ,snake_case="absolute" ,snake_case=True ,snake_case=None ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : List[Any] = vocab_size lowercase : Tuple = hidden_size lowercase : Union[str, Any] = num_hidden_layers lowercase : List[str] = num_attention_heads lowercase : Optional[Any] = hidden_act lowercase : Tuple = intermediate_size lowercase : Any = hidden_dropout_prob lowercase : List[str] = attention_probs_dropout_prob lowercase : Dict = max_position_embeddings lowercase : Tuple = type_vocab_size lowercase : Union[str, Any] = initializer_range lowercase : Tuple = layer_norm_eps lowercase : Dict = position_embedding_type lowercase : Union[str, Any] = use_cache lowercase : Optional[int] = classifier_dropout class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.task == "multiple-choice": lowercase : Union[str, Any] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: lowercase : Union[str, Any] = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ] )
20
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 MobileNetVaImageProcessor class __snake_case ( unittest.TestCase ): def __init__( self ,snake_case ,snake_case=7 ,snake_case=3 ,snake_case=18 ,snake_case=30 ,snake_case=400 ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=None ,): '''simple docstring''' lowercase : Dict = size if size is not None else {"""shortest_edge""": 20} lowercase : Union[str, Any] = crop_size if crop_size is not None else {"""height""": 18, """width""": 18} lowercase : str = parent lowercase : int = batch_size lowercase : str = num_channels lowercase : int = image_size lowercase : List[str] = min_resolution lowercase : str = max_resolution lowercase : Dict = do_resize lowercase : Dict = size lowercase : Dict = do_center_crop lowercase : str = crop_size def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, } @require_torch @require_vision class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Any= MobileNetVaImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = MobileNetVaImageProcessingTester(self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case ,"""do_resize""" ) ) self.assertTrue(hasattr(snake_case ,"""size""" ) ) self.assertTrue(hasattr(snake_case ,"""do_center_crop""" ) ) self.assertTrue(hasattr(snake_case ,"""crop_size""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 20} ) self.assertEqual(image_processor.crop_size ,{"""height""": 18, """width""": 18} ) lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 ,crop_size=84 ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 42} ) self.assertEqual(image_processor.crop_size ,{"""height""": 84, """width""": 84} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowercase : str = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,Image.Image ) # Test not batched input lowercase : Dict = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : Tuple = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,numpify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,np.ndarray ) # Test not batched input lowercase : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,torchify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,torch.Tensor ) # Test not batched input lowercase : Optional[int] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,)
20
1
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 lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[Any] = { """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 ( lowerCAmelCase ): _a : str= "gpt_neo" _a : Optional[int]= ["past_key_values"] _a : Dict= {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self ,snake_case=50257 ,snake_case=2048 ,snake_case=2048 ,snake_case=24 ,snake_case=[[["global", "local"], 12]] ,snake_case=16 ,snake_case=None ,snake_case=256 ,snake_case="gelu_new" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=1e-5 ,snake_case=0.02 ,snake_case=True ,snake_case=50256 ,snake_case=50256 ,**snake_case ,): '''simple docstring''' lowercase : int = vocab_size lowercase : Union[str, Any] = max_position_embeddings lowercase : Dict = hidden_size lowercase : Union[str, Any] = num_layers lowercase : Union[str, Any] = num_heads lowercase : Optional[int] = intermediate_size lowercase : List[str] = window_size lowercase : Optional[int] = activation_function lowercase : List[str] = resid_dropout lowercase : int = embed_dropout lowercase : Optional[int] = attention_dropout lowercase : Tuple = classifier_dropout lowercase : Optional[int] = layer_norm_epsilon lowercase : Dict = initializer_range lowercase : List[str] = use_cache lowercase : Optional[int] = bos_token_id lowercase : int = eos_token_id lowercase : Union[str, Any] = attention_types lowercase : Dict = self.expand_attention_types_params(snake_case ) 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=snake_case ,eos_token_id=snake_case ,**snake_case ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : List[Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: import torch lowercase : Tuple = input.size() lowercase : int = len(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = shape[dimension] lowercase : int = torch.arange(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.div(sizedim - size , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) + 1 lowercase : Dict = torch.arange(SCREAMING_SNAKE_CASE__ ) + low_indices[:min_length][:, None] lowercase : Union[str, Any] = [slice(SCREAMING_SNAKE_CASE__ )] * rank lowercase : Optional[Any] = indices lowercase : List[str] = input[s] lowercase : Optional[int] = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import torch lowercase : Union[str, Any] = torch.arange(1 , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.remainder(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = remainders == 0 lowercase : Optional[int] = candidates[divisor_indices] lowercase : List[Any] = torch.max(SCREAMING_SNAKE_CASE__ ) return largest_divisor, torch.div(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(snake_case ,direction="""inputs""" ) lowercase : Dict = {0: """batch""", 1: """past_sequence + sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} return common_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self._config.num_heads def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,): '''simple docstring''' lowercase : Any = super(snake_case ,self ).generate_dummy_inputs( snake_case ,batch_size=snake_case ,seq_length=snake_case ,is_pair=snake_case ,framework=snake_case ) # We need to order the input in the way they appears in the forward() lowercase : List[str] = 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 lowercase , lowercase : List[Any] = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowercase : Optional[int] = seqlen + 2 lowercase : int = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowercase : Optional[Any] = [ (torch.zeros(snake_case ), torch.zeros(snake_case )) for _ in range(self.num_layers ) ] lowercase : Optional[Any] = common_inputs["""attention_mask"""] if self.use_past: lowercase : Any = ordered_inputs["""attention_mask"""].dtype lowercase : Union[str, Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(snake_case ,snake_case ,dtype=snake_case )] ,dim=1 ) return ordered_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 13
20
from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef import datasets lowercase : str = """\ @inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019} } """ lowercase : Dict = """\ GLUE, the General Language Understanding Evaluation benchmark (https://gluebenchmark.com/) is a collection of resources for training, evaluating, and analyzing natural language understanding systems. """ lowercase : int = """ Compute GLUE evaluation metric associated to each GLUE dataset. Args: predictions: list of predictions to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. Returns: depending on the GLUE subset, one or several of: \"accuracy\": Accuracy \"f1\": F1 score \"pearson\": Pearson Correlation \"spearmanr\": Spearman Correlation \"matthews_correlation\": Matthew Correlation Examples: >>> glue_metric = datasets.load_metric('glue', 'sst2') # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"] >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> glue_metric = datasets.load_metric('glue', 'mrpc') # 'mrpc' or 'qqp' >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> glue_metric = datasets.load_metric('glue', 'stsb') >>> references = [0., 1., 2., 3., 4., 5.] >>> predictions = [0., 1., 2., 3., 4., 5.] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)}) {'pearson': 1.0, 'spearmanr': 1.0} >>> glue_metric = datasets.load_metric('glue', 'cola') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: return float((preds == labels).mean() ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = simple_accuracy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = float(fa_score(y_true=SCREAMING_SNAKE_CASE__ , y_pred=SCREAMING_SNAKE_CASE__ ) ) return { "accuracy": acc, "f1": fa, } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = float(pearsonr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) lowercase : Dict = float(spearmanr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) return { "pearson": pearson_corr, "spearmanr": spearman_corr, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config_name not in [ "sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans", ]: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), } ) ,codebase_urls=[] ,reference_urls=[] ,format="""numpy""" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if self.config_name == "cola": return {"matthews_correlation": matthews_corrcoef(snake_case ,snake_case )} elif self.config_name == "stsb": return pearson_and_spearman(snake_case ,snake_case ) elif self.config_name in ["mrpc", "qqp"]: return acc_and_fa(snake_case ,snake_case ) elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]: return {"accuracy": simple_accuracy(snake_case ,snake_case )} else: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" )
20
1
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase : List[str] = { """text_branch""": """text_model""", """audio_branch""": """audio_model.audio_encoder""", """attn""": """attention.self""", """self.proj""": """output.dense""", """attention.self_mask""": """attn_mask""", """mlp.fc1""": """intermediate.dense""", """mlp.fc2""": """output.dense""", """norm1""": """layernorm_before""", """norm2""": """layernorm_after""", """bn0""": """batch_norm""", } lowercase : Dict = AutoFeatureExtractor.from_pretrained("""laion/clap-htsat-unfused""", truncation="""rand_trunc""") def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=False ) -> Optional[Any]: lowercase , lowercase : Any = create_model( """HTSAT-tiny""" , """roberta""" , SCREAMING_SNAKE_CASE__ , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=SCREAMING_SNAKE_CASE__ , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Optional[int] = {} lowercase : Optional[int] = R""".*sequential.(\d+).*""" lowercase : Dict = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: lowercase : Dict = key.replace(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if re.match(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): # replace sequential layers with list lowercase : Optional[int] = re.match(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ).group(1 ) lowercase : Optional[Any] = key.replace(f"sequential.{sequential_layer}." , f"layers.{int(SCREAMING_SNAKE_CASE__ )//3}.linear." ) elif re.match(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): lowercase : Dict = int(re.match(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... lowercase : Any = 1 if projecton_layer == 0 else 2 lowercase : Dict = key.replace(f"_projection.{projecton_layer}." , f"_projection.linear{transformers_projection_layer}." ) if "audio" and "qkv" in key: # split qkv into query key and value lowercase : Dict = value lowercase : Union[str, Any] = mixed_qkv.size(0 ) // 3 lowercase : Any = mixed_qkv[:qkv_dim] lowercase : str = mixed_qkv[qkv_dim : qkv_dim * 2] lowercase : Optional[Any] = mixed_qkv[qkv_dim * 2 :] lowercase : Tuple = query_layer lowercase : Dict = key_layer lowercase : Union[str, Any] = value_layer else: lowercase : Tuple = value return model_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=False ) -> Tuple: lowercase , lowercase : List[str] = init_clap(SCREAMING_SNAKE_CASE__ , enable_fusion=SCREAMING_SNAKE_CASE__ ) clap_model.eval() lowercase : List[Any] = clap_model.state_dict() lowercase : str = rename_state_dict(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = ClapConfig() lowercase : List[str] = enable_fusion lowercase : Tuple = ClapModel(SCREAMING_SNAKE_CASE__ ) # ignore the spectrogram embedding layer model.load_state_dict(SCREAMING_SNAKE_CASE__ , strict=SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) transformers_config.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : int = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument("""--enable_fusion""", action="""store_true""", help="""Whether to enable fusion or not""") lowercase : Union[str, Any] = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = hex_num.strip() if not hex_num: raise ValueError("""No value was passed to the function""" ) lowercase : int = hex_num[0] == """-""" if is_negative: lowercase : List[Any] = hex_num[1:] try: lowercase : str = int(SCREAMING_SNAKE_CASE__ , 16 ) except ValueError: raise ValueError("""Invalid value was passed to the function""" ) lowercase : Dict = """""" while int_num > 0: lowercase : str = str(int_num % 2 ) + bin_str int_num >>= 1 return int(("""-""" + bin_str) if is_negative else bin_str ) if __name__ == "__main__": import doctest doctest.testmod()
20
from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class __snake_case : _a : int _a : TreeNode | None= None _a : TreeNode | None= None lowercase : Dict = namedtuple("""CoinsDistribResult""", """moves excess""") def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if root is None: return 0 # Validation def count_nodes(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(SCREAMING_SNAKE_CASE__ ) != count_coins(SCREAMING_SNAKE_CASE__ ): raise ValueError("""The nodes number should be same as the number of coins""" ) # Main calculation def get_distrib(SCREAMING_SNAKE_CASE__ ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 , 1 ) lowercase , lowercase : int = get_distrib(node.left ) lowercase , lowercase : List[Any] = get_distrib(node.right ) lowercase : Optional[Any] = 1 - left_distrib_excess lowercase : Union[str, Any] = 1 - right_distrib_excess lowercase : List[Any] = ( left_distrib_moves + right_distrib_moves + abs(SCREAMING_SNAKE_CASE__ ) + abs(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = node.data - coins_to_left - coins_to_right return CoinsDistribResult(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return get_distrib(SCREAMING_SNAKE_CASE__ )[0] if __name__ == "__main__": import doctest doctest.testmod()
20
1
import numpy as np from sklearn.datasets import fetch_california_housing from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.model_selection import train_test_split from xgboost import XGBRegressor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> tuple: return (data["data"], data["target"]) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> np.ndarray: lowercase : int = XGBRegressor(verbosity=0 , random_state=42 ) xgb.fit(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) # Predict target for test data lowercase : List[str] = xgb.predict(SCREAMING_SNAKE_CASE__ ) lowercase : Any = predictions.reshape(len(SCREAMING_SNAKE_CASE__ ) , 1 ) return predictions def _snake_case( ) -> None: lowercase : str = fetch_california_housing() lowercase , lowercase : str = data_handling(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase , lowercase : List[Any] = train_test_split( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , test_size=0.25 , random_state=1 ) lowercase : str = xgboost(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) # Error printing print(f"Mean Absolute Error : {mean_absolute_error(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )}" ) print(f"Mean Square Error : {mean_squared_error(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )}" ) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
20
from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline lowercase : Optional[Any] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,**snake_case ): '''simple docstring''' super().__init__(**snake_case ) if self.framework != "pt": raise ValueError(f"The {self.__class__} is only available in PyTorch." ) # No specific FOR_XXX available yet def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : Union[str, Any] = {} if "candidate_labels" in kwargs: lowercase : List[str] = kwargs["""candidate_labels"""] if "hypothesis_template" in kwargs: lowercase : Dict = kwargs["""hypothesis_template"""] return preprocess_params, {}, {} def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case="This is a sound of {}." ): '''simple docstring''' if isinstance(snake_case ,snake_case ): if audio.startswith("""http://""" ) or audio.startswith("""https://""" ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png lowercase : Optional[Any] = requests.get(snake_case ).content else: with open(snake_case ,"""rb""" ) as f: lowercase : Union[str, Any] = f.read() if isinstance(snake_case ,snake_case ): lowercase : int = ffmpeg_read(snake_case ,self.feature_extractor.sampling_rate ) if not isinstance(snake_case ,np.ndarray ): raise ValueError("""We expect a numpy ndarray as input""" ) if len(audio.shape ) != 1: raise ValueError("""We expect a single channel audio input for ZeroShotAudioClassificationPipeline""" ) lowercase : Dict = self.feature_extractor( [audio] ,sampling_rate=self.feature_extractor.sampling_rate ,return_tensors="""pt""" ) lowercase : Tuple = candidate_labels lowercase : Tuple = [hypothesis_template.format(snake_case ) for x in candidate_labels] lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=self.framework ,padding=snake_case ) lowercase : Optional[Any] = [text_inputs] return inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = model_inputs.pop("""candidate_labels""" ) lowercase : Dict = model_inputs.pop("""text_inputs""" ) if isinstance(text_inputs[0] ,snake_case ): lowercase : List[Any] = text_inputs[0] else: # Batching case. lowercase : Dict = text_inputs[0][0] lowercase : Optional[Any] = self.model(**snake_case ,**snake_case ) lowercase : Any = { """candidate_labels""": candidate_labels, """logits""": outputs.logits_per_audio, } return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = model_outputs.pop("""candidate_labels""" ) lowercase : Any = model_outputs["""logits"""][0] if self.framework == "pt": lowercase : Any = logits.softmax(dim=0 ) lowercase : Tuple = probs.tolist() else: raise ValueError("""`tf` framework not supported.""" ) lowercase : Tuple = [ {"""score""": score, """label""": candidate_label} for score, candidate_label in sorted(zip(snake_case ,snake_case ) ,key=lambda snake_case : -x[0] ) ] return result
20
1
from __future__ import annotations import time lowercase : Optional[int] = list[tuple[int, int]] lowercase : List[Any] = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], # 0 are free path whereas 1's are obstacles [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], ] lowercase : Optional[int] = [[-1, 0], [0, -1], [1, 0], [0, 1]] # up, left, down, right class __snake_case : def __init__( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Tuple = pos_x lowercase : str = pos_y lowercase : Any = (pos_y, pos_x) lowercase : int = goal_x lowercase : int = goal_y lowercase : Dict = parent class __snake_case : def __init__( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[Any] = Node(start[1] ,start[0] ,goal[1] ,goal[0] ,snake_case ) lowercase : Optional[Any] = Node(goal[1] ,goal[0] ,goal[1] ,goal[0] ,snake_case ) lowercase : Union[str, Any] = [self.start] lowercase : Any = False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' while self.node_queue: lowercase : int = self.node_queue.pop(0 ) if current_node.pos == self.target.pos: lowercase : Dict = True return self.retrace_path(snake_case ) lowercase : List[str] = self.get_successors(snake_case ) for node in successors: self.node_queue.append(snake_case ) if not self.reached: return [self.start.pos] return None def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = [] for action in delta: lowercase : Any = parent.pos_x + action[1] lowercase : str = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0] ) - 1 and 0 <= pos_y <= len(snake_case ) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node(snake_case ,snake_case ,self.target.pos_y ,self.target.pos_x ,snake_case ) ) return successors def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = node lowercase : str = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x) ) lowercase : Tuple = current_node.parent path.reverse() return path class __snake_case : def __init__( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : int = BreadthFirstSearch(snake_case ,snake_case ) lowercase : Any = BreadthFirstSearch(snake_case ,snake_case ) lowercase : Union[str, Any] = False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' while self.fwd_bfs.node_queue or self.bwd_bfs.node_queue: lowercase : Any = self.fwd_bfs.node_queue.pop(0 ) lowercase : Optional[int] = self.bwd_bfs.node_queue.pop(0 ) if current_bwd_node.pos == current_fwd_node.pos: lowercase : int = True return self.retrace_bidirectional_path( snake_case ,snake_case ) lowercase : Dict = current_bwd_node lowercase : List[Any] = current_fwd_node lowercase : Optional[Any] = { self.fwd_bfs: self.fwd_bfs.get_successors(snake_case ), self.bwd_bfs: self.bwd_bfs.get_successors(snake_case ), } for bfs in [self.fwd_bfs, self.bwd_bfs]: for node in successors[bfs]: bfs.node_queue.append(snake_case ) if not self.reached: return [self.fwd_bfs.start.pos] return None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = self.fwd_bfs.retrace_path(snake_case ) lowercase : Union[str, Any] = self.bwd_bfs.retrace_path(snake_case ) bwd_path.pop() bwd_path.reverse() lowercase : Tuple = fwd_path + bwd_path return path if __name__ == "__main__": # all coordinates are given in format [y,x] import doctest doctest.testmod() lowercase : Tuple = (0, 0) lowercase : Union[str, Any] = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) lowercase : Dict = time.time() lowercase : Optional[int] = BreadthFirstSearch(init, goal) lowercase : Dict = bfs.search() lowercase : Dict = time.time() - start_bfs_time print("""Unidirectional BFS computation time : """, bfs_time) lowercase : List[str] = time.time() lowercase : int = BidirectionalBreadthFirstSearch(init, goal) lowercase : Any = bd_bfs.search() lowercase : Dict = time.time() - start_bd_bfs_time print("""Bidirectional BFS computation time : """, bd_bfs_time)
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def _snake_case( *SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=2 ) -> Optional[Any]: from .. import __version__ lowercase : int = take_from lowercase : Tuple = () if not isinstance(args[0] , SCREAMING_SNAKE_CASE__ ): lowercase : Dict = (args,) for attribute, version_name, message in args: if version.parse(version.parse(SCREAMING_SNAKE_CASE__ ).base_version ) >= version.parse(SCREAMING_SNAKE_CASE__ ): raise ValueError( f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'" f" version {__version__} is >= {version_name}" ) lowercase : int = None if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(SCREAMING_SNAKE_CASE__ ),) lowercase : Union[str, Any] = f"The `{attribute}` argument is deprecated and will be removed in version {version_name}." elif hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): values += (getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ),) lowercase : int = f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}." elif deprecated_kwargs is None: lowercase : Dict = f"`{attribute}` is deprecated and will be removed in version {version_name}." if warning is not None: lowercase : Dict = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , SCREAMING_SNAKE_CASE__ , stacklevel=SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and len(SCREAMING_SNAKE_CASE__ ) > 0: lowercase : str = inspect.getouterframes(inspect.currentframe() )[1] lowercase : List[str] = call_frame.filename lowercase : Tuple = call_frame.lineno lowercase : List[str] = call_frame.function lowercase , lowercase : Optional[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: return elif len(SCREAMING_SNAKE_CASE__ ) == 1: return values[0] return values
20
1
import json import os import unittest from transformers.models.roc_bert.tokenization_roc_bert import ( VOCAB_FILES_NAMES, RoCBertBasicTokenizer, RoCBertTokenizer, RoCBertWordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english @require_tokenizers class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : str= RoCBertTokenizer _a : str= None _a : str= False _a : Union[str, Any]= True _a : List[str]= filter_non_english def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setUp() lowercase : Any = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """你""", """好""", """是""", """谁""", """a""", """b""", """c""", """d"""] lowercase : Optional[int] = {} lowercase : List[str] = {} for i, value in enumerate(snake_case ): lowercase : List[str] = i lowercase : Optional[int] = i lowercase : Optional[int] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["""vocab_file"""] ) lowercase : List[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["""word_shape_file"""] ) lowercase : List[str] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["""word_pronunciation_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.word_shape_file ,"""w""" ,encoding="""utf-8""" ) as word_shape_writer: json.dump(snake_case ,snake_case ,ensure_ascii=snake_case ) with open(self.word_pronunciation_file ,"""w""" ,encoding="""utf-8""" ) as word_pronunciation_writer: json.dump(snake_case ,snake_case ,ensure_ascii=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.tokenizer_class(self.vocab_file ,self.word_shape_file ,self.word_pronunciation_file ) lowercase : Tuple = tokenizer.tokenize("""你好[SEP]你是谁""" ) self.assertListEqual(snake_case ,["""你""", """好""", """[SEP]""", """你""", """是""", """谁"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case ) ,[5, 6, 2, 5, 7, 8] ) self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(snake_case ) ,[5, 6, 2, 5, 7, 8] ) self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(snake_case ) ,[5, 6, 2, 5, 7, 8] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = RoCBertBasicTokenizer() self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" ) ,["""ah""", """\u535A""", """\u63A8""", """zz"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = RoCBertBasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) ,["""hello""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = RoCBertBasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hällo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""h\u00E9llo"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = RoCBertBasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = RoCBertBasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) ,["""hello"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = RoCBertBasicTokenizer(do_lower_case=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = RoCBertBasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = RoCBertBasicTokenizer(do_lower_case=snake_case ,strip_accents=snake_case ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) ,["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = RoCBertBasicTokenizer(do_lower_case=snake_case ,never_split=["""[UNK]"""] ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? [UNK]""" ) ,["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""] lowercase : str = {} for i, token in enumerate(snake_case ): lowercase : Optional[Any] = i lowercase : str = RoCBertWordpieceTokenizer(vocab=snake_case ,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"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''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 _SCREAMING_SNAKE_CASE ( self ): '''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 _SCREAMING_SNAKE_CASE ( self ): '''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(""" """ ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_tokenizer() # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340 self.assertListEqual([tokenizer.tokenize(snake_case ) for t in ["""Test""", """\xad""", """test"""]] ,[["""[UNK]"""], [], ["""[UNK]"""]] ) if self.test_rust_tokenizer: lowercase : Union[str, Any] = self.get_rust_tokenizer() self.assertListEqual( [rust_tokenizer.tokenize(snake_case ) for t in ["""Test""", """\xad""", """test"""]] ,[["""[UNK]"""], [], ["""[UNK]"""]] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowercase : List[Any] = self.rust_tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : Optional[Any] = f"A, naïve {tokenizer_r.mask_token} AllenNLP sentence." lowercase : str = tokenizer_r.encode_plus( snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,return_offsets_mapping=snake_case ,add_special_tokens=snake_case ,) lowercase : int = tokenizer_r.do_lower_case if hasattr(snake_case ,"""do_lower_case""" ) else False lowercase : List[str] = ( [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """A"""), ((1, 2), ""","""), ((3, 5), """na"""), ((5, 6), """##ï"""), ((6, 8), """##ve"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """Allen"""), ((21, 23), """##NL"""), ((23, 24), """##P"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] if not do_lower_case else [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """a"""), ((1, 2), ""","""), ((3, 8), """naive"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """allen"""), ((21, 23), """##nl"""), ((23, 24), """##p"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] ) self.assertEqual( [e[1] for e in expected_results] ,tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""] ) ) self.assertEqual([e[0] for e in expected_results] ,tokens["""offset_mapping"""] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = ["""的""", """人""", """有"""] lowercase : List[str] = """""".join(snake_case ) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): lowercase : int = True lowercase : Any = self.tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : str = self.rust_tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : Dict = tokenizer_p.encode(snake_case ,add_special_tokens=snake_case ) lowercase : Optional[int] = tokenizer_r.encode(snake_case ,add_special_tokens=snake_case ) lowercase : Optional[Any] = tokenizer_r.convert_ids_to_tokens(snake_case ) lowercase : str = tokenizer_p.convert_ids_to_tokens(snake_case ) # it is expected that each Chinese character is not preceded by "##" self.assertListEqual(snake_case ,snake_case ) self.assertListEqual(snake_case ,snake_case ) lowercase : List[str] = False lowercase : Any = self.rust_tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : List[Any] = self.tokenizer_class.from_pretrained(snake_case ,**snake_case ) lowercase : Union[str, Any] = tokenizer_r.encode(snake_case ,add_special_tokens=snake_case ) lowercase : Optional[int] = tokenizer_p.encode(snake_case ,add_special_tokens=snake_case ) lowercase : str = tokenizer_r.convert_ids_to_tokens(snake_case ) lowercase : Optional[Any] = tokenizer_p.convert_ids_to_tokens(snake_case ) # it is expected that only the first Chinese character is not preceded by "##". lowercase : List[str] = [ f"##{token}" if idx != 0 else token for idx, token in enumerate(snake_case ) ] self.assertListEqual(snake_case ,snake_case ) self.assertListEqual(snake_case ,snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.tokenizer_class(self.vocab_file ,self.word_shape_file ,self.word_pronunciation_file ) lowercase : List[Any] = tokenizer.encode("""你好""" ,add_special_tokens=snake_case ) lowercase : Any = tokenizer.encode("""你是谁""" ,add_special_tokens=snake_case ) lowercase : int = tokenizer.build_inputs_with_special_tokens(snake_case ) lowercase : List[Any] = tokenizer.build_inputs_with_special_tokens(snake_case ,snake_case ) assert encoded_sentence == [1] + text + [2] assert encoded_pair == [1] + text + [2] + text_a + [2] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_tokenizers(do_lower_case=snake_case ) for tokenizer in tokenizers: with self.subTest(f"{tokenizer.__class__.__name__}" ): lowercase : Optional[Any] = """你好,你是谁""" lowercase : int = tokenizer.tokenize(snake_case ) lowercase : Tuple = tokenizer.convert_tokens_to_ids(snake_case ) lowercase : Dict = tokenizer.convert_tokens_to_shape_ids(snake_case ) lowercase : str = tokenizer.convert_tokens_to_pronunciation_ids(snake_case ) lowercase : int = tokenizer.prepare_for_model( snake_case ,snake_case ,snake_case ,add_special_tokens=snake_case ) lowercase : Union[str, Any] = tokenizer.encode_plus(snake_case ,add_special_tokens=snake_case ) self.assertEqual(snake_case ,snake_case )
20
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: if index == r: for j in range(SCREAMING_SNAKE_CASE__ ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location lowercase : Tuple = arr[i] combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 , SCREAMING_SNAKE_CASE__ , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # A temporary array to store all combination one by one lowercase : Optional[int] = [0] * r # Print all combination using temporary array 'data[]' combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , 0 , SCREAMING_SNAKE_CASE__ , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase : int = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
1
import multiprocessing import os from typing import BinaryIO, Optional, Union import fsspec from .. import Dataset, Features, NamedSplit, config from ..formatting import query_table from ..packaged_modules.json.json import Json from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader class __snake_case ( lowerCAmelCase ): def __init__( self ,snake_case ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = False ,snake_case = False ,snake_case = None ,snake_case = None ,**snake_case ,): '''simple docstring''' super().__init__( snake_case ,split=snake_case ,features=snake_case ,cache_dir=snake_case ,keep_in_memory=snake_case ,streaming=snake_case ,num_proc=snake_case ,**snake_case ,) lowercase : Optional[Any] = field lowercase : str = path_or_paths if isinstance(snake_case ,snake_case ) else {self.split: path_or_paths} lowercase : Dict = Json( cache_dir=snake_case ,data_files=snake_case ,features=snake_case ,field=snake_case ,**snake_case ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.streaming: lowercase : List[Any] = self.builder.as_streaming_dataset(split=self.split ) # Build regular (map-style) dataset else: lowercase : List[str] = None lowercase : Any = None lowercase : List[str] = None lowercase : str = None self.builder.download_and_prepare( download_config=snake_case ,download_mode=snake_case ,verification_mode=snake_case ,base_path=snake_case ,num_proc=self.num_proc ,) lowercase : Optional[int] = self.builder.as_dataset( split=self.split ,verification_mode=snake_case ,in_memory=self.keep_in_memory ) return dataset class __snake_case : def __init__( self ,snake_case ,snake_case ,snake_case = None ,snake_case = None ,**snake_case ,): '''simple docstring''' if num_proc is not None and num_proc <= 0: raise ValueError(f"num_proc {num_proc} must be an integer > 0." ) lowercase : Tuple = dataset lowercase : Optional[int] = path_or_buf lowercase : Optional[Any] = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE lowercase : Optional[Any] = num_proc lowercase : Tuple = """utf-8""" lowercase : Tuple = to_json_kwargs def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.to_json_kwargs.pop("""path_or_buf""" ,snake_case ) lowercase : Tuple = self.to_json_kwargs.pop("""orient""" ,"""records""" ) lowercase : List[str] = self.to_json_kwargs.pop("""lines""" ,True if orient == """records""" else False ) lowercase : Optional[int] = self.to_json_kwargs.pop("""index""" ,False if orient in ["""split""", """table"""] else True ) lowercase : str = self.to_json_kwargs.pop("""compression""" ,snake_case ) if compression not in [None, "infer", "gzip", "bz2", "xz"]: raise NotImplementedError(f"`datasets` currently does not support {compression} compression" ) if isinstance(self.path_or_buf ,(str, bytes, os.PathLike) ): with fsspec.open(self.path_or_buf ,"""wb""" ,compression=snake_case ) as buffer: lowercase : Union[str, Any] = self._write(file_obj=snake_case ,orient=snake_case ,lines=snake_case ,index=snake_case ,**self.to_json_kwargs ) else: if compression: raise NotImplementedError( f"The compression parameter is not supported when writing to a buffer, but compression={compression}" """ was passed. Please provide a local path instead.""" ) lowercase : Tuple = self._write( file_obj=self.path_or_buf ,orient=snake_case ,lines=snake_case ,index=snake_case ,**self.to_json_kwargs ) return written def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase , lowercase , lowercase , lowercase : Any = args lowercase : Optional[Any] = query_table( table=self.dataset.data ,key=slice(snake_case ,offset + self.batch_size ) ,indices=self.dataset._indices ,) lowercase : Any = batch.to_pandas().to_json( path_or_buf=snake_case ,orient=snake_case ,lines=snake_case ,index=snake_case ,**snake_case ) if not json_str.endswith("""\n""" ): json_str += "\n" return json_str.encode(self.encoding ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,**snake_case ,): '''simple docstring''' lowercase : Optional[int] = 0 if self.num_proc is None or self.num_proc == 1: for offset in logging.tqdm( range(0 ,len(self.dataset ) ,self.batch_size ) ,unit="""ba""" ,disable=not logging.is_progress_bar_enabled() ,desc="""Creating json from Arrow format""" ,): lowercase : Any = self._batch_json((offset, orient, lines, index, to_json_kwargs) ) written += file_obj.write(snake_case ) else: lowercase , lowercase : int = len(self.dataset ), self.batch_size with multiprocessing.Pool(self.num_proc ) as pool: for json_str in logging.tqdm( pool.imap( self._batch_json ,[(offset, orient, lines, index, to_json_kwargs) for offset in range(0 ,snake_case ,snake_case )] ,) ,total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size ,unit="""ba""" ,disable=not logging.is_progress_bar_enabled() ,desc="""Creating json from Arrow format""" ,): written += file_obj.write(snake_case ) return written
20
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : Optional[Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): lowercase : Any = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ , keep_in_memory=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : int = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} lowercase : str = features.copy() if features else default_expected_features lowercase : Optional[Any] = ( Features({feature: Value(SCREAMING_SNAKE_CASE__ ) for feature, dtype in features.items()} ) if features is not None else None ) lowercase : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__ ) ) as con: lowercase : Optional[int] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = tmp_path / """cache""" lowercase : int = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() lowercase : List[str] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Dict = tmp_path / """cache""" lowercase : List[str] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() lowercase : Optional[int] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : str = tmp_path / """cache""" lowercase : Optional[int] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : Optional[Any] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() with pytest.raises(SCREAMING_SNAKE_CASE__ ): SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
1
from __future__ import annotations from typing import TypedDict class __snake_case ( lowerCAmelCase ): _a : str _a : int def _snake_case( SCREAMING_SNAKE_CASE__ ) -> list[str]: if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise TypeError("""The parameter s type must be str.""" ) return [s[i:] + s[:i] for i in range(len(SCREAMING_SNAKE_CASE__ ) )] def _snake_case( SCREAMING_SNAKE_CASE__ ) -> BWTTransformDict: if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise TypeError("""The parameter s type must be str.""" ) if not s: raise ValueError("""The parameter s must not be empty.""" ) lowercase : List[Any] = all_rotations(SCREAMING_SNAKE_CASE__ ) rotations.sort() # sort the list of rotations in alphabetically order # make a string composed of the last char of each rotation lowercase : BWTTransformDict = { "bwt_string": "".join([word[-1] for word in rotations] ), "idx_original_string": rotations.index(SCREAMING_SNAKE_CASE__ ), } return response def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise TypeError("""The parameter bwt_string type must be str.""" ) if not bwt_string: raise ValueError("""The parameter bwt_string must not be empty.""" ) try: lowercase : List[str] = int(SCREAMING_SNAKE_CASE__ ) except ValueError: raise TypeError( """The parameter idx_original_string type must be int or passive""" """ of cast to int.""" ) if idx_original_string < 0: raise ValueError("""The parameter idx_original_string must not be lower than 0.""" ) if idx_original_string >= len(SCREAMING_SNAKE_CASE__ ): raise ValueError( """The parameter idx_original_string must be lower than""" """ len(bwt_string).""" ) lowercase : str = [""""""] * len(SCREAMING_SNAKE_CASE__ ) for _ in range(len(SCREAMING_SNAKE_CASE__ ) ): for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : List[str] = bwt_string[i] + ordered_rotations[i] ordered_rotations.sort() return ordered_rotations[idx_original_string] if __name__ == "__main__": lowercase : List[Any] = """Provide a string that I will generate its BWT transform: """ lowercase : int = input(entry_msg).strip() lowercase : List[Any] = bwt_transform(s) print( F'''Burrows Wheeler transform for string \'{s}\' results ''' F'''in \'{result["bwt_string"]}\'''' ) lowercase : Optional[Any] = reverse_bwt(result["""bwt_string"""], result["""idx_original_string"""]) print( F'''Reversing Burrows Wheeler transform for entry \'{result["bwt_string"]}\' ''' F'''we get original string \'{original_string}\'''' )
20
import os import numpy import onnx def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : int = a.name lowercase : Any = b.name lowercase : Optional[Any] = """""" lowercase : Dict = """""" lowercase : int = a == b lowercase : int = name_a lowercase : List[str] = name_b return res def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) _graph_replace_input_with(node_proto.attribute[1].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for n in graph_proto.node: _node_replace_input_with(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Any = list(model.graph.initializer ) lowercase : Dict = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i lowercase : Union[str, Any] = inits[i].name lowercase : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Union[str, Any] = os.path.dirname(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = os.path.basename(SCREAMING_SNAKE_CASE__ ) lowercase : str = onnx.load(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) lowercase : List[str] = list(model.graph.initializer ) lowercase : Tuple = set() lowercase : int = {} lowercase : Optional[Any] = [] lowercase : Dict = 0 for i in range(len(SCREAMING_SNAKE_CASE__ ) ): if i in dup_set: continue for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(SCREAMING_SNAKE_CASE__ ) dup_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : int = inits[j].data_type lowercase : Optional[int] = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 11: mem_size *= 8 else: print("""unexpected data type: """ , SCREAMING_SNAKE_CASE__ ) total_reduced_size += mem_size lowercase : Tuple = inits[i].name lowercase : int = inits[j].name if name_i in dup_map: dup_map[name_i].append(SCREAMING_SNAKE_CASE__ ) else: lowercase : List[str] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_024 / 1_024 / 1_024 , """GB""" ) lowercase : str = sorted(SCREAMING_SNAKE_CASE__ ) _remove_dup_initializers_from_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = """optimized_""" + model_file_name lowercase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) onnx.save(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return new_model
20
1
import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration lowercase : Union[str, Any] = 50000 lowercase : Optional[int] = 5000 lowercase , lowercase : List[str] = os.path.split(__file__) lowercase : int = os.path.join(RESULTS_BASEPATH, """results""", RESULTS_FILENAME.replace(""".py""", """.json""")) @get_duration def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Optional[int] = dataset[i] @get_duration def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for i in range(0 , len(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ): lowercase : str = dataset[i : i + batch_size] @get_duration def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: with dataset.formatted_as(type=SCREAMING_SNAKE_CASE__ ): for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Any = dataset[i] @get_duration def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: with dataset.formatted_as(type=SCREAMING_SNAKE_CASE__ ): for i in range(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = dataset[i : i + batch_size] def _snake_case( ) -> str: lowercase : Any = {"""num examples""": SPEED_TEST_N_EXAMPLES} lowercase : int = [ (read, {"""length""": SMALL_TEST}), (read, {"""length""": SPEED_TEST_N_EXAMPLES}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 10}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 100}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_000}), (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """pandas""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """torch""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """tensorflow""", """length""": SMALL_TEST}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 10}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_000}), ] lowercase : List[Any] = [ (read, {"""length""": SMALL_TEST}), (read, {"""length""": SPEED_TEST_N_EXAMPLES}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 10}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 100}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_000}), (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 10}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print("""generating dataset""" ) lowercase : int = datasets.Features( {"""list""": datasets.Sequence(datasets.Value("""float32""" ) ), """numbers""": datasets.Value("""float32""" )} ) lowercase : List[Any] = generate_example_dataset( os.path.join(SCREAMING_SNAKE_CASE__ , """dataset.arrow""" ) , SCREAMING_SNAKE_CASE__ , num_examples=SCREAMING_SNAKE_CASE__ , seq_shapes={"""list""": (100,)} , ) print("""first set of iterations""" ) for func, kwargs in functions: print(func.__name__ , str(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = func(SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) print("""shuffling dataset""" ) lowercase : Tuple = dataset.shuffle() print("""Second set of iterations (after shuffling""" ) for func, kwargs in functions_shuffled: print("""shuffled """ , func.__name__ , str(SCREAMING_SNAKE_CASE__ ) ) lowercase : Dict = func( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) with open(SCREAMING_SNAKE_CASE__ , """wb""" ) as f: f.write(json.dumps(SCREAMING_SNAKE_CASE__ ).encode("""utf-8""" ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
20
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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = [] embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight", f"stage{idx}.patch_embed.proj.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias", f"stage{idx}.patch_embed.proj.bias", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight", f"stage{idx}.patch_embed.norm.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias", f"stage{idx}.patch_embed.norm.bias", ) ) return embed def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Optional[Any] = [] 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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Optional[Any] = [] token.append((f"cvt.encoder.stages.{idx}.cls_token", """stage2.cls_token""") ) return token def _snake_case( ) -> Dict: lowercase : Optional[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 _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = """imagenet-1k-id2label.json""" lowercase : List[str] = 1_000 lowercase : int = """huggingface/label-files""" lowercase : Union[str, Any] = num_labels lowercase : Optional[Any] = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) ) , """r""" ) ) lowercase : List[Any] = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Dict = idalabel lowercase : List[str] = {v: k for k, v in idalabel.items()} lowercase : List[str] = CvtConfig(num_labels=SCREAMING_SNAKE_CASE__ , idalabel=SCREAMING_SNAKE_CASE__ , labelaid=SCREAMING_SNAKE_CASE__ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": lowercase : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": lowercase : Dict = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: lowercase : int = [2, 2, 20] lowercase : Optional[int] = [3, 12, 16] lowercase : str = [192, 768, 1_024] lowercase : Union[str, Any] = CvtForImageClassification(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) lowercase : Optional[Any] = image_size lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ , map_location=torch.device("""cpu""" ) ) lowercase : Optional[Any] = OrderedDict() lowercase : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: lowercase : Optional[Any] = list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__ ) lowercase : str = list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__ ) for cnt in range(config.depth[idx] ): lowercase : List[str] = list_of_state_dict + attention(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = list_of_state_dict + final() for gg in list_of_state_dict: print(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=384, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : Optional[int] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise ValueError("""Input series is not valid, valid series - [2, 4, 6]""" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: raise ValueError("""Input list must be a non empty list""" ) if len(SCREAMING_SNAKE_CASE__ ) == 1: return True lowercase : Any = series[1] - series[0] for index in range(len(SCREAMING_SNAKE_CASE__ ) - 1 ): if series[index + 1] - series[index] != common_diff: return False return True def _snake_case( SCREAMING_SNAKE_CASE__ ) -> float: if not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): raise ValueError("""Input series is not valid, valid series - [2, 4, 6]""" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: raise ValueError("""Input list must be a non empty list""" ) lowercase : List[str] = 0 for val in series: answer += val return answer / len(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": import doctest doctest.testmod()
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "microsoft/speecht5_tts" _a : Tuple= ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) _a : Dict= "text_reader" _a : Optional[Any]= SpeechTaProcessor _a : Tuple= SpeechTaForTextToSpeech _a : Optional[int]= SpeechTaHifiGan _a : Union[str, Any]= ["text"] _a : Optional[int]= ["audio"] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.post_processor is None: lowercase : Any = """microsoft/speecht5_hifigan""" super().setup() def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : int = self.pre_processor(text=snake_case ,return_tensors="""pt""" ,truncation=snake_case ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) lowercase : Tuple = load_dataset("""Matthijs/cmu-arctic-xvectors""" ,split="""validation""" ) lowercase : List[str] = torch.tensor(embeddings_dataset[7305]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.model.generate_speech(**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.post_processor(snake_case ).cpu().detach()
20
1
import argparse import os import gluonnlp as nlp import mxnet as mx import numpy as np import torch from gluonnlp.base import get_home_dir from gluonnlp.model.bert import BERTEncoder from gluonnlp.model.utils import _load_vocab from gluonnlp.vocab import Vocab from packaging import version from torch import nn from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer from transformers.models.bert.modeling_bert import ( BertIntermediate, BertLayer, BertOutput, BertSelfAttention, BertSelfOutput, ) from transformers.utils import logging if version.parse(nlp.__version__) != version.parse("""0.8.3"""): raise Exception("""requires gluonnlp == 0.8.3""") if version.parse(mx.__version__) != version.parse("""1.5.0"""): raise Exception("""requires mxnet == 1.5.0""") logging.set_verbosity_info() lowercase : List[Any] = logging.get_logger(__name__) lowercase : List[str] = """The Nymphenburg Palace is a beautiful palace in Munich!""" def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = { """attention_cell""": """multi_head""", """num_layers""": 4, """units""": 1_024, """hidden_size""": 768, """max_length""": 512, """num_heads""": 8, """scaled""": True, """dropout""": 0.1, """use_residual""": True, """embed_size""": 1_024, """embed_dropout""": 0.1, """word_embed""": None, """layer_norm_eps""": 1e-5, """token_type_vocab_size""": 2, } lowercase : List[Any] = bort_4_8_768_1024_hparams # Let's construct the original Bort model here # Taken from official BERT implementation, see: # https://github.com/alexa/bort/blob/master/bort/bort.py lowercase : Union[str, Any] = BERTEncoder( attention_cell=predefined_args["""attention_cell"""] , num_layers=predefined_args["""num_layers"""] , units=predefined_args["""units"""] , hidden_size=predefined_args["""hidden_size"""] , max_length=predefined_args["""max_length"""] , num_heads=predefined_args["""num_heads"""] , scaled=predefined_args["""scaled"""] , dropout=predefined_args["""dropout"""] , output_attention=SCREAMING_SNAKE_CASE__ , output_all_encodings=SCREAMING_SNAKE_CASE__ , use_residual=predefined_args["""use_residual"""] , activation=predefined_args.get("""activation""" , """gelu""" ) , layer_norm_eps=predefined_args.get("""layer_norm_eps""" , SCREAMING_SNAKE_CASE__ ) , ) # Vocab information needs to be fetched first # It's the same as RoBERTa, so RobertaTokenizer can be used later lowercase : Any = """openwebtext_ccnews_stories_books_cased""" # Specify download folder to Gluonnlp's vocab lowercase : Optional[int] = os.path.join(get_home_dir() , """models""" ) lowercase : List[Any] = _load_vocab(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , cls=SCREAMING_SNAKE_CASE__ ) lowercase : int = nlp.model.BERTModel( SCREAMING_SNAKE_CASE__ , len(SCREAMING_SNAKE_CASE__ ) , units=predefined_args["""units"""] , embed_size=predefined_args["""embed_size"""] , embed_dropout=predefined_args["""embed_dropout"""] , word_embed=predefined_args["""word_embed"""] , use_pooler=SCREAMING_SNAKE_CASE__ , use_token_type_embed=SCREAMING_SNAKE_CASE__ , token_type_vocab_size=predefined_args["""token_type_vocab_size"""] , use_classifier=SCREAMING_SNAKE_CASE__ , use_decoder=SCREAMING_SNAKE_CASE__ , ) original_bort.load_parameters(SCREAMING_SNAKE_CASE__ , cast_dtype=SCREAMING_SNAKE_CASE__ , ignore_extra=SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = original_bort._collect_params_with_prefix() # Build our config 🤗 lowercase : Union[str, Any] = { """architectures""": ["""BertForMaskedLM"""], """attention_probs_dropout_prob""": predefined_args["""dropout"""], """hidden_act""": """gelu""", """hidden_dropout_prob""": predefined_args["""dropout"""], """hidden_size""": predefined_args["""embed_size"""], """initializer_range""": 0.02, """intermediate_size""": predefined_args["""hidden_size"""], """layer_norm_eps""": predefined_args["""layer_norm_eps"""], """max_position_embeddings""": predefined_args["""max_length"""], """model_type""": """bort""", """num_attention_heads""": predefined_args["""num_heads"""], """num_hidden_layers""": predefined_args["""num_layers"""], """pad_token_id""": 1, # 2 = BERT, 1 = RoBERTa """type_vocab_size""": 1, # 2 = BERT, 1 = RoBERTa """vocab_size""": len(SCREAMING_SNAKE_CASE__ ), } lowercase : Dict = BertConfig.from_dict(SCREAMING_SNAKE_CASE__ ) lowercase : Any = BertForMaskedLM(SCREAMING_SNAKE_CASE__ ) hf_bort_model.eval() # Parameter mapping table (Gluonnlp to Transformers) # * denotes layer index # # | Gluon Parameter | Transformers Parameter # | -------------------------------------------------------------- | ---------------------- # | `encoder.layer_norm.beta` | `bert.embeddings.LayerNorm.bias` # | `encoder.layer_norm.gamma` | `bert.embeddings.LayerNorm.weight` # | `encoder.position_weight` | `bert.embeddings.position_embeddings.weight` # | `word_embed.0.weight` | `bert.embeddings.word_embeddings.weight` # | `encoder.transformer_cells.*.attention_cell.proj_key.bias` | `bert.encoder.layer.*.attention.self.key.bias` # | `encoder.transformer_cells.*.attention_cell.proj_key.weight` | `bert.encoder.layer.*.attention.self.key.weight` # | `encoder.transformer_cells.*.attention_cell.proj_query.bias` | `bert.encoder.layer.*.attention.self.query.bias` # | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight` # | `encoder.transformer_cells.*.attention_cell.proj_value.bias` | `bert.encoder.layer.*.attention.self.value.bias` # | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight` # | `encoder.transformer_cells.*.ffn.ffn_2.bias` | `bert.encoder.layer.*.attention.output.dense.bias` # | `encoder.transformer_cells.*.ffn.ffn_2.weight` | `bert.encoder.layer.*.attention.output.dense.weight` # | `encoder.transformer_cells.*.layer_norm.beta` | `bert.encoder.layer.*.attention.output.LayerNorm.bias` # | `encoder.transformer_cells.*.layer_norm.gamma` | `bert.encoder.layer.*.attention.output.LayerNorm.weight` # | `encoder.transformer_cells.*.ffn.ffn_1.bias` | `bert.encoder.layer.*.intermediate.dense.bias` # | `encoder.transformer_cells.*.ffn.ffn_1.weight` | `bert.encoder.layer.*.intermediate.dense.weight` # | `encoder.transformer_cells.*.ffn.layer_norm.beta` | `bert.encoder.layer.*.output.LayerNorm.bias` # | `encoder.transformer_cells.*.ffn.layer_norm.gamma` | `bert.encoder.layer.*.output.LayerNorm.weight` # | `encoder.transformer_cells.*.proj.bias` | `bert.encoder.layer.*.output.dense.bias` # | `encoder.transformer_cells.*.proj.weight` | `bert.encoder.layer.*.output.dense.weight` # Helper function to convert MXNET Arrays to PyTorch def to_torch(SCREAMING_SNAKE_CASE__ ) -> nn.Parameter: return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy() ) ) # Check param shapes and map new HF param back def check_and_map_params(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): lowercase : Tuple = hf_param.shape lowercase : int = to_torch(params[gluon_param] ) lowercase : str = gluon_param.shape assert ( shape_hf == shape_gluon ), f"The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers" return gluon_param lowercase : List[str] = check_and_map_params( hf_bort_model.bert.embeddings.word_embeddings.weight , """word_embed.0.weight""" ) lowercase : Dict = check_and_map_params( hf_bort_model.bert.embeddings.position_embeddings.weight , """encoder.position_weight""" ) lowercase : Union[str, Any] = check_and_map_params( hf_bort_model.bert.embeddings.LayerNorm.bias , """encoder.layer_norm.beta""" ) lowercase : int = check_and_map_params( hf_bort_model.bert.embeddings.LayerNorm.weight , """encoder.layer_norm.gamma""" ) # Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them) lowercase : Tuple = torch.zeros_like( hf_bort_model.bert.embeddings.token_type_embeddings.weight.data ) for i in range(hf_bort_config.num_hidden_layers ): lowercase : BertLayer = hf_bort_model.bert.encoder.layer[i] # self attention lowercase : BertSelfAttention = layer.attention.self lowercase : Any = check_and_map_params( self_attn.key.bias.data , f"encoder.transformer_cells.{i}.attention_cell.proj_key.bias" ) lowercase : str = check_and_map_params( self_attn.key.weight.data , f"encoder.transformer_cells.{i}.attention_cell.proj_key.weight" ) lowercase : Any = check_and_map_params( self_attn.query.bias.data , f"encoder.transformer_cells.{i}.attention_cell.proj_query.bias" ) lowercase : List[str] = check_and_map_params( self_attn.query.weight.data , f"encoder.transformer_cells.{i}.attention_cell.proj_query.weight" ) lowercase : List[str] = check_and_map_params( self_attn.value.bias.data , f"encoder.transformer_cells.{i}.attention_cell.proj_value.bias" ) lowercase : Optional[Any] = check_and_map_params( self_attn.value.weight.data , f"encoder.transformer_cells.{i}.attention_cell.proj_value.weight" ) # self attention output lowercase : BertSelfOutput = layer.attention.output lowercase : List[Any] = check_and_map_params( self_output.dense.bias , f"encoder.transformer_cells.{i}.proj.bias" ) lowercase : Optional[Any] = check_and_map_params( self_output.dense.weight , f"encoder.transformer_cells.{i}.proj.weight" ) lowercase : Union[str, Any] = check_and_map_params( self_output.LayerNorm.bias , f"encoder.transformer_cells.{i}.layer_norm.beta" ) lowercase : List[str] = check_and_map_params( self_output.LayerNorm.weight , f"encoder.transformer_cells.{i}.layer_norm.gamma" ) # intermediate lowercase : BertIntermediate = layer.intermediate lowercase : Dict = check_and_map_params( intermediate.dense.bias , f"encoder.transformer_cells.{i}.ffn.ffn_1.bias" ) lowercase : str = check_and_map_params( intermediate.dense.weight , f"encoder.transformer_cells.{i}.ffn.ffn_1.weight" ) # output lowercase : BertOutput = layer.output lowercase : Optional[Any] = check_and_map_params( bert_output.dense.bias , f"encoder.transformer_cells.{i}.ffn.ffn_2.bias" ) lowercase : int = check_and_map_params( bert_output.dense.weight , f"encoder.transformer_cells.{i}.ffn.ffn_2.weight" ) lowercase : str = check_and_map_params( bert_output.LayerNorm.bias , f"encoder.transformer_cells.{i}.ffn.layer_norm.beta" ) lowercase : List[str] = check_and_map_params( bert_output.LayerNorm.weight , f"encoder.transformer_cells.{i}.ffn.layer_norm.gamma" ) # Save space and energy 🎄 hf_bort_model.half() # Compare output of both models lowercase : List[Any] = RobertaTokenizer.from_pretrained("""roberta-base""" ) lowercase : int = tokenizer.encode_plus(SCREAMING_SNAKE_CASE__ )["""input_ids"""] # Get gluon output lowercase : Any = mx.nd.array([input_ids] ) lowercase : List[Any] = original_bort(inputs=SCREAMING_SNAKE_CASE__ , token_types=[] ) # Get Transformer output (save and reload model again) hf_bort_model.save_pretrained(SCREAMING_SNAKE_CASE__ ) lowercase : str = BertModel.from_pretrained(SCREAMING_SNAKE_CASE__ ) hf_bort_model.eval() lowercase : Union[str, Any] = tokenizer.encode_plus(SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) lowercase : List[str] = hf_bort_model(**SCREAMING_SNAKE_CASE__ )[0] lowercase : str = output_gluon[0].asnumpy() lowercase : Optional[int] = output_hf[0].detach().numpy() lowercase : Optional[Any] = np.max(np.abs(hf_layer - gluon_layer ) ).item() lowercase : List[str] = np.allclose(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , atol=1e-3 ) if success: print("""✔️ Both model do output the same tensors""" ) else: print("""❌ Both model do **NOT** output the same tensors""" ) print("""Absolute difference is:""" , SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Optional[int] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--bort_checkpoint_path""", default=None, type=str, required=True, help="""Path the official Bort params file.""" ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) lowercase : Union[str, Any] = parser.parse_args() convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : str = { """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""], """convert_funnel_original_tf_checkpoint_to_pytorch""": [], """tokenization_funnel""": ["""FunnelTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Tuple = ["""FunnelTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = [ """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """FunnelBaseModel""", """FunnelForMaskedLM""", """FunnelForMultipleChoice""", """FunnelForPreTraining""", """FunnelForQuestionAnswering""", """FunnelForSequenceClassification""", """FunnelForTokenClassification""", """FunnelModel""", """FunnelPreTrainedModel""", """load_tf_weights_in_funnel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFFunnelBaseModel""", """TFFunnelForMaskedLM""", """TFFunnelForMultipleChoice""", """TFFunnelForPreTraining""", """TFFunnelForQuestionAnswering""", """TFFunnelForSequenceClassification""", """TFFunnelForTokenClassification""", """TFFunnelModel""", """TFFunnelPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowercase : str = {"""configuration_vit_msn""": ["""VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTMSNConfig"""]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST""", """ViTMSNModel""", """ViTMSNForImageClassification""", """ViTMSNPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_msn import ( VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMSNForImageClassification, ViTMSNModel, ViTMSNPreTrainedModel, ) else: import sys lowercase : str = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Any: lowercase : Dict = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } lowercase , lowercase : Optional[Any] = input_paths_and_base_extractors[compression_format] if input_path is None: lowercase : Dict = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) assert base_extractor.is_extractable(SCREAMING_SNAKE_CASE__ ) lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : str = file_path.read_text(encoding="""utf-8""" ) else: lowercase : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) lowercase : Tuple = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Dict: lowercase : str = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } lowercase : Optional[Any] = input_paths[compression_format] if input_path is None: lowercase : int = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = Extractor.infer_extractor_format(SCREAMING_SNAKE_CASE__ ) assert extractor_format is not None lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : Dict = file_path.read_text(encoding="""utf-8""" ) else: lowercase : int = output_path.read_text(encoding="""utf-8""" ) lowercase : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: import tarfile lowercase : Tuple = tmp_path / """data_dot_dot""" directory.mkdir() lowercase : str = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(SCREAMING_SNAKE_CASE__ , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: import tarfile lowercase : Tuple = tmp_path / """data_sym_link""" directory.mkdir() lowercase : int = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=SCREAMING_SNAKE_CASE__ ) with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : List[Any] = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } lowercase : Optional[int] = insecure_tar_files[insecure_tar_file] lowercase : List[str] = tmp_path / """extracted""" TarExtractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number lowercase : Any = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 lowercase : str = ( B"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" B"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" B"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" B"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(SCREAMING_SNAKE_CASE__ ) assert zipfile.is_zipfile(str(SCREAMING_SNAKE_CASE__ ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(SCREAMING_SNAKE_CASE__ ) # but we're right
20
1
import torch from diffusers import DDPMParallelScheduler from .test_schedulers import SchedulerCommonTest class __snake_case ( lowerCAmelCase ): _a : str= (DDPMParallelScheduler,) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : str = { """num_train_timesteps""": 1000, """beta_start""": 0.0_001, """beta_end""": 0.02, """beta_schedule""": """linear""", """variance_type""": """fixed_small""", """clip_sample""": True, } config.update(**snake_case ) return config def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for timesteps in [1, 5, 100, 1000]: self.check_over_configs(num_train_timesteps=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for beta_start, beta_end in zip([0.0_001, 0.001, 0.01, 0.1] ,[0.002, 0.02, 0.2, 2] ): self.check_over_configs(beta_start=snake_case ,beta_end=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for schedule in ["linear", "squaredcos_cap_v2"]: self.check_over_configs(beta_schedule=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for variance in ["fixed_small", "fixed_large", "other"]: self.check_over_configs(variance_type=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for clip_sample in [True, False]: self.check_over_configs(clip_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.check_over_configs(thresholding=snake_case ) for threshold in [0.5, 1.0, 2.0]: for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs( thresholding=snake_case ,prediction_type=snake_case ,sample_max_value=snake_case ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs(prediction_type=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for t in [0, 500, 999]: self.check_over_forward(time_step=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.scheduler_classes[0] lowercase : int = self.get_scheduler_config() lowercase : List[Any] = scheduler_class(**snake_case ) assert torch.sum(torch.abs(scheduler._get_variance(0 ) - 0.0 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(487 ) - 0.00_979 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(999 ) - 0.02 ) ) < 1e-5 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.scheduler_classes[0] lowercase : List[Any] = self.get_scheduler_config() lowercase : List[Any] = scheduler_class(**snake_case ) lowercase : Any = len(snake_case ) lowercase : str = self.dummy_model() lowercase : Union[str, Any] = self.dummy_sample_deter lowercase : Optional[int] = self.dummy_sample_deter + 0.1 lowercase : Tuple = self.dummy_sample_deter - 0.1 lowercase : Dict = samplea.shape[0] lowercase : Dict = torch.stack([samplea, samplea, samplea] ,dim=0 ) lowercase : Union[str, Any] = torch.arange(snake_case )[0:3, None].repeat(1 ,snake_case ) lowercase : Any = model(samples.flatten(0 ,1 ) ,timesteps.flatten(0 ,1 ) ) lowercase : Tuple = scheduler.batch_step_no_noise(snake_case ,timesteps.flatten(0 ,1 ) ,samples.flatten(0 ,1 ) ) lowercase : List[str] = torch.sum(torch.abs(snake_case ) ) lowercase : List[str] = torch.mean(torch.abs(snake_case ) ) assert abs(result_sum.item() - 1_153.1_833 ) < 1e-2 assert abs(result_mean.item() - 0.5_005 ) < 1e-3 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.scheduler_classes[0] lowercase : Tuple = self.get_scheduler_config() lowercase : List[Any] = scheduler_class(**snake_case ) lowercase : Tuple = len(snake_case ) lowercase : str = self.dummy_model() lowercase : List[Any] = self.dummy_sample_deter lowercase : List[str] = torch.manual_seed(0 ) for t in reversed(range(snake_case ) ): # 1. predict noise residual lowercase : List[str] = model(snake_case ,snake_case ) # 2. predict previous mean of sample x_t-1 lowercase : Optional[Any] = scheduler.step(snake_case ,snake_case ,snake_case ,generator=snake_case ).prev_sample lowercase : Optional[int] = pred_prev_sample lowercase : str = torch.sum(torch.abs(snake_case ) ) lowercase : Tuple = torch.mean(torch.abs(snake_case ) ) assert abs(result_sum.item() - 258.9_606 ) < 1e-2 assert abs(result_mean.item() - 0.3_372 ) < 1e-3 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.scheduler_classes[0] lowercase : Any = self.get_scheduler_config(prediction_type="""v_prediction""" ) lowercase : Dict = scheduler_class(**snake_case ) lowercase : Union[str, Any] = len(snake_case ) lowercase : Dict = self.dummy_model() lowercase : Tuple = self.dummy_sample_deter lowercase : Dict = torch.manual_seed(0 ) for t in reversed(range(snake_case ) ): # 1. predict noise residual lowercase : Optional[int] = model(snake_case ,snake_case ) # 2. predict previous mean of sample x_t-1 lowercase : Dict = scheduler.step(snake_case ,snake_case ,snake_case ,generator=snake_case ).prev_sample lowercase : Optional[Any] = pred_prev_sample lowercase : Dict = torch.sum(torch.abs(snake_case ) ) lowercase : Union[str, Any] = torch.mean(torch.abs(snake_case ) ) assert abs(result_sum.item() - 202.0_296 ) < 1e-2 assert abs(result_mean.item() - 0.2_631 ) < 1e-3 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.scheduler_classes[0] lowercase : Optional[Any] = self.get_scheduler_config() lowercase : List[str] = scheduler_class(**snake_case ) lowercase : Dict = [100, 87, 50, 1, 0] scheduler.set_timesteps(timesteps=snake_case ) lowercase : List[str] = scheduler.timesteps for i, timestep in enumerate(snake_case ): if i == len(snake_case ) - 1: lowercase : List[Any] = -1 else: lowercase : Any = timesteps[i + 1] lowercase : Any = scheduler.previous_timestep(snake_case ) lowercase : int = prev_t.item() self.assertEqual(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.scheduler_classes[0] lowercase : List[str] = self.get_scheduler_config() lowercase : str = scheduler_class(**snake_case ) lowercase : Tuple = [100, 87, 50, 51, 0] with self.assertRaises(snake_case ,msg="""`custom_timesteps` must be in descending order.""" ): scheduler.set_timesteps(timesteps=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.scheduler_classes[0] lowercase : List[str] = self.get_scheduler_config() lowercase : Union[str, Any] = scheduler_class(**snake_case ) lowercase : Union[str, Any] = [100, 87, 50, 1, 0] lowercase : List[Any] = len(snake_case ) with self.assertRaises(snake_case ,msg="""Can only pass one of `num_inference_steps` or `custom_timesteps`.""" ): scheduler.set_timesteps(num_inference_steps=snake_case ,timesteps=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.scheduler_classes[0] lowercase : Tuple = self.get_scheduler_config() lowercase : Optional[int] = scheduler_class(**snake_case ) lowercase : Any = [scheduler.config.num_train_timesteps] with self.assertRaises( snake_case ,msg="""`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}""" ,): scheduler.set_timesteps(timesteps=snake_case )
20
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 lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[Any] = { """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 ( lowerCAmelCase ): _a : str= "gpt_neo" _a : Optional[int]= ["past_key_values"] _a : Dict= {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self ,snake_case=50257 ,snake_case=2048 ,snake_case=2048 ,snake_case=24 ,snake_case=[[["global", "local"], 12]] ,snake_case=16 ,snake_case=None ,snake_case=256 ,snake_case="gelu_new" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=1e-5 ,snake_case=0.02 ,snake_case=True ,snake_case=50256 ,snake_case=50256 ,**snake_case ,): '''simple docstring''' lowercase : int = vocab_size lowercase : Union[str, Any] = max_position_embeddings lowercase : Dict = hidden_size lowercase : Union[str, Any] = num_layers lowercase : Union[str, Any] = num_heads lowercase : Optional[int] = intermediate_size lowercase : List[str] = window_size lowercase : Optional[int] = activation_function lowercase : List[str] = resid_dropout lowercase : int = embed_dropout lowercase : Optional[int] = attention_dropout lowercase : Tuple = classifier_dropout lowercase : Optional[int] = layer_norm_epsilon lowercase : Dict = initializer_range lowercase : List[str] = use_cache lowercase : Optional[int] = bos_token_id lowercase : int = eos_token_id lowercase : Union[str, Any] = attention_types lowercase : Dict = self.expand_attention_types_params(snake_case ) 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=snake_case ,eos_token_id=snake_case ,**snake_case ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : List[Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: import torch lowercase : Tuple = input.size() lowercase : int = len(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = shape[dimension] lowercase : int = torch.arange(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.div(sizedim - size , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) + 1 lowercase : Dict = torch.arange(SCREAMING_SNAKE_CASE__ ) + low_indices[:min_length][:, None] lowercase : Union[str, Any] = [slice(SCREAMING_SNAKE_CASE__ )] * rank lowercase : Optional[Any] = indices lowercase : List[str] = input[s] lowercase : Optional[int] = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import torch lowercase : Union[str, Any] = torch.arange(1 , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.remainder(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = remainders == 0 lowercase : Optional[int] = candidates[divisor_indices] lowercase : List[Any] = torch.max(SCREAMING_SNAKE_CASE__ ) return largest_divisor, torch.div(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(snake_case ,direction="""inputs""" ) lowercase : Dict = {0: """batch""", 1: """past_sequence + sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} return common_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self._config.num_heads def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,): '''simple docstring''' lowercase : Any = super(snake_case ,self ).generate_dummy_inputs( snake_case ,batch_size=snake_case ,seq_length=snake_case ,is_pair=snake_case ,framework=snake_case ) # We need to order the input in the way they appears in the forward() lowercase : List[str] = 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 lowercase , lowercase : List[Any] = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowercase : Optional[int] = seqlen + 2 lowercase : int = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowercase : Optional[Any] = [ (torch.zeros(snake_case ), torch.zeros(snake_case )) for _ in range(self.num_layers ) ] lowercase : Optional[Any] = common_inputs["""attention_mask"""] if self.use_past: lowercase : Any = ordered_inputs["""attention_mask"""].dtype lowercase : Union[str, Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(snake_case ,snake_case ,dtype=snake_case )] ,dim=1 ) return ordered_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 13
20
1
from __future__ import annotations lowercase : Tuple = """Muhammad Umer Farooq""" lowercase : List[str] = """MIT""" lowercase : Any = """1.0.0""" lowercase : str = """Muhammad Umer Farooq""" lowercase : List[str] = """[email protected]""" lowercase : Union[str, Any] = """Alpha""" import re from html.parser import HTMLParser from urllib import parse import requests class __snake_case ( lowerCAmelCase ): def __init__( self ,snake_case ): '''simple docstring''' super().__init__() lowercase : list[str] = [] lowercase : Union[str, Any] = domain def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' 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: lowercase : Tuple = parse.urljoin(self.domain ,snake_case ) self.urls.append(snake_case ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: return ".".join(get_sub_domain_name(SCREAMING_SNAKE_CASE__ ).split(""".""" )[-2:] ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: return parse.urlparse(SCREAMING_SNAKE_CASE__ ).netloc def _snake_case( SCREAMING_SNAKE_CASE__ = "https://github.com" ) -> list[str]: lowercase : List[Any] = get_domain_name(SCREAMING_SNAKE_CASE__ ) # Initialize the parser lowercase : List[str] = Parser(SCREAMING_SNAKE_CASE__ ) try: # Open URL lowercase : Tuple = requests.get(SCREAMING_SNAKE_CASE__ ) # pass the raw HTML to the parser to get links parser.feed(r.text ) # Get links and loop through lowercase : List[str] = set() for link in parser.urls: # open URL. # read = requests.get(link) try: lowercase : Tuple = requests.get(SCREAMING_SNAKE_CASE__ ) # Get the valid email. lowercase : Any = re.findall("""[a-zA-Z0-9]+@""" + domain , read.text ) # If not in list then append it. for email in emails: valid_emails.add(SCREAMING_SNAKE_CASE__ ) except ValueError: pass except ValueError: raise SystemExit(1 ) # Finally return a sorted list of email addresses with no duplicates. return sorted(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Optional[Any] = emails_from_url("""https://github.com""") print(F'''{len(emails)} emails found:''') print("""\n""".join(sorted(emails)))
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING lowercase : Any = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == """tf""" else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = {} if top_k is not None: lowercase : int = top_k return {}, {}, postprocess_params def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = load_image(snake_case ) lowercase : List[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = self.model(**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ): '''simple docstring''' if top_k > self.model.config.num_labels: lowercase : Tuple = self.model.config.num_labels if self.framework == "pt": lowercase : str = model_outputs.logits.softmax(-1 )[0] lowercase , lowercase : Dict = probs.topk(snake_case ) elif self.framework == "tf": lowercase : Optional[int] = stable_softmax(model_outputs.logits ,axis=-1 )[0] lowercase : Union[str, Any] = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : List[str] = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f"Unsupported framework: {self.framework}" ) lowercase : Tuple = scores.tolist() lowercase : Dict = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case ,snake_case )]
20
1
import importlib import json import os from collections import OrderedDict from typing import Dict, Optional, Union # Build the list of all image processors from ...configuration_utils import PretrainedConfig from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code from ...image_processing_utils import ImageProcessingMixin from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging from .auto_factory import _LazyAutoMapping from .configuration_auto import ( CONFIG_MAPPING_NAMES, AutoConfig, model_type_to_module_name, replace_list_option_in_docstrings, ) lowercase : Any = logging.get_logger(__name__) lowercase : Tuple = OrderedDict( [ ("""align""", """EfficientNetImageProcessor"""), ("""beit""", """BeitImageProcessor"""), ("""bit""", """BitImageProcessor"""), ("""blip""", """BlipImageProcessor"""), ("""blip-2""", """BlipImageProcessor"""), ("""bridgetower""", """BridgeTowerImageProcessor"""), ("""chinese_clip""", """ChineseCLIPImageProcessor"""), ("""clip""", """CLIPImageProcessor"""), ("""clipseg""", """ViTImageProcessor"""), ("""conditional_detr""", """ConditionalDetrImageProcessor"""), ("""convnext""", """ConvNextImageProcessor"""), ("""convnextv2""", """ConvNextImageProcessor"""), ("""cvt""", """ConvNextImageProcessor"""), ("""data2vec-vision""", """BeitImageProcessor"""), ("""deformable_detr""", """DeformableDetrImageProcessor"""), ("""deit""", """DeiTImageProcessor"""), ("""deta""", """DetaImageProcessor"""), ("""detr""", """DetrImageProcessor"""), ("""dinat""", """ViTImageProcessor"""), ("""donut-swin""", """DonutImageProcessor"""), ("""dpt""", """DPTImageProcessor"""), ("""efficientformer""", """EfficientFormerImageProcessor"""), ("""efficientnet""", """EfficientNetImageProcessor"""), ("""flava""", """FlavaImageProcessor"""), ("""focalnet""", """BitImageProcessor"""), ("""git""", """CLIPImageProcessor"""), ("""glpn""", """GLPNImageProcessor"""), ("""groupvit""", """CLIPImageProcessor"""), ("""imagegpt""", """ImageGPTImageProcessor"""), ("""instructblip""", """BlipImageProcessor"""), ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""), ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""), ("""levit""", """LevitImageProcessor"""), ("""mask2former""", """Mask2FormerImageProcessor"""), ("""maskformer""", """MaskFormerImageProcessor"""), ("""mgp-str""", """ViTImageProcessor"""), ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""), ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""), ("""mobilevit""", """MobileViTImageProcessor"""), ("""mobilevit""", """MobileViTImageProcessor"""), ("""mobilevitv2""", """MobileViTImageProcessor"""), ("""nat""", """ViTImageProcessor"""), ("""oneformer""", """OneFormerImageProcessor"""), ("""owlvit""", """OwlViTImageProcessor"""), ("""perceiver""", """PerceiverImageProcessor"""), ("""pix2struct""", """Pix2StructImageProcessor"""), ("""poolformer""", """PoolFormerImageProcessor"""), ("""regnet""", """ConvNextImageProcessor"""), ("""resnet""", """ConvNextImageProcessor"""), ("""sam""", """SamImageProcessor"""), ("""segformer""", """SegformerImageProcessor"""), ("""swiftformer""", """ViTImageProcessor"""), ("""swin""", """ViTImageProcessor"""), ("""swin2sr""", """Swin2SRImageProcessor"""), ("""swinv2""", """ViTImageProcessor"""), ("""table-transformer""", """DetrImageProcessor"""), ("""timesformer""", """VideoMAEImageProcessor"""), ("""tvlt""", """TvltImageProcessor"""), ("""upernet""", """SegformerImageProcessor"""), ("""van""", """ConvNextImageProcessor"""), ("""videomae""", """VideoMAEImageProcessor"""), ("""vilt""", """ViltImageProcessor"""), ("""vit""", """ViTImageProcessor"""), ("""vit_hybrid""", """ViTHybridImageProcessor"""), ("""vit_mae""", """ViTImageProcessor"""), ("""vit_msn""", """ViTImageProcessor"""), ("""xclip""", """CLIPImageProcessor"""), ("""yolos""", """YolosImageProcessor"""), ] ) lowercase : Any = _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items(): if class_name in extractors: lowercase : Any = model_type_to_module_name(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = importlib.import_module(f".{module_name}" , """transformers.models""" ) try: return getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) except AttributeError: continue for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items(): if getattr(SCREAMING_SNAKE_CASE__ , """__name__""" , SCREAMING_SNAKE_CASE__ ) == class_name: return extractor # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main # init and we return the proper dummy to get an appropriate error message. lowercase : Optional[int] = importlib.import_module("""transformers""" ) if hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): return getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return None def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = False , SCREAMING_SNAKE_CASE__ = False , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = False , **SCREAMING_SNAKE_CASE__ , ) -> Optional[Any]: lowercase : List[Any] = get_file_from_repo( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ , force_download=SCREAMING_SNAKE_CASE__ , resume_download=SCREAMING_SNAKE_CASE__ , proxies=SCREAMING_SNAKE_CASE__ , use_auth_token=SCREAMING_SNAKE_CASE__ , revision=SCREAMING_SNAKE_CASE__ , local_files_only=SCREAMING_SNAKE_CASE__ , ) if resolved_config_file is None: logger.info( """Could not locate the image processor configuration file, will try to use the model config instead.""" ) return {} with open(SCREAMING_SNAKE_CASE__ , encoding="""utf-8""" ) as reader: return json.load(SCREAMING_SNAKE_CASE__ ) class __snake_case : def __init__( self ): '''simple docstring''' raise EnvironmentError( """AutoImageProcessor is designed to be instantiated """ """using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.""" ) @classmethod @replace_list_option_in_docstrings(snake_case ) def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,**snake_case ): '''simple docstring''' lowercase : int = kwargs.pop("""config""" ,snake_case ) lowercase : Optional[Any] = kwargs.pop("""trust_remote_code""" ,snake_case ) lowercase : str = True lowercase , lowercase : str = ImageProcessingMixin.get_image_processor_dict(snake_case ,**snake_case ) lowercase : List[str] = config_dict.get("""image_processor_type""" ,snake_case ) lowercase : Dict = None if "AutoImageProcessor" in config_dict.get("""auto_map""" ,{} ): lowercase : str = config_dict["""auto_map"""]["""AutoImageProcessor"""] # If we still don't have the image processor class, check if we're loading from a previous feature extractor config # and if so, infer the image processor class from there. if image_processor_class is None and image_processor_auto_map is None: lowercase : Dict = config_dict.pop("""feature_extractor_type""" ,snake_case ) if feature_extractor_class is not None: logger.warning( """Could not find image processor class in the image processor config or the model config. Loading""" """ based on pattern matching with the model's feature extractor configuration.""" ) lowercase : List[str] = feature_extractor_class.replace("""FeatureExtractor""" ,"""ImageProcessor""" ) if "AutoFeatureExtractor" in config_dict.get("""auto_map""" ,{} ): lowercase : int = config_dict["""auto_map"""]["""AutoFeatureExtractor"""] lowercase : str = feature_extractor_auto_map.replace("""FeatureExtractor""" ,"""ImageProcessor""" ) logger.warning( """Could not find image processor auto map in the image processor config or the model config.""" """ Loading based on pattern matching with the model's feature extractor configuration.""" ) # If we don't find the image processor class in the image processor config, let's try the model config. if image_processor_class is None and image_processor_auto_map is None: if not isinstance(snake_case ,snake_case ): lowercase : Tuple = AutoConfig.from_pretrained(snake_case ,**snake_case ) # It could be in `config.image_processor_type`` lowercase : Optional[int] = getattr(snake_case ,"""image_processor_type""" ,snake_case ) if hasattr(snake_case ,"""auto_map""" ) and "AutoImageProcessor" in config.auto_map: lowercase : Tuple = config.auto_map["""AutoImageProcessor"""] if image_processor_class is not None: lowercase : Union[str, Any] = image_processor_class_from_name(snake_case ) lowercase : List[Any] = image_processor_auto_map is not None lowercase : Optional[int] = image_processor_class is not None or type(snake_case ) in IMAGE_PROCESSOR_MAPPING lowercase : Any = resolve_trust_remote_code( snake_case ,snake_case ,snake_case ,snake_case ) if has_remote_code and trust_remote_code: lowercase : int = get_class_from_dynamic_module( snake_case ,snake_case ,**snake_case ) lowercase : Dict = kwargs.pop("""code_revision""" ,snake_case ) if os.path.isdir(snake_case ): image_processor_class.register_for_auto_class() return image_processor_class.from_dict(snake_case ,**snake_case ) elif image_processor_class is not None: return image_processor_class.from_dict(snake_case ,**snake_case ) # Last try: we use the IMAGE_PROCESSOR_MAPPING. elif type(snake_case ) in IMAGE_PROCESSOR_MAPPING: lowercase : List[Any] = IMAGE_PROCESSOR_MAPPING[type(snake_case )] return image_processor_class.from_dict(snake_case ,**snake_case ) raise ValueError( f"Unrecognized image processor in {pretrained_model_name_or_path}. Should have a " f"`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following " f"`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}" ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ,snake_case ): '''simple docstring''' IMAGE_PROCESSOR_MAPPING.register(snake_case ,snake_case )
20
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
1
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : Optional[Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): lowercase : Any = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ , keep_in_memory=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : int = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} lowercase : str = features.copy() if features else default_expected_features lowercase : Optional[Any] = ( Features({feature: Value(SCREAMING_SNAKE_CASE__ ) for feature, dtype in features.items()} ) if features is not None else None ) lowercase : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__ ) ) as con: lowercase : Optional[int] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = tmp_path / """cache""" lowercase : int = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() lowercase : List[str] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Dict = tmp_path / """cache""" lowercase : List[str] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() lowercase : Optional[int] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : str = tmp_path / """cache""" lowercase : Optional[int] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : Optional[Any] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() with pytest.raises(SCREAMING_SNAKE_CASE__ ): SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
import json import os from dataclasses import dataclass from functools import partial from typing import Callable import flax.linen as nn import jax import jax.numpy as jnp import joblib import optax import wandb from flax import jax_utils, struct, traverse_util from flax.serialization import from_bytes, to_bytes from flax.training import train_state from flax.training.common_utils import shard from tqdm.auto import tqdm from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule class __snake_case ( lowerCAmelCase ): _a : BigBirdConfig _a : jnp.dtype= jnp.floataa _a : bool= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setup() lowercase : List[str] = nn.Dense(5 ,dtype=self.dtype ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = super().__call__(*snake_case ,**snake_case ) lowercase : Any = self.cls(outputs[2] ) return outputs[:2] + (cls_out,) class __snake_case ( lowerCAmelCase ): _a : List[Any]= FlaxBigBirdForNaturalQuestionsModule def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: def cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ): lowercase : int = logits.shape[-1] lowercase : Dict = (labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__ )[None]).astype("""f4""" ) lowercase : Any = jax.nn.log_softmax(SCREAMING_SNAKE_CASE__ , axis=-1 ) lowercase : Optional[Any] = -jnp.sum(labels * logits , axis=-1 ) if reduction is not None: lowercase : Any = reduction(SCREAMING_SNAKE_CASE__ ) return loss lowercase : Optional[Any] = partial(SCREAMING_SNAKE_CASE__ , reduction=jnp.mean ) lowercase : Optional[int] = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Dict = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return (start_loss + end_loss + pooled_loss) / 3 @dataclass class __snake_case : _a : str= "google/bigbird-roberta-base" _a : int= 3000 _a : int= 1_0500 _a : int= 128 _a : int= 3 _a : int= 1 _a : int= 5 # tx_args _a : float= 3E-5 _a : float= 0.0 _a : int= 2_0000 _a : float= 0.00_95 _a : str= "bigbird-roberta-natural-questions" _a : str= "training-expt" _a : str= "data/nq-training.jsonl" _a : str= "data/nq-validation.jsonl" def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' os.makedirs(self.base_dir ,exist_ok=snake_case ) lowercase : Optional[int] = os.path.join(self.base_dir ,self.save_dir ) lowercase : Optional[int] = self.batch_size_per_device * jax.device_count() @dataclass class __snake_case : _a : int _a : int= 4096 # no dynamic padding on TPUs def __call__( self ,snake_case ): '''simple docstring''' lowercase : int = self.collate_fn(snake_case ) lowercase : Union[str, Any] = jax.tree_util.tree_map(snake_case ,snake_case ) return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Union[str, Any] = self.fetch_inputs(features["""input_ids"""] ) lowercase : Tuple = { """input_ids""": jnp.array(snake_case ,dtype=jnp.intaa ), """attention_mask""": jnp.array(snake_case ,dtype=jnp.intaa ), """start_labels""": jnp.array(features["""start_token"""] ,dtype=jnp.intaa ), """end_labels""": jnp.array(features["""end_token"""] ,dtype=jnp.intaa ), """pooled_labels""": jnp.array(features["""category"""] ,dtype=jnp.intaa ), } return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = [self._fetch_inputs(snake_case ) for ids in input_ids] return zip(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [1 for _ in range(len(snake_case ) )] while len(snake_case ) < self.max_length: input_ids.append(self.pad_id ) attention_mask.append(0 ) return input_ids, attention_mask def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> Any: if seed is not None: lowercase : Optional[int] = dataset.shuffle(seed=SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) // batch_size ): lowercase : Optional[Any] = dataset[i * batch_size : (i + 1) * batch_size] yield dict(SCREAMING_SNAKE_CASE__ ) @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[Any]: def loss_fn(SCREAMING_SNAKE_CASE__ ): lowercase : List[str] = model_inputs.pop("""start_labels""" ) lowercase : Optional[int] = model_inputs.pop("""end_labels""" ) lowercase : str = model_inputs.pop("""pooled_labels""" ) lowercase : Union[str, Any] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=SCREAMING_SNAKE_CASE__ , dropout_rng=SCREAMING_SNAKE_CASE__ , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[str] = outputs return state.loss_fn( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) lowercase , lowercase : int = jax.random.split(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = jax.value_and_grad(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : Union[str, Any] = grad_fn(state.params ) lowercase : List[Any] = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) lowercase : List[Any] = jax.lax.pmean(SCREAMING_SNAKE_CASE__ , """batch""" ) lowercase : str = state.apply_gradients(grads=SCREAMING_SNAKE_CASE__ ) return state, metrics, new_drp_rng @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = model_inputs.pop("""start_labels""" ) lowercase : Dict = model_inputs.pop("""end_labels""" ) lowercase : Optional[Any] = model_inputs.pop("""pooled_labels""" ) lowercase : Optional[int] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=state.params , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[Any] = outputs lowercase : Dict = state.loss_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : str = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) return metrics class __snake_case ( train_state.TrainState ): _a : Callable= struct.field(pytree_node=lowerCAmelCase ) @dataclass class __snake_case : _a : Args _a : Callable _a : Callable _a : Callable _a : Callable _a : wandb _a : Callable= None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = model.params lowercase : Any = TrainState.create( apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,loss_fn=snake_case ,) if ckpt_dir is not None: lowercase , lowercase , lowercase , lowercase , lowercase : Tuple = restore_checkpoint(snake_case ,snake_case ) lowercase : List[str] = { """lr""": args.lr, """init_lr""": args.init_lr, """warmup_steps""": args.warmup_steps, """num_train_steps""": num_train_steps, """weight_decay""": args.weight_decay, } lowercase , lowercase : Tuple = build_tx(**snake_case ) lowercase : str = train_state.TrainState( step=snake_case ,apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,opt_state=snake_case ,) lowercase : Any = args lowercase : Optional[Any] = data_collator lowercase : List[str] = lr lowercase : str = params lowercase : Tuple = jax_utils.replicate(snake_case ) return state def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = self.args lowercase : Optional[Any] = len(snake_case ) // args.batch_size lowercase : int = jax.random.PRNGKey(0 ) lowercase : List[str] = jax.random.split(snake_case ,jax.device_count() ) for epoch in range(args.max_epochs ): lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : List[str] = get_batched_dataset(snake_case ,args.batch_size ,seed=snake_case ) lowercase : int = 0 for batch in tqdm(snake_case ,total=snake_case ,desc=f"Running EPOCH-{epoch}" ): lowercase : Dict = self.data_collator(snake_case ) lowercase , lowercase , lowercase : Optional[int] = self.train_step_fn(snake_case ,snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 if i % args.logging_steps == 0: lowercase : Optional[Any] = jax_utils.unreplicate(state.step ) lowercase : List[str] = running_loss.item() / i lowercase : List[str] = self.scheduler_fn(state_step - 1 ) lowercase : int = self.evaluate(snake_case ,snake_case ) lowercase : Tuple = { """step""": state_step.item(), """eval_loss""": eval_loss.item(), """tr_loss""": tr_loss, """lr""": lr.item(), } tqdm.write(str(snake_case ) ) self.logger.log(snake_case ,commit=snake_case ) if i % args.save_steps == 0: self.save_checkpoint(args.save_dir + f"-e{epoch}-s{i}" ,state=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = get_batched_dataset(snake_case ,self.args.batch_size ) lowercase : Any = len(snake_case ) // self.args.batch_size lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : Optional[int] = 0 for batch in tqdm(snake_case ,total=snake_case ,desc="""Evaluating ... """ ): lowercase : Tuple = self.data_collator(snake_case ) lowercase : Optional[int] = self.val_step_fn(snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 return running_loss / i def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = jax_utils.unreplicate(snake_case ) print(f"SAVING CHECKPOINT IN {save_dir}" ,end=""" ... """ ) self.model_save_fn(snake_case ,params=state.params ) with open(os.path.join(snake_case ,"""opt_state.msgpack""" ) ,"""wb""" ) as f: f.write(to_bytes(state.opt_state ) ) joblib.dump(self.args ,os.path.join(snake_case ,"""args.joblib""" ) ) joblib.dump(self.data_collator ,os.path.join(snake_case ,"""data_collator.joblib""" ) ) with open(os.path.join(snake_case ,"""training_state.json""" ) ,"""w""" ) as f: json.dump({"""step""": state.step.item()} ,snake_case ) print("""DONE""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: print(f"RESTORING CHECKPOINT FROM {save_dir}" , end=""" ... """ ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """flax_model.msgpack""" ) , """rb""" ) as f: lowercase : str = from_bytes(state.params , f.read() ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """opt_state.msgpack""" ) , """rb""" ) as f: lowercase : Optional[int] = from_bytes(state.opt_state , f.read() ) lowercase : Optional[Any] = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """args.joblib""" ) ) lowercase : int = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """data_collator.joblib""" ) ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """training_state.json""" ) , """r""" ) as f: lowercase : Tuple = json.load(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = training_state["""step"""] print("""DONE""" ) return params, opt_state, step, args, data_collator def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : List[str] = num_train_steps - warmup_steps lowercase : Dict = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=SCREAMING_SNAKE_CASE__ , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=1e-7 , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = optax.join_schedules(schedules=[warmup_fn, decay_fn] , boundaries=[warmup_steps] ) return lr def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: def weight_decay_mask(SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = {k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()} return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = scheduler_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__ , weight_decay=SCREAMING_SNAKE_CASE__ , mask=SCREAMING_SNAKE_CASE__ ) return tx, lr
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_distilbert import DistilBertTokenizer lowercase : Tuple = logging.get_logger(__name__) lowercase : str = {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""} lowercase : List[str] = { """vocab_file""": { """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt""", """distilbert-base-uncased-distilled-squad""": ( """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt""" ), """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt""", """distilbert-base-cased-distilled-squad""": ( """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt""" ), """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt""", """distilbert-base-multilingual-cased""": ( """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt""" ), }, """tokenizer_file""": { """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json""", """distilbert-base-uncased-distilled-squad""": ( """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json""" ), """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json""", """distilbert-base-cased-distilled-squad""": ( """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json""" ), """distilbert-base-german-cased""": ( """https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json""" ), """distilbert-base-multilingual-cased""": ( """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json""" ), }, } lowercase : Any = { """distilbert-base-uncased""": 512, """distilbert-base-uncased-distilled-squad""": 512, """distilbert-base-cased""": 512, """distilbert-base-cased-distilled-squad""": 512, """distilbert-base-german-cased""": 512, """distilbert-base-multilingual-cased""": 512, } lowercase : Tuple = { """distilbert-base-uncased""": {"""do_lower_case""": True}, """distilbert-base-uncased-distilled-squad""": {"""do_lower_case""": True}, """distilbert-base-cased""": {"""do_lower_case""": False}, """distilbert-base-cased-distilled-squad""": {"""do_lower_case""": False}, """distilbert-base-german-cased""": {"""do_lower_case""": False}, """distilbert-base-multilingual-cased""": {"""do_lower_case""": False}, } class __snake_case ( lowerCAmelCase ): _a : Optional[Any]= VOCAB_FILES_NAMES _a : List[str]= PRETRAINED_VOCAB_FILES_MAP _a : Optional[Any]= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : str= PRETRAINED_INIT_CONFIGURATION _a : List[Any]= ["input_ids", "attention_mask"] _a : str= DistilBertTokenizer def __init__( self ,snake_case=None ,snake_case=None ,snake_case=True ,snake_case="[UNK]" ,snake_case="[SEP]" ,snake_case="[PAD]" ,snake_case="[CLS]" ,snake_case="[MASK]" ,snake_case=True ,snake_case=None ,**snake_case ,): '''simple docstring''' super().__init__( snake_case ,tokenizer_file=snake_case ,do_lower_case=snake_case ,unk_token=snake_case ,sep_token=snake_case ,pad_token=snake_case ,cls_token=snake_case ,mask_token=snake_case ,tokenize_chinese_chars=snake_case ,strip_accents=snake_case ,**snake_case ,) lowercase : Optional[int] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get("""lowercase""" ,snake_case ) != do_lower_case or normalizer_state.get("""strip_accents""" ,snake_case ) != strip_accents or normalizer_state.get("""handle_chinese_chars""" ,snake_case ) != tokenize_chinese_chars ): lowercase : Optional[Any] = getattr(snake_case ,normalizer_state.pop("""type""" ) ) lowercase : int = do_lower_case lowercase : Optional[int] = strip_accents lowercase : int = tokenize_chinese_chars lowercase : Dict = normalizer_class(**snake_case ) lowercase : str = do_lower_case def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : 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 _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Any = [self.sep_token_id] lowercase : 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 ) * [0] + len(token_ids_a + sep ) * [1] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Optional[int] = self._tokenizer.model.save(snake_case ,name=snake_case ) return tuple(snake_case )
20
from math import sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' must been an int and positive" lowercase : Union[str, Any] = True # 0 and 1 are none primes. if number <= 1: lowercase : str = False for divisor in range(2 , int(round(sqrt(SCREAMING_SNAKE_CASE__ ) ) ) + 1 ): # if 'number' divisible by 'divisor' then sets 'status' # of false and break up the loop. if number % divisor == 0: lowercase : Any = False break # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'status' must been from type bool" return status def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" # beginList: contains all natural numbers from 2 up to N lowercase : str = list(range(2 , n + 1 ) ) lowercase : Tuple = [] # this list will be returns. # actual sieve of erathostenes for i in range(len(SCREAMING_SNAKE_CASE__ ) ): for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0): lowercase : Tuple = 0 # filters actual prime numbers. lowercase : int = [x for x in begin_list if x != 0] # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" lowercase : Dict = [] # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2 , n + 1 ): if is_prime(SCREAMING_SNAKE_CASE__ ): ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and number >= 0, "'number' must been an int and >= 0" lowercase : Tuple = [] # this list will be returns of the function. # potential prime number factors. lowercase : Optional[Any] = 2 lowercase : Any = number if number == 0 or number == 1: ans.append(SCREAMING_SNAKE_CASE__ ) # if 'number' not prime then builds the prime factorization of 'number' elif not is_prime(SCREAMING_SNAKE_CASE__ ): while quotient != 1: if is_prime(SCREAMING_SNAKE_CASE__ ) and (quotient % factor == 0): ans.append(SCREAMING_SNAKE_CASE__ ) quotient /= factor else: factor += 1 else: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Tuple = 0 # prime factorization of 'number' lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = max(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Union[str, Any] = 0 # prime factorization of 'number' lowercase : Tuple = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = min(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 == 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 == 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 != 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 != 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__ ) ), "'number' must been an int, even and > 2" lowercase : Union[str, Any] = [] # this list will returned # creates a list of prime numbers between 2 up to 'number' lowercase : str = get_prime_numbers(SCREAMING_SNAKE_CASE__ ) lowercase : Any = len(SCREAMING_SNAKE_CASE__ ) # run variable for while-loops. lowercase : Optional[Any] = 0 lowercase : List[Any] = None # exit variable. for break up the loops lowercase : Any = True while i < len_pn and loop: lowercase : str = i + 1 while j < len_pn and loop: if prime_numbers[i] + prime_numbers[j] == number: lowercase : Union[str, Any] = False ans.append(prime_numbers[i] ) ans.append(prime_numbers[j] ) j += 1 i += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (len(SCREAMING_SNAKE_CASE__ ) == 2) and (ans[0] + ans[1] == number) and is_prime(ans[0] ) and is_prime(ans[1] ) ), "'ans' must contains two primes. And sum of elements must been eq 'number'" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 0) and (numbera >= 0) ), "'number1' and 'number2' must been positive integer." lowercase : Union[str, Any] = 0 while numbera != 0: lowercase : Optional[int] = numbera % numbera lowercase : Optional[int] = numbera lowercase : Dict = rest # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( numbera >= 0 ), "'number' must been from type int and positive" return numbera def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 1) and (numbera >= 1) ), "'number1' and 'number2' must been positive integer." lowercase : Dict = 1 # actual answer that will be return. # for kgV (x,1) if numbera > 1 and numbera > 1: # builds the prime factorization of 'number1' and 'number2' lowercase : Optional[Any] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) elif numbera == 1 or numbera == 1: lowercase : Union[str, Any] = [] lowercase : List[str] = [] lowercase : Dict = max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = 0 lowercase : Optional[Any] = 0 lowercase : List[str] = [] # captured numbers int both 'primeFac1' and 'primeFac2' # iterates through primeFac1 for n in prime_fac_a: if n not in done: if n in prime_fac_a: lowercase : Dict = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ): ans *= n else: lowercase : List[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # iterates through primeFac2 for n in prime_fac_a: if n not in done: lowercase : Optional[int] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( ans >= 0 ), "'ans' must been from type int and positive" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'number' must been a positive int" lowercase : Dict = 0 lowercase : List[str] = 2 # this variable holds the answer while index < n: index += 1 ans += 1 # counts to the next number # if ans not prime then # runs to the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): ans += 1 # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and is_prime( SCREAMING_SNAKE_CASE__ ), "'ans' must been a prime number and from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert ( is_prime(SCREAMING_SNAKE_CASE__ ) and is_prime(SCREAMING_SNAKE_CASE__ ) and (p_number_a < p_number_a) ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" lowercase : List[str] = p_number_a + 1 # jump to the next number lowercase : List[Any] = [] # this list will be returns. # if number is not prime then # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 while number < p_number_a: ans.append(SCREAMING_SNAKE_CASE__ ) number += 1 # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ans[0] != p_number_a and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] != p_number_a ), "'ans' must been a list without the arguments" # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 1), "'n' must been int and >= 1" lowercase : Optional[Any] = [] # will be returned. for divisor in range(1 , n + 1 ): if n % divisor == 0: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] == n, "Error in function getDivisiors(...)" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number > 1 ), "'number' must been an int and >= 1" lowercase : str = get_divisors(SCREAMING_SNAKE_CASE__ ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (divisors[0] == 1) and (divisors[len(SCREAMING_SNAKE_CASE__ ) - 1] == number) ), "Error in help-function getDivisiors(...)" # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1] ) == number def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (denominator != 0) ), "The arguments must been from type int and 'denominator' != 0" # build the greatest common divisor of numerator and denominator. lowercase : Tuple = gcd(abs(SCREAMING_SNAKE_CASE__ ) , abs(SCREAMING_SNAKE_CASE__ ) ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numerator % gcd_of_fraction == 0) and (denominator % gcd_of_fraction == 0) ), "Error in function gcd(...,...)" return (numerator // gcd_of_fraction, denominator // gcd_of_fraction) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been a int and >= 0" lowercase : List[str] = 1 # this will be return. for factor in range(1 , n + 1 ): ans *= factor return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been an int and >= 0" lowercase : int = 0 lowercase : Union[str, Any] = 1 lowercase : int = 1 # this will be return for _ in range(n - 1 ): lowercase : Optional[int] = ans ans += fiba lowercase : Optional[int] = tmp return ans
20
1
import json import os from typing import Optional, Tuple from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase : int = logging.get_logger(__name__) lowercase : Optional[Any] = {"""vocab_file""": """vocab.json"""} lowercase : Optional[Any] = { """vocab_file""": { """mgp-str""": """https://huggingface.co/alibaba-damo/mgp-str-base/blob/main/vocab.json""", } } lowercase : int = {"""mgp-str""": 27} class __snake_case ( lowerCAmelCase ): _a : List[Any]= VOCAB_FILES_NAMES _a : Optional[int]= PRETRAINED_VOCAB_FILES_MAP _a : str= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self ,snake_case ,snake_case="[GO]" ,snake_case="[GO]" ,snake_case="[s]" ,snake_case="[GO]" ,**snake_case ): '''simple docstring''' super().__init__( unk_token=snake_case ,bos_token=snake_case ,eos_token=snake_case ,pad_token=snake_case ,**snake_case ,) with open(snake_case ,encoding="""utf-8""" ) as vocab_handle: lowercase : Dict = json.load(snake_case ) lowercase : Dict = {v: k for k, v in self.vocab.items()} @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return len(self.vocab ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return dict(self.vocab ,**self.added_tokens_encoder ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Dict = [] for s in text: char_tokens.extend(snake_case ) return char_tokens def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.vocab.get(snake_case ,self.vocab.get(self.unk_token ) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.decoder.get(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' if not os.path.isdir(snake_case ): logger.error("""Vocabulary path ({}) should be a directory""".format(snake_case ) ) return lowercase : Dict = os.path.join( snake_case ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as f: f.write(json.dumps(self.vocab ,indent=2 ,sort_keys=snake_case ,ensure_ascii=snake_case ) + """\n""" ) return (vocab_file,)
20
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
1
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
import argparse import requests import torch from PIL import Image from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: if "cls_token" in name: lowercase : List[Any] = name.replace("""cls_token""" , """vit.embeddings.cls_token""" ) if "mask_token" in name: lowercase : Any = name.replace("""mask_token""" , """decoder.mask_token""" ) if "decoder_pos_embed" in name: lowercase : str = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : List[str] = name.replace("""pos_embed""" , """vit.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """vit.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : int = name.replace("""patch_embed.norm""" , """vit.embeddings.norm""" ) if "decoder_blocks" in name: lowercase : Tuple = name.replace("""decoder_blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[Any] = name.replace("""blocks""" , """vit.encoder.layer""" ) if "attn.proj" in name: lowercase : List[str] = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "norm1" in name: lowercase : Optional[Any] = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Union[str, Any] = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : Dict = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : Dict = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Dict = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : List[str] = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name: lowercase : Tuple = name.replace("""norm.weight""" , """vit.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name: lowercase : int = name.replace("""norm.bias""" , """vit.layernorm.bias""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: for key in orig_state_dict.copy().keys(): lowercase : List[Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if "qkv" in key: lowercase : int = key.split(""".""" ) lowercase : List[str] = int(key_split[1] ) if "decoder_blocks" in key: lowercase : Tuple = config.decoder_hidden_size lowercase : int = """decoder.decoder_layers.""" if "weight" in key: lowercase : List[Any] = val[:dim, :] lowercase : Tuple = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] elif "bias" in key: lowercase : str = val[:dim] lowercase : Dict = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Tuple = config.hidden_size lowercase : Union[str, Any] = """vit.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : Dict = val[-dim:, :] elif "bias" in key: lowercase : Any = val[:dim] lowercase : str = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Union[str, Any] = val return orig_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : int = ViTMAEConfig() if "large" in checkpoint_url: lowercase : Dict = 1_024 lowercase : str = 4_096 lowercase : Optional[Any] = 24 lowercase : Optional[Any] = 16 elif "huge" in checkpoint_url: lowercase : int = 14 lowercase : List[Any] = 1_280 lowercase : int = 5_120 lowercase : List[Any] = 32 lowercase : Any = 16 lowercase : List[str] = ViTMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" )["""model"""] lowercase : Tuple = ViTMAEImageProcessor(size=config.image_size ) lowercase : Optional[int] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() lowercase : Union[str, Any] = """https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg""" lowercase : Union[str, Any] = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ) lowercase : Optional[Any] = ViTMAEImageProcessor(size=config.image_size ) lowercase : List[Any] = image_processor(images=SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) # forward pass torch.manual_seed(2 ) lowercase : int = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits if "large" in checkpoint_url: lowercase : List[Any] = torch.tensor( [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]] ) elif "huge" in checkpoint_url: lowercase : Tuple = torch.tensor( [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]] ) else: lowercase : List[str] = torch.tensor( [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]] ) # verify logits assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print(f"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""", type=str, help="""URL of the checkpoint you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : List[Any] = parser.parse_args() convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
20
1
import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES from ...utils import logging from ..auto import CONFIG_MAPPING lowercase : str = logging.get_logger(__name__) lowercase : List[str] = { """salesforce/blip2-opt-2.7b""": """https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json""", } class __snake_case ( lowerCAmelCase ): _a : str= "blip_2_vision_model" def __init__( self ,snake_case=1408 ,snake_case=6144 ,snake_case=39 ,snake_case=16 ,snake_case=224 ,snake_case=14 ,snake_case="gelu" ,snake_case=0.00_001 ,snake_case=0.0 ,snake_case=1e-10 ,snake_case=True ,**snake_case ,): '''simple docstring''' super().__init__(**snake_case ) lowercase : str = hidden_size lowercase : int = intermediate_size lowercase : int = num_hidden_layers lowercase : Any = num_attention_heads lowercase : str = patch_size lowercase : Union[str, Any] = image_size lowercase : List[Any] = initializer_range lowercase : Tuple = attention_dropout lowercase : Optional[int] = layer_norm_eps lowercase : List[Any] = hidden_act lowercase : str = qkv_bias @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,**snake_case ): '''simple docstring''' cls._set_token_in_kwargs(snake_case ) lowercase , lowercase : Union[str, Any] = cls.get_config_dict(snake_case ,**snake_case ) # get the vision config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": lowercase : Optional[int] = config_dict["""vision_config"""] if "model_type" in config_dict and hasattr(cls ,"""model_type""" ) and config_dict["model_type"] != cls.model_type: logger.warning( f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." ) return cls.from_dict(snake_case ,**snake_case ) class __snake_case ( lowerCAmelCase ): _a : List[str]= "blip_2_qformer" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=0 ,snake_case="absolute" ,snake_case=2 ,snake_case=1408 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,**snake_case ) lowercase : Optional[Any] = vocab_size lowercase : int = hidden_size lowercase : Union[str, Any] = num_hidden_layers lowercase : int = num_attention_heads lowercase : Optional[int] = hidden_act lowercase : Dict = intermediate_size lowercase : Dict = hidden_dropout_prob lowercase : Any = attention_probs_dropout_prob lowercase : Any = max_position_embeddings lowercase : Dict = initializer_range lowercase : str = layer_norm_eps lowercase : Union[str, Any] = position_embedding_type lowercase : List[str] = cross_attention_frequency lowercase : Union[str, Any] = encoder_hidden_size @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,**snake_case ): '''simple docstring''' cls._set_token_in_kwargs(snake_case ) lowercase , lowercase : Optional[int] = cls.get_config_dict(snake_case ,**snake_case ) # get the qformer config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": lowercase : Tuple = config_dict["""qformer_config"""] if "model_type" in config_dict and hasattr(cls ,"""model_type""" ) and config_dict["model_type"] != cls.model_type: logger.warning( f"You are using a model of type {config_dict['model_type']} to instantiate a model of type " f"{cls.model_type}. This is not supported for all configurations of models and can yield errors." ) return cls.from_dict(snake_case ,**snake_case ) class __snake_case ( lowerCAmelCase ): _a : Optional[int]= "blip-2" _a : Optional[Any]= True def __init__( self ,snake_case=None ,snake_case=None ,snake_case=None ,snake_case=32 ,**snake_case ): '''simple docstring''' super().__init__(**snake_case ) if vision_config is None: lowercase : List[str] = {} logger.info("""vision_config is None. initializing the Blip2VisionConfig with default values.""" ) if qformer_config is None: lowercase : str = {} logger.info("""qformer_config is None. Initializing the Blip2QFormerConfig with default values.""" ) if text_config is None: lowercase : str = {} logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`).""" ) lowercase : str = BlipaVisionConfig(**snake_case ) lowercase : Union[str, Any] = BlipaQFormerConfig(**snake_case ) lowercase : Optional[Any] = text_config["""model_type"""] if """model_type""" in text_config else """opt""" lowercase : int = CONFIG_MAPPING[text_model_type](**snake_case ) lowercase : Optional[int] = self.text_config.tie_word_embeddings lowercase : Dict = self.text_config.is_encoder_decoder lowercase : List[Any] = num_query_tokens lowercase : int = self.vision_config.hidden_size lowercase : List[str] = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES lowercase : List[str] = 1.0 lowercase : Union[str, Any] = 0.02 @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,snake_case ,snake_case ,**snake_case ,): '''simple docstring''' return cls( vision_config=vision_config.to_dict() ,qformer_config=qformer_config.to_dict() ,text_config=text_config.to_dict() ,**snake_case ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = copy.deepcopy(self.__dict__ ) lowercase : Dict = self.vision_config.to_dict() lowercase : Any = self.qformer_config.to_dict() lowercase : Any = self.text_config.to_dict() lowercase : int = self.__class__.model_type return output
20
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=0.999 , SCREAMING_SNAKE_CASE__="cosine" , ) -> List[Any]: if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.exp(t * -12.0 ) else: raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}" ) lowercase : int = [] for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = i / num_diffusion_timesteps lowercase : Optional[int] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) / alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ) ) return torch.tensor(SCREAMING_SNAKE_CASE__ , dtype=torch.floataa ) class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Tuple= [e.name for e in KarrasDiffusionSchedulers] _a : int= 2 @register_to_config def __init__( self ,snake_case = 1000 ,snake_case = 0.00_085 ,snake_case = 0.012 ,snake_case = "linear" ,snake_case = None ,snake_case = "epsilon" ,snake_case = False ,snake_case = False ,snake_case = 1.0 ,snake_case = "linspace" ,snake_case = 0 ,): '''simple docstring''' if trained_betas is not None: lowercase : List[str] = torch.tensor(snake_case ,dtype=torch.floataa ) elif beta_schedule == "linear": lowercase : Optional[Any] = torch.linspace(snake_case ,snake_case ,snake_case ,dtype=torch.floataa ) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. lowercase : int = ( torch.linspace(beta_start**0.5 ,beta_end**0.5 ,snake_case ,dtype=torch.floataa ) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule lowercase : Union[str, Any] = betas_for_alpha_bar(snake_case ,alpha_transform_type="""cosine""" ) elif beta_schedule == "exp": lowercase : int = betas_for_alpha_bar(snake_case ,alpha_transform_type="""exp""" ) else: raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}" ) lowercase : Any = 1.0 - self.betas lowercase : Dict = torch.cumprod(self.alphas ,dim=0 ) # set all values self.set_timesteps(snake_case ,snake_case ,snake_case ) lowercase : Tuple = use_karras_sigmas def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if schedule_timesteps is None: lowercase : Union[str, Any] = self.timesteps lowercase : Dict = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter ) == 0: lowercase : Dict = 1 if len(snake_case ) > 1 else 0 else: lowercase : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep lowercase : str = self._index_counter[timestep_int] return indices[pos].item() @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[Any] = self.index_for_timestep(snake_case ) lowercase : Dict = self.sigmas[step_index] lowercase : List[str] = sample / ((sigma**2 + 1) ** 0.5) return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,): '''simple docstring''' lowercase : Any = num_inference_steps lowercase : List[Any] = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": lowercase : Optional[int] = np.linspace(0 ,num_train_timesteps - 1 ,snake_case ,dtype=snake_case )[::-1].copy() elif self.config.timestep_spacing == "leading": lowercase : int = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : List[str] = (np.arange(0 ,snake_case ) * step_ratio).round()[::-1].copy().astype(snake_case ) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": lowercase : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : Optional[int] = (np.arange(snake_case ,0 ,-step_ratio )).round().copy().astype(snake_case ) timesteps -= 1 else: raise ValueError( f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." ) lowercase : Optional[int] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 ) lowercase : Dict = np.log(snake_case ) lowercase : Union[str, Any] = np.interp(snake_case ,np.arange(0 ,len(snake_case ) ) ,snake_case ) if self.config.use_karras_sigmas: lowercase : List[Any] = self._convert_to_karras(in_sigmas=snake_case ,num_inference_steps=self.num_inference_steps ) lowercase : Tuple = np.array([self._sigma_to_t(snake_case ,snake_case ) for sigma in sigmas] ) lowercase : Any = np.concatenate([sigmas, [0.0]] ).astype(np.floataa ) lowercase : List[Any] = torch.from_numpy(snake_case ).to(device=snake_case ) lowercase : List[Any] = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2 ), sigmas[-1:]] ) lowercase : Dict = torch.from_numpy(snake_case ) lowercase : List[Any] = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2 )] ) if str(snake_case ).startswith("""mps""" ): # mps does not support float64 lowercase : Any = timesteps.to(snake_case ,dtype=torch.floataa ) else: lowercase : str = timesteps.to(device=snake_case ) # empty dt and derivative lowercase : Union[str, Any] = None lowercase : Any = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter lowercase : str = defaultdict(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = np.log(snake_case ) # get distribution lowercase : Union[str, Any] = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range lowercase : Optional[int] = np.cumsum((dists >= 0) ,axis=0 ).argmax(axis=0 ).clip(max=log_sigmas.shape[0] - 2 ) lowercase : Any = low_idx + 1 lowercase : str = log_sigmas[low_idx] lowercase : Dict = log_sigmas[high_idx] # interpolate sigmas lowercase : int = (low - log_sigma) / (low - high) lowercase : Dict = np.clip(snake_case ,0 ,1 ) # transform interpolation to time range lowercase : Optional[Any] = (1 - w) * low_idx + w * high_idx lowercase : Tuple = t.reshape(sigma.shape ) return t def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : float = in_sigmas[-1].item() lowercase : float = in_sigmas[0].item() lowercase : Dict = 7.0 # 7.0 is the value used in the paper lowercase : Optional[int] = np.linspace(0 ,1 ,snake_case ) lowercase : int = sigma_min ** (1 / rho) lowercase : Any = sigma_max ** (1 / rho) lowercase : Tuple = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.dt is None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = True ,): '''simple docstring''' lowercase : Union[str, Any] = self.index_for_timestep(snake_case ) # advance index counter by 1 lowercase : Optional[int] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: lowercase : str = self.sigmas[step_index] lowercase : Optional[int] = self.sigmas[step_index + 1] else: # 2nd order / Heun's method lowercase : Dict = self.sigmas[step_index - 1] lowercase : Optional[Any] = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API lowercase : Union[str, Any] = 0 lowercase : Any = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": lowercase : Any = sigma_hat if self.state_in_first_order else sigma_next lowercase : int = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": lowercase : Union[str, Any] = sigma_hat if self.state_in_first_order else sigma_next lowercase : Optional[Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": lowercase : Optional[Any] = model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`" ) if self.config.clip_sample: lowercase : str = pred_original_sample.clamp( -self.config.clip_sample_range ,self.config.clip_sample_range ) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order lowercase : Optional[int] = (sample - pred_original_sample) / sigma_hat # 3. delta timestep lowercase : Union[str, Any] = sigma_next - sigma_hat # store for 2nd order step lowercase : Optional[int] = derivative lowercase : Union[str, Any] = dt lowercase : Union[str, Any] = sample else: # 2. 2nd order / Heun's method lowercase : Tuple = (sample - pred_original_sample) / sigma_next lowercase : Dict = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample lowercase : Tuple = self.dt lowercase : Optional[Any] = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" lowercase : List[str] = None lowercase : Tuple = None lowercase : Dict = None lowercase : List[Any] = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[int] = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype ) if original_samples.device.type == "mps" and torch.is_floating_point(snake_case ): # mps does not support float64 lowercase : List[Any] = self.timesteps.to(original_samples.device ,dtype=torch.floataa ) lowercase : List[str] = timesteps.to(original_samples.device ,dtype=torch.floataa ) else: lowercase : List[str] = self.timesteps.to(original_samples.device ) lowercase : Tuple = timesteps.to(original_samples.device ) lowercase : Any = [self.index_for_timestep(snake_case ,snake_case ) for t in timesteps] lowercase : int = sigmas[step_indices].flatten() while len(sigma.shape ) < len(original_samples.shape ): lowercase : Any = sigma.unsqueeze(-1 ) lowercase : Optional[int] = original_samples + noise * sigma return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
1
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase : Optional[Any] = logging.get_logger(__name__) lowercase : str = """▁""" lowercase : Dict = {"""vocab_file""": """vocab.txt""", """sentencepiece_model_ckpt""": """sentencepiece.bpe.model"""} lowercase : Optional[Any] = { """sentencepiece_model_file""": """sentencepiece.bpe.model""", """vocab_file""": """vocab.txt""", } lowercase : str = { """vocab_file""": { """ernie-m-base""": """https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt""", """ernie-m-large""": """https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt""", }, """sentencepiece_model_file""": { """ernie-m-base""": """https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model""", """ernie-m-large""": """https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model""", }, } lowercase : int = { """ernie-m-base""": 514, """ernie-m-large""": 514, } lowercase : List[Any] = { """ernie-m-base""": {"""do_lower_case""": False}, """ernie-m-large""": {"""do_lower_case""": False}, } class __snake_case ( lowerCAmelCase ): _a : List[str]= ["input_ids"] _a : Optional[Any]= VOCAB_FILES_NAMES _a : Tuple= PRETRAINED_INIT_CONFIGURATION _a : Optional[int]= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : int= PRETRAINED_VOCAB_FILES_MAP _a : Dict= RESOURCE_FILES_NAMES def __init__( self ,snake_case ,snake_case=None ,snake_case=False ,snake_case="utf8" ,snake_case="[UNK]" ,snake_case="[SEP]" ,snake_case="[PAD]" ,snake_case="[CLS]" ,snake_case="[MASK]" ,snake_case = None ,**snake_case ,): '''simple docstring''' lowercase : Dict = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=snake_case ,unk_token=snake_case ,sep_token=snake_case ,pad_token=snake_case ,cls_token=snake_case ,mask_token=snake_case ,vocab_file=snake_case ,encoding=snake_case ,sp_model_kwargs=self.sp_model_kwargs ,**snake_case ,) lowercase : List[str] = do_lower_case lowercase : List[Any] = sentencepiece_model_ckpt lowercase : Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(snake_case ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: lowercase : Dict = self.load_vocab(filepath=snake_case ) else: lowercase : Dict = {self.sp_model.id_to_piece(snake_case ): id for id in range(self.sp_model.get_piece_size() )} lowercase : Optional[int] = {v: k for k, v in self.vocab.items()} def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if text is None: return None lowercase : Optional[Any] = self.tokenize(snake_case ) lowercase , lowercase : Tuple = """""", [] for i, ch in enumerate(snake_case ): if ch in self.SP_CHAR_MAPPING: lowercase : Tuple = self.SP_CHAR_MAPPING.get(snake_case ) else: lowercase : str = unicodedata.normalize("""NFKC""" ,snake_case ) if self.is_whitespace(snake_case ): continue normalized_text += ch char_mapping.extend([i] * len(snake_case ) ) lowercase , lowercase , lowercase : Union[str, Any] = normalized_text, [], 0 if self.do_lower_case: lowercase : str = text.lower() for token in split_tokens: if token[:1] == "▁": lowercase : Optional[int] = token[1:] lowercase : Optional[int] = text[offset:].index(snake_case ) + offset lowercase : Union[str, Any] = start + len(snake_case ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) lowercase : List[Any] = end return token_mapping @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return len(self.vocab ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return dict(self.vocab ,**self.added_tokens_encoder ) def __getstate__( self ): '''simple docstring''' lowercase : List[str] = self.__dict__.copy() lowercase : Optional[int] = None return state def __setstate__( self ,snake_case ): '''simple docstring''' lowercase : Optional[Any] = d # for backward compatibility if not hasattr(self ,"""sp_model_kwargs""" ): lowercase : List[Any] = {} lowercase : Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return "".join((self.SP_CHAR_MAPPING.get(snake_case ,snake_case ) for c in text) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=False ,snake_case=64 ,snake_case=0.1 ): '''simple docstring''' if self.sp_model_kwargs.get("""enable_sampling""" ) is True: lowercase : Union[str, Any] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: lowercase : Optional[int] = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: lowercase : int = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: lowercase : Tuple = self.sp_model.EncodeAsPieces(snake_case ) else: lowercase : Tuple = self.sp_model.SampleEncodeAsPieces(snake_case ,snake_case ,snake_case ) lowercase : Any = [] for pi, piece in enumerate(snake_case ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(snake_case ) and pi != 0: new_pieces.append(snake_case ) continue else: continue lowercase : Optional[Any] = 0 for i, chunk in enumerate(snake_case ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(snake_case ) or self.is_punct(snake_case ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(snake_case ) lowercase : List[Any] = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) lowercase : List[Any] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) lowercase : List[Any] = i if len(snake_case ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = """""".join(snake_case ).replace(snake_case ,""" """ ).strip() return out_string def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[Any] = self.convert_ids_to_tokens(snake_case ) lowercase : Any = """""".join(snake_case ).replace(snake_case ,""" """ ).strip() return out_string def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.vocab.get(snake_case ,self.vocab.get(self.unk_token ) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.reverse_vocab.get(snake_case ,self.unk_token ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] lowercase : int = [self.cls_token_id] lowercase : Union[str, Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case=False ): '''simple docstring''' if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(snake_case )) + [1, 1] + ([0] * len(snake_case )) + [1] return [1] + ([0] * len(snake_case )) + [1] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' if token_ids_a is None: # [CLS] X [SEP] return (len(snake_case ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(snake_case ) + 1) + [1] * (len(snake_case ) + 3) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if "\u4e00" <= char <= "\u9fff": return True return False def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if char in ",;:.?!~,;:。?!《》【】": return True return False def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(snake_case ) == 1: lowercase : Optional[Any] = unicodedata.category(snake_case ) if cat == "Zs": return True return False def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = {} with io.open(snake_case ,"""r""" ,encoding="""utf-8""" ) as f: for index, line in enumerate(snake_case ): lowercase : Any = line.rstrip("""\n""" ) lowercase : Union[str, Any] = int(snake_case ) return token_to_idx def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : Dict = 0 if os.path.isdir(snake_case ): lowercase : int = os.path.join( snake_case ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: lowercase : List[str] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() ,key=lambda snake_case : kv[1] ): if index != token_index: logger.warning( f"Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive." """ Please check that the vocabulary is not corrupted!""" ) lowercase : Any = token_index writer.write(token + """\n""" ) index += 1 lowercase : List[Any] = os.path.join(snake_case ,"""sentencepiece.bpe.model""" ) with open(snake_case ,"""wb""" ) as fi: lowercase : List[Any] = self.sp_model.serialized_model_proto() fi.write(snake_case ) return (vocab_file,)
20
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch lowercase : List[str] = logging.get_logger(__name__) @add_end_docstrings( lowerCAmelCase , R"\n top_k (`int`, defaults to 5):\n The number of predictions to return.\n targets (`str` or `List[str]`, *optional*):\n When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n token will be used (with a warning, and that might be slower).\n\n " , ) class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if self.framework == "tf": lowercase : str = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": lowercase : Optional[int] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ) else: raise ValueError("""Unsupported framework""" ) return masked_index def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = self.get_masked_index(snake_case ) lowercase : Dict = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,f"No mask_token ({self.tokenizer.mask_token}) found on the input" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if isinstance(snake_case ,snake_case ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,**snake_case ): '''simple docstring''' if return_tensors is None: lowercase : int = self.framework lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=snake_case ) self.ensure_exactly_one_mask_token(snake_case ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[int] = self.model(**snake_case ) lowercase : Tuple = model_inputs["""input_ids"""] return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ,snake_case=None ): '''simple docstring''' if target_ids is not None and target_ids.shape[0] < top_k: lowercase : str = target_ids.shape[0] lowercase : Optional[Any] = model_outputs["""input_ids"""][0] lowercase : List[str] = model_outputs["""logits"""] if self.framework == "tf": lowercase : List[str] = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] lowercase : Tuple = outputs.numpy() lowercase : Tuple = outputs[0, masked_index, :] lowercase : Any = stable_softmax(snake_case ,axis=-1 ) if target_ids is not None: lowercase : Union[str, Any] = tf.gather_nd(tf.squeeze(snake_case ,0 ) ,target_ids.reshape(-1 ,1 ) ) lowercase : int = tf.expand_dims(snake_case ,0 ) lowercase : Tuple = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : int = topk.values.numpy(), topk.indices.numpy() else: lowercase : Optional[Any] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample lowercase : Union[str, Any] = outputs[0, masked_index, :] lowercase : Tuple = logits.softmax(dim=-1 ) if target_ids is not None: lowercase : List[str] = probs[..., target_ids] lowercase , lowercase : Union[str, Any] = probs.topk(snake_case ) lowercase : Any = [] lowercase : List[Any] = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() ,predictions.tolist() ) ): lowercase : Dict = [] for v, p in zip(_values ,_predictions ): # Copy is important since we're going to modify this array in place lowercase : Dict = input_ids.numpy().copy() if target_ids is not None: lowercase : Union[str, Any] = target_ids[p].tolist() lowercase : Tuple = p # Filter padding out: lowercase : List[str] = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back lowercase : Tuple = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : Optional[Any] = {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p] ), """sequence""": sequence} row.append(snake_case ) result.append(snake_case ) if single_mask: return result[0] return result def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if isinstance(snake_case ,snake_case ): lowercase : List[Any] = [targets] try: lowercase : List[str] = self.tokenizer.get_vocab() except Exception: lowercase : Any = {} lowercase : Dict = [] for target in targets: lowercase : Dict = vocab.get(snake_case ,snake_case ) if id_ is None: lowercase : Optional[int] = self.tokenizer( snake_case ,add_special_tokens=snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,max_length=1 ,truncation=snake_case ,)["""input_ids"""] if len(snake_case ) == 0: logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " """We cannot replace it with anything meaningful, ignoring it""" ) continue lowercase : Union[str, Any] = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`." ) target_ids.append(id_ ) lowercase : Optional[Any] = list(set(snake_case ) ) if len(snake_case ) == 0: raise ValueError("""At least one target must be provided when passed.""" ) lowercase : Optional[Any] = np.array(snake_case ) return target_ids def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : Dict = {} if targets is not None: lowercase : str = self.get_target_ids(snake_case ,snake_case ) lowercase : List[Any] = target_ids if top_k is not None: lowercase : List[str] = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,"""The tokenizer does not define a `mask_token`.""" ) return {}, {}, postprocess_params def __call__( self ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Tuple = super().__call__(snake_case ,**snake_case ) if isinstance(snake_case ,snake_case ) and len(snake_case ) == 1: return outputs[0] return outputs
20
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase : List[Any] = logging.get_logger(__name__) lowercase : Dict = { """xlm-mlm-en-2048""": """https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json""", """xlm-mlm-ende-1024""": """https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json""", """xlm-mlm-enfr-1024""": """https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json""", """xlm-mlm-enro-1024""": """https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json""", """xlm-mlm-tlm-xnli15-1024""": """https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json""", """xlm-mlm-xnli15-1024""": """https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json""", """xlm-clm-enfr-1024""": """https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json""", """xlm-clm-ende-1024""": """https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json""", """xlm-mlm-17-1280""": """https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json""", """xlm-mlm-100-1280""": """https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json""", } class __snake_case ( lowerCAmelCase ): _a : Optional[int]= "xlm" _a : List[str]= { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self ,snake_case=30145 ,snake_case=2048 ,snake_case=12 ,snake_case=16 ,snake_case=0.1 ,snake_case=0.1 ,snake_case=True ,snake_case=False ,snake_case=False ,snake_case=False ,snake_case=1 ,snake_case=True ,snake_case=512 ,snake_case=2048**-0.5 ,snake_case=1e-12 ,snake_case=0.02 ,snake_case=0 ,snake_case=1 ,snake_case=2 ,snake_case=3 ,snake_case=5 ,snake_case=True ,snake_case="first" ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=0.1 ,snake_case=5 ,snake_case=5 ,snake_case=0 ,snake_case=0 ,snake_case=2 ,snake_case=0 ,**snake_case ,): '''simple docstring''' lowercase : Optional[int] = vocab_size lowercase : Any = emb_dim lowercase : Union[str, Any] = n_layers lowercase : Tuple = n_heads lowercase : Any = dropout lowercase : Optional[int] = attention_dropout lowercase : List[Any] = gelu_activation lowercase : List[str] = sinusoidal_embeddings lowercase : Dict = causal lowercase : List[Any] = asm lowercase : Optional[Any] = n_langs lowercase : Any = use_lang_emb lowercase : Optional[Any] = layer_norm_eps lowercase : Dict = bos_index lowercase : List[str] = eos_index lowercase : str = pad_index lowercase : str = unk_index lowercase : str = mask_index lowercase : str = is_encoder lowercase : Optional[int] = max_position_embeddings lowercase : Optional[Any] = embed_init_std lowercase : str = init_std lowercase : str = summary_type lowercase : Optional[Any] = summary_use_proj lowercase : int = summary_activation lowercase : List[str] = summary_proj_to_labels lowercase : Tuple = summary_first_dropout lowercase : str = start_n_top lowercase : Optional[int] = end_n_top lowercase : Optional[Any] = mask_token_id lowercase : Union[str, Any] = lang_id if "n_words" in kwargs: lowercase : Tuple = kwargs["""n_words"""] super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,**snake_case ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.task == "multiple-choice": lowercase : List[Any] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: lowercase : Optional[int] = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
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 MobileNetVaImageProcessor class __snake_case ( unittest.TestCase ): def __init__( self ,snake_case ,snake_case=7 ,snake_case=3 ,snake_case=18 ,snake_case=30 ,snake_case=400 ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=None ,): '''simple docstring''' lowercase : Dict = size if size is not None else {"""shortest_edge""": 20} lowercase : Union[str, Any] = crop_size if crop_size is not None else {"""height""": 18, """width""": 18} lowercase : str = parent lowercase : int = batch_size lowercase : str = num_channels lowercase : int = image_size lowercase : List[str] = min_resolution lowercase : str = max_resolution lowercase : Dict = do_resize lowercase : Dict = size lowercase : Dict = do_center_crop lowercase : str = crop_size def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, } @require_torch @require_vision class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Any= MobileNetVaImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = MobileNetVaImageProcessingTester(self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case ,"""do_resize""" ) ) self.assertTrue(hasattr(snake_case ,"""size""" ) ) self.assertTrue(hasattr(snake_case ,"""do_center_crop""" ) ) self.assertTrue(hasattr(snake_case ,"""crop_size""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 20} ) self.assertEqual(image_processor.crop_size ,{"""height""": 18, """width""": 18} ) lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 ,crop_size=84 ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 42} ) self.assertEqual(image_processor.crop_size ,{"""height""": 84, """width""": 84} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowercase : str = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,Image.Image ) # Test not batched input lowercase : Dict = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : Tuple = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,numpify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,np.ndarray ) # Test not batched input lowercase : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,torchify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,torch.Tensor ) # Test not batched input lowercase : Optional[int] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,)
20
1
from typing import Dict, List, Optional, Union import numpy as np from transformers.utils import is_vision_available from transformers.utils.generic import TensorType from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, is_valid_image, to_numpy_array, valid_images, ) from ...utils import logging if is_vision_available(): import PIL lowercase : int = logging.get_logger(__name__) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[List[ImageInput]]: if isinstance(SCREAMING_SNAKE_CASE__ , (list, tuple) ) and isinstance(videos[0] , (list, tuple) ) and is_valid_image(videos[0][0] ): return videos elif isinstance(SCREAMING_SNAKE_CASE__ , (list, tuple) ) and is_valid_image(videos[0] ): return [videos] elif is_valid_image(SCREAMING_SNAKE_CASE__ ): return [[videos]] raise ValueError(f"Could not make batched video from {videos}" ) class __snake_case ( lowerCAmelCase ): _a : Dict= ["pixel_values"] def __init__( self ,snake_case = True ,snake_case = None ,snake_case = PILImageResampling.BILINEAR ,snake_case = True ,snake_case = None ,snake_case = True ,snake_case = 1 / 255 ,snake_case = True ,snake_case = True ,snake_case = None ,snake_case = None ,**snake_case ,): '''simple docstring''' super().__init__(**snake_case ) lowercase : int = size if size is not None else {"""shortest_edge""": 256} lowercase : Union[str, Any] = get_size_dict(snake_case ,default_to_square=snake_case ) lowercase : str = crop_size if crop_size is not None else {"""height""": 224, """width""": 224} lowercase : Tuple = get_size_dict(snake_case ,param_name="""crop_size""" ) lowercase : Union[str, Any] = do_resize lowercase : str = size lowercase : Optional[int] = do_center_crop lowercase : List[Any] = crop_size lowercase : List[str] = resample lowercase : Any = do_rescale lowercase : Union[str, Any] = rescale_factor lowercase : Any = offset lowercase : Optional[int] = do_normalize lowercase : Optional[int] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN lowercase : Tuple = image_std if image_std is not None else IMAGENET_STANDARD_STD def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case = PILImageResampling.BILINEAR ,snake_case = None ,**snake_case ,): '''simple docstring''' lowercase : List[Any] = get_size_dict(snake_case ,default_to_square=snake_case ) if "shortest_edge" in size: lowercase : str = get_resize_output_image_size(snake_case ,size["""shortest_edge"""] ,default_to_square=snake_case ) elif "height" in size and "width" in size: lowercase : Optional[int] = (size["""height"""], size["""width"""]) else: raise ValueError(f"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}" ) return resize(snake_case ,size=snake_case ,resample=snake_case ,data_format=snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case = None ,**snake_case ,): '''simple docstring''' lowercase : List[Any] = get_size_dict(snake_case ) if "height" not in size or "width" not in size: raise ValueError(f"Size must have 'height' and 'width' as keys. Got {size.keys()}" ) return center_crop(snake_case ,size=(size["""height"""], size["""width"""]) ,data_format=snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case = True ,snake_case = None ,**snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = image.astype(np.floataa ) if offset: lowercase : Optional[Any] = image - (scale / 2) return rescale(snake_case ,scale=snake_case ,data_format=snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = None ,**snake_case ,): '''simple docstring''' return normalize(snake_case ,mean=snake_case ,std=snake_case ,data_format=snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = ChannelDimension.FIRST ,): '''simple docstring''' if do_resize and size is None or resample is None: raise ValueError("""Size and resample must be specified if do_resize is True.""" ) if do_center_crop and crop_size is None: raise ValueError("""Crop size must be specified if do_center_crop is True.""" ) if do_rescale and rescale_factor is None: raise ValueError("""Rescale factor must be specified if do_rescale is True.""" ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("""Image mean and std must be specified if do_normalize is True.""" ) if offset and not do_rescale: raise ValueError("""For offset, do_rescale must also be set to True.""" ) # All transformations expect numpy arrays. lowercase : Optional[int] = to_numpy_array(snake_case ) if do_resize: lowercase : Union[str, Any] = self.resize(image=snake_case ,size=snake_case ,resample=snake_case ) if do_center_crop: lowercase : Optional[Any] = self.center_crop(snake_case ,size=snake_case ) if do_rescale: lowercase : Optional[int] = self.rescale(image=snake_case ,scale=snake_case ,offset=snake_case ) if do_normalize: lowercase : Any = self.normalize(image=snake_case ,mean=snake_case ,std=snake_case ) lowercase : Any = to_channel_dimension_format(snake_case ,snake_case ) return image def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = None ,snake_case = ChannelDimension.FIRST ,**snake_case ,): '''simple docstring''' lowercase : List[Any] = do_resize if do_resize is not None else self.do_resize lowercase : List[str] = resample if resample is not None else self.resample lowercase : str = do_center_crop if do_center_crop is not None else self.do_center_crop lowercase : Any = do_rescale if do_rescale is not None else self.do_rescale lowercase : str = rescale_factor if rescale_factor is not None else self.rescale_factor lowercase : List[str] = offset if offset is not None else self.offset lowercase : Optional[int] = do_normalize if do_normalize is not None else self.do_normalize lowercase : Union[str, Any] = image_mean if image_mean is not None else self.image_mean lowercase : Optional[Any] = image_std if image_std is not None else self.image_std lowercase : int = size if size is not None else self.size lowercase : List[Any] = get_size_dict(snake_case ,default_to_square=snake_case ) lowercase : str = crop_size if crop_size is not None else self.crop_size lowercase : List[Any] = get_size_dict(snake_case ,param_name="""crop_size""" ) if not valid_images(snake_case ): raise ValueError( """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """ """torch.Tensor, tf.Tensor or jax.ndarray.""" ) lowercase : List[Any] = make_batched(snake_case ) lowercase : Any = [ [ self._preprocess_image( image=snake_case ,do_resize=snake_case ,size=snake_case ,resample=snake_case ,do_center_crop=snake_case ,crop_size=snake_case ,do_rescale=snake_case ,rescale_factor=snake_case ,offset=snake_case ,do_normalize=snake_case ,image_mean=snake_case ,image_std=snake_case ,data_format=snake_case ,) for img in video ] for video in videos ] lowercase : Optional[int] = {"""pixel_values""": videos} return BatchFeature(data=snake_case ,tensor_type=snake_case )
20
from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef import datasets lowercase : str = """\ @inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019} } """ lowercase : Dict = """\ GLUE, the General Language Understanding Evaluation benchmark (https://gluebenchmark.com/) is a collection of resources for training, evaluating, and analyzing natural language understanding systems. """ lowercase : int = """ Compute GLUE evaluation metric associated to each GLUE dataset. Args: predictions: list of predictions to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. Returns: depending on the GLUE subset, one or several of: \"accuracy\": Accuracy \"f1\": F1 score \"pearson\": Pearson Correlation \"spearmanr\": Spearman Correlation \"matthews_correlation\": Matthew Correlation Examples: >>> glue_metric = datasets.load_metric('glue', 'sst2') # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"] >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> glue_metric = datasets.load_metric('glue', 'mrpc') # 'mrpc' or 'qqp' >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> glue_metric = datasets.load_metric('glue', 'stsb') >>> references = [0., 1., 2., 3., 4., 5.] >>> predictions = [0., 1., 2., 3., 4., 5.] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)}) {'pearson': 1.0, 'spearmanr': 1.0} >>> glue_metric = datasets.load_metric('glue', 'cola') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: return float((preds == labels).mean() ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = simple_accuracy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = float(fa_score(y_true=SCREAMING_SNAKE_CASE__ , y_pred=SCREAMING_SNAKE_CASE__ ) ) return { "accuracy": acc, "f1": fa, } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = float(pearsonr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) lowercase : Dict = float(spearmanr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) return { "pearson": pearson_corr, "spearmanr": spearman_corr, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config_name not in [ "sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans", ]: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), } ) ,codebase_urls=[] ,reference_urls=[] ,format="""numpy""" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if self.config_name == "cola": return {"matthews_correlation": matthews_corrcoef(snake_case ,snake_case )} elif self.config_name == "stsb": return pearson_and_spearman(snake_case ,snake_case ) elif self.config_name in ["mrpc", "qqp"]: return acc_and_fa(snake_case ,snake_case ) elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]: return {"accuracy": simple_accuracy(snake_case ,snake_case )} else: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" )
20
1
import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class __snake_case ( tf.keras.layers.Layer ): def __init__( self ,snake_case ,snake_case ,snake_case = None ,snake_case = None ): '''simple docstring''' super().__init__() lowercase : int = pad_token_id lowercase : Dict = max_length lowercase : Optional[int] = vocab lowercase : Tuple = merges lowercase : int = BytePairTokenizer(snake_case ,snake_case ,sequence_length=snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = [""" """.join(snake_case ) for m in tokenizer.bpe_ranks.keys()] lowercase : Optional[Any] = tokenizer.get_vocab() return cls(snake_case ,snake_case ,*snake_case ,**snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Any = GPTaTokenizer.from_pretrained(snake_case ,*snake_case ,**snake_case ) return cls.from_tokenizer(snake_case ,*snake_case ,**snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ): '''simple docstring''' return cls(**snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' lowercase : List[Any] = self.tf_tokenizer(snake_case ) lowercase : List[str] = tf.ones_like(snake_case ) if self.pad_token_id is not None: # pad the tokens up to max length lowercase : List[str] = max_length if max_length is not None else self.max_length if max_length is not None: lowercase , lowercase : List[Any] = pad_model_inputs( snake_case ,max_seq_length=snake_case ,pad_value=self.pad_token_id ) return {"attention_mask": attention_mask, "input_ids": input_ids}
20
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
1
import os import numpy import onnx def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : int = a.name lowercase : Any = b.name lowercase : Optional[Any] = """""" lowercase : Dict = """""" lowercase : int = a == b lowercase : int = name_a lowercase : List[str] = name_b return res def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) _graph_replace_input_with(node_proto.attribute[1].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for n in graph_proto.node: _node_replace_input_with(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Any = list(model.graph.initializer ) lowercase : Dict = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i lowercase : Union[str, Any] = inits[i].name lowercase : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Union[str, Any] = os.path.dirname(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = os.path.basename(SCREAMING_SNAKE_CASE__ ) lowercase : str = onnx.load(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) lowercase : List[str] = list(model.graph.initializer ) lowercase : Tuple = set() lowercase : int = {} lowercase : Optional[Any] = [] lowercase : Dict = 0 for i in range(len(SCREAMING_SNAKE_CASE__ ) ): if i in dup_set: continue for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(SCREAMING_SNAKE_CASE__ ) dup_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : int = inits[j].data_type lowercase : Optional[int] = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 11: mem_size *= 8 else: print("""unexpected data type: """ , SCREAMING_SNAKE_CASE__ ) total_reduced_size += mem_size lowercase : Tuple = inits[i].name lowercase : int = inits[j].name if name_i in dup_map: dup_map[name_i].append(SCREAMING_SNAKE_CASE__ ) else: lowercase : List[str] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_024 / 1_024 / 1_024 , """GB""" ) lowercase : str = sorted(SCREAMING_SNAKE_CASE__ ) _remove_dup_initializers_from_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = """optimized_""" + model_file_name lowercase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) onnx.save(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return new_model
20
from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class __snake_case : _a : int _a : TreeNode | None= None _a : TreeNode | None= None lowercase : Dict = namedtuple("""CoinsDistribResult""", """moves excess""") def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if root is None: return 0 # Validation def count_nodes(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(SCREAMING_SNAKE_CASE__ ) != count_coins(SCREAMING_SNAKE_CASE__ ): raise ValueError("""The nodes number should be same as the number of coins""" ) # Main calculation def get_distrib(SCREAMING_SNAKE_CASE__ ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 , 1 ) lowercase , lowercase : int = get_distrib(node.left ) lowercase , lowercase : List[Any] = get_distrib(node.right ) lowercase : Optional[Any] = 1 - left_distrib_excess lowercase : Union[str, Any] = 1 - right_distrib_excess lowercase : List[Any] = ( left_distrib_moves + right_distrib_moves + abs(SCREAMING_SNAKE_CASE__ ) + abs(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = node.data - coins_to_left - coins_to_right return CoinsDistribResult(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return get_distrib(SCREAMING_SNAKE_CASE__ )[0] if __name__ == "__main__": import doctest doctest.testmod()
20
1
import json import os import sys import tempfile import unittest from pathlib import Path from shutil import copyfile from huggingface_hub import HfFolder, Repository, create_repo, delete_repo from requests.exceptions import HTTPError import transformers from transformers import ( CONFIG_MAPPING, FEATURE_EXTRACTOR_MAPPING, PROCESSOR_MAPPING, TOKENIZER_MAPPING, AutoConfig, AutoFeatureExtractor, AutoProcessor, AutoTokenizer, BertTokenizer, ProcessorMixin, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaProcessor, ) from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils""")) from test_module.custom_configuration import CustomConfig # noqa E402 from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 from test_module.custom_processing import CustomProcessor # noqa E402 from test_module.custom_tokenization import CustomTokenizer # noqa E402 lowercase : Optional[Any] = get_tests_dir("""fixtures/dummy_feature_extractor_config.json""") lowercase : Optional[Any] = get_tests_dir("""fixtures/vocab.json""") lowercase : int = get_tests_dir("""fixtures""") class __snake_case ( unittest.TestCase ): _a : Union[str, Any]= ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: lowercase : Optional[int] = WavaVecaConfig() lowercase : Any = AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) # save in new folder model_config.save_pretrained(snake_case ) processor.save_pretrained(snake_case ) lowercase : Optional[Any] = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: # copy relevant files copyfile(snake_case ,os.path.join(snake_case ,snake_case ) ) copyfile(snake_case ,os.path.join(snake_case ,"""vocab.json""" ) ) lowercase : str = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: lowercase : Optional[int] = WavaVecaFeatureExtractor() lowercase : Optional[int] = AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) lowercase : List[str] = WavaVecaProcessor(snake_case ,snake_case ) # save in new folder processor.save_pretrained(snake_case ) # drop `processor_class` in tokenizer with open(os.path.join(snake_case ,snake_case ) ,"""r""" ) as f: lowercase : Optional[int] = json.load(snake_case ) config_dict.pop("""processor_class""" ) with open(os.path.join(snake_case ,snake_case ) ,"""w""" ) as f: f.write(json.dumps(snake_case ) ) lowercase : str = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: lowercase : List[str] = WavaVecaFeatureExtractor() lowercase : List[Any] = AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) lowercase : List[str] = WavaVecaProcessor(snake_case ,snake_case ) # save in new folder processor.save_pretrained(snake_case ) # drop `processor_class` in feature extractor with open(os.path.join(snake_case ,snake_case ) ,"""r""" ) as f: lowercase : str = json.load(snake_case ) config_dict.pop("""processor_class""" ) with open(os.path.join(snake_case ,snake_case ) ,"""w""" ) as f: f.write(json.dumps(snake_case ) ) lowercase : Tuple = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmpdirname: lowercase : Tuple = WavaVecaConfig(processor_class="""Wav2Vec2Processor""" ) model_config.save_pretrained(snake_case ) # copy relevant files copyfile(snake_case ,os.path.join(snake_case ,"""vocab.json""" ) ) # create emtpy sample processor with open(os.path.join(snake_case ,snake_case ) ,"""w""" ) as f: f.write("""{}""" ) lowercase : str = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' with self.assertRaises(snake_case ): lowercase : Optional[int] = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(snake_case ): lowercase : Tuple = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" ,trust_remote_code=snake_case ) lowercase : Dict = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ,trust_remote_code=snake_case ) self.assertTrue(processor.special_attribute_present ) self.assertEqual(processor.__class__.__name__ ,"""NewProcessor""" ) lowercase : Optional[Any] = processor.feature_extractor self.assertTrue(feature_extractor.special_attribute_present ) self.assertEqual(feature_extractor.__class__.__name__ ,"""NewFeatureExtractor""" ) lowercase : Optional[Any] = processor.tokenizer self.assertTrue(tokenizer.special_attribute_present ) if is_tokenizers_available(): self.assertEqual(tokenizer.__class__.__name__ ,"""NewTokenizerFast""" ) # Test we can also load the slow version lowercase : Optional[Any] = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" ,trust_remote_code=snake_case ,use_fast=snake_case ) lowercase : List[Any] = new_processor.tokenizer self.assertTrue(new_tokenizer.special_attribute_present ) self.assertEqual(new_tokenizer.__class__.__name__ ,"""NewTokenizer""" ) else: self.assertEqual(tokenizer.__class__.__name__ ,"""NewTokenizer""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' try: AutoConfig.register("""custom""" ,snake_case ) AutoFeatureExtractor.register(snake_case ,snake_case ) AutoTokenizer.register(snake_case ,slow_tokenizer_class=snake_case ) AutoProcessor.register(snake_case ,snake_case ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(snake_case ): AutoProcessor.register(snake_case ,snake_case ) # Now that the config is registered, it can be used as any other config with the auto-API lowercase : Tuple = CustomFeatureExtractor.from_pretrained(snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: lowercase : List[str] = os.path.join(snake_case ,"""vocab.txt""" ) with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) lowercase : int = CustomTokenizer(snake_case ) lowercase : Union[str, Any] = CustomProcessor(snake_case ,snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained(snake_case ) lowercase : str = AutoProcessor.from_pretrained(snake_case ) self.assertIsInstance(snake_case ,snake_case ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' class __snake_case ( lowerCAmelCase ): _a : List[Any]= False class __snake_case ( lowerCAmelCase ): _a : Optional[int]= False class __snake_case ( lowerCAmelCase ): _a : List[Any]= "AutoFeatureExtractor" _a : Union[str, Any]= "AutoTokenizer" _a : str= False try: AutoConfig.register("""custom""" ,snake_case ) AutoFeatureExtractor.register(snake_case ,snake_case ) AutoTokenizer.register(snake_case ,slow_tokenizer_class=snake_case ) AutoProcessor.register(snake_case ,snake_case ) # If remote code is not set, the default is to use local classes. lowercase : Optional[Any] = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) self.assertEqual(processor.__class__.__name__ ,"""NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote code is disabled, we load the local ones. lowercase : Dict = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" ,trust_remote_code=snake_case ) self.assertEqual(processor.__class__.__name__ ,"""NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote is enabled, we load from the Hub. lowercase : Union[str, Any] = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" ,trust_remote_code=snake_case ) self.assertEqual(processor.__class__.__name__ ,"""NewProcessor""" ) self.assertTrue(processor.special_attribute_present ) self.assertTrue(processor.feature_extractor.special_attribute_present ) self.assertTrue(processor.tokenizer.special_attribute_present ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-bert""" ) self.assertEqual(processor.__class__.__name__ ,"""BertTokenizerFast""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-convnext""" ) self.assertEqual(processor.__class__.__name__ ,"""ConvNextImageProcessor""" ) @is_staging_test class __snake_case ( unittest.TestCase ): _a : Dict= ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"] @classmethod def _SCREAMING_SNAKE_CASE ( cls ): '''simple docstring''' lowercase : List[Any] = TOKEN HfFolder.save_token(snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ): '''simple docstring''' try: delete_repo(token=cls._token ,repo_id="""test-processor""" ) except HTTPError: pass try: delete_repo(token=cls._token ,repo_id="""valid_org/test-processor-org""" ) except HTTPError: pass try: delete_repo(token=cls._token ,repo_id="""test-dynamic-processor""" ) except HTTPError: pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = WavaVecaProcessor.from_pretrained(snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(snake_case ,"""test-processor""" ) ,push_to_hub=snake_case ,use_auth_token=self._token ) lowercase : List[str] = WavaVecaProcessor.from_pretrained(f"{USER}/test-processor" ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(snake_case ,getattr(new_processor.feature_extractor ,snake_case ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() ,processor.tokenizer.get_vocab() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = WavaVecaProcessor.from_pretrained(snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(snake_case ,"""test-processor-org""" ) ,push_to_hub=snake_case ,use_auth_token=self._token ,organization="""valid_org""" ,) lowercase : Optional[int] = WavaVecaProcessor.from_pretrained("""valid_org/test-processor-org""" ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(snake_case ,getattr(new_processor.feature_extractor ,snake_case ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() ,processor.tokenizer.get_vocab() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' CustomFeatureExtractor.register_for_auto_class() CustomTokenizer.register_for_auto_class() CustomProcessor.register_for_auto_class() lowercase : Dict = CustomFeatureExtractor.from_pretrained(snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: lowercase : List[Any] = os.path.join(snake_case ,"""vocab.txt""" ) with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) lowercase : List[Any] = CustomTokenizer(snake_case ) lowercase : Optional[Any] = CustomProcessor(snake_case ,snake_case ) with tempfile.TemporaryDirectory() as tmp_dir: create_repo(f"{USER}/test-dynamic-processor" ,token=self._token ) lowercase : Dict = Repository(snake_case ,clone_from=f"{USER}/test-dynamic-processor" ,token=self._token ) processor.save_pretrained(snake_case ) # This has added the proper auto_map field to the feature extractor config self.assertDictEqual( processor.feature_extractor.auto_map ,{ """AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor""", """AutoProcessor""": """custom_processing.CustomProcessor""", } ,) # This has added the proper auto_map field to the tokenizer config with open(os.path.join(snake_case ,"""tokenizer_config.json""" ) ) as f: lowercase : Dict = json.load(snake_case ) self.assertDictEqual( tokenizer_config["""auto_map"""] ,{ """AutoTokenizer""": ["""custom_tokenization.CustomTokenizer""", None], """AutoProcessor""": """custom_processing.CustomProcessor""", } ,) # The code has been copied from fixtures self.assertTrue(os.path.isfile(os.path.join(snake_case ,"""custom_feature_extraction.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(snake_case ,"""custom_tokenization.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(snake_case ,"""custom_processing.py""" ) ) ) repo.push_to_hub() lowercase : Any = AutoProcessor.from_pretrained(f"{USER}/test-dynamic-processor" ,trust_remote_code=snake_case ) # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module self.assertEqual(new_processor.__class__.__name__ ,"""CustomProcessor""" )
20
from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline lowercase : Optional[Any] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,**snake_case ): '''simple docstring''' super().__init__(**snake_case ) if self.framework != "pt": raise ValueError(f"The {self.__class__} is only available in PyTorch." ) # No specific FOR_XXX available yet def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : Union[str, Any] = {} if "candidate_labels" in kwargs: lowercase : List[str] = kwargs["""candidate_labels"""] if "hypothesis_template" in kwargs: lowercase : Dict = kwargs["""hypothesis_template"""] return preprocess_params, {}, {} def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case="This is a sound of {}." ): '''simple docstring''' if isinstance(snake_case ,snake_case ): if audio.startswith("""http://""" ) or audio.startswith("""https://""" ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png lowercase : Optional[Any] = requests.get(snake_case ).content else: with open(snake_case ,"""rb""" ) as f: lowercase : Union[str, Any] = f.read() if isinstance(snake_case ,snake_case ): lowercase : int = ffmpeg_read(snake_case ,self.feature_extractor.sampling_rate ) if not isinstance(snake_case ,np.ndarray ): raise ValueError("""We expect a numpy ndarray as input""" ) if len(audio.shape ) != 1: raise ValueError("""We expect a single channel audio input for ZeroShotAudioClassificationPipeline""" ) lowercase : Dict = self.feature_extractor( [audio] ,sampling_rate=self.feature_extractor.sampling_rate ,return_tensors="""pt""" ) lowercase : Tuple = candidate_labels lowercase : Tuple = [hypothesis_template.format(snake_case ) for x in candidate_labels] lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=self.framework ,padding=snake_case ) lowercase : Optional[Any] = [text_inputs] return inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = model_inputs.pop("""candidate_labels""" ) lowercase : Dict = model_inputs.pop("""text_inputs""" ) if isinstance(text_inputs[0] ,snake_case ): lowercase : List[Any] = text_inputs[0] else: # Batching case. lowercase : Dict = text_inputs[0][0] lowercase : Optional[Any] = self.model(**snake_case ,**snake_case ) lowercase : Any = { """candidate_labels""": candidate_labels, """logits""": outputs.logits_per_audio, } return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[Any] = model_outputs.pop("""candidate_labels""" ) lowercase : Any = model_outputs["""logits"""][0] if self.framework == "pt": lowercase : Any = logits.softmax(dim=0 ) lowercase : Tuple = probs.tolist() else: raise ValueError("""`tf` framework not supported.""" ) lowercase : Tuple = [ {"""score""": score, """label""": candidate_label} for score, candidate_label in sorted(zip(snake_case ,snake_case ) ,key=lambda snake_case : -x[0] ) ] return result
20
1
import json import os from typing import Optional, Tuple import regex as re from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase : int = logging.get_logger(__name__) lowercase : Dict = { """vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", } lowercase : str = { """vocab_file""": {"""ctrl""": """https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json"""}, """merges_file""": {"""ctrl""": """https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt"""}, } lowercase : List[str] = { """ctrl""": 256, } lowercase : int = { """Pregnancy""": 168629, """Christianity""": 7675, """Explain""": 106423, """Fitness""": 63440, """Saving""": 63163, """Ask""": 27171, """Ass""": 95985, """Joke""": 163509, """Questions""": 45622, """Thoughts""": 49605, """Retail""": 52342, """Feminism""": 164338, """Writing""": 11992, """Atheism""": 192263, """Netflix""": 48616, """Computing""": 39639, """Opinion""": 43213, """Alone""": 44967, """Funny""": 58917, """Gaming""": 40358, """Human""": 4088, """India""": 1331, """Joker""": 77138, """Diet""": 36206, """Legal""": 11859, """Norman""": 4939, """Tip""": 72689, """Weight""": 52343, """Movies""": 46273, """Running""": 23425, """Science""": 2090, """Horror""": 37793, """Confession""": 60572, """Finance""": 12250, """Politics""": 16360, """Scary""": 191985, """Support""": 12654, """Technologies""": 32516, """Teenage""": 66160, """Event""": 32769, """Learned""": 67460, """Notion""": 182770, """Wikipedia""": 37583, """Books""": 6665, """Extract""": 76050, """Confessions""": 102701, """Conspiracy""": 75932, """Links""": 63674, """Narcissus""": 150425, """Relationship""": 54766, """Relationships""": 134796, """Reviews""": 41671, """News""": 4256, """Translation""": 26820, """multilingual""": 128406, } def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: lowercase : List[Any] = set() lowercase : List[Any] = word[0] for char in word[1:]: pairs.add((prev_char, char) ) lowercase : List[str] = char lowercase : Dict = set(SCREAMING_SNAKE_CASE__ ) return pairs class __snake_case ( lowerCAmelCase ): _a : int= VOCAB_FILES_NAMES _a : int= PRETRAINED_VOCAB_FILES_MAP _a : List[str]= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _a : int= CONTROL_CODES def __init__( self ,snake_case ,snake_case ,snake_case="<unk>" ,**snake_case ): '''simple docstring''' super().__init__(unk_token=snake_case ,**snake_case ) with open(snake_case ,encoding="""utf-8""" ) as vocab_handle: lowercase : Union[str, Any] = json.load(snake_case ) lowercase : Optional[int] = {v: k for k, v in self.encoder.items()} with open(snake_case ,encoding="""utf-8""" ) as merges_handle: lowercase : int = merges_handle.read().split("""\n""" )[1:-1] lowercase : Dict = [tuple(merge.split() ) for merge in merges] lowercase : Optional[Any] = dict(zip(snake_case ,range(len(snake_case ) ) ) ) lowercase : Union[str, Any] = {} @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return len(self.encoder ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return dict(self.encoder ,**self.added_tokens_encoder ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if token in self.cache: return self.cache[token] lowercase : Union[str, Any] = tuple(snake_case ) lowercase : Tuple = tuple(list(word[:-1] ) + [word[-1] + """</w>"""] ) lowercase : Tuple = get_pairs(snake_case ) if not pairs: return token while True: lowercase : Tuple = min(snake_case ,key=lambda snake_case : self.bpe_ranks.get(snake_case ,float("""inf""" ) ) ) if bigram not in self.bpe_ranks: break lowercase , lowercase : List[str] = bigram lowercase : int = [] lowercase : str = 0 while i < len(snake_case ): try: lowercase : str = word.index(snake_case ,snake_case ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) lowercase : int = j if word[i] == first and i < len(snake_case ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 lowercase : str = tuple(snake_case ) lowercase : List[Any] = new_word if len(snake_case ) == 1: break else: lowercase : Any = get_pairs(snake_case ) lowercase : int = """@@ """.join(snake_case ) lowercase : List[Any] = word[:-4] lowercase : Optional[int] = word return word def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = [] lowercase : str = re.findall(r"""\S+\n?""" ,snake_case ) for token in words: split_tokens.extend(list(self.bpe(snake_case ).split(""" """ ) ) ) return split_tokens def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.encoder.get(snake_case ,self.encoder.get(self.unk_token ) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' return self.decoder.get(snake_case ,self.unk_token ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : List[str] = """ """.join(snake_case ).replace("""@@ """ ,"""""" ).strip() return out_string def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ): '''simple docstring''' if not os.path.isdir(snake_case ): logger.error(f"Vocabulary path ({save_directory}) should be a directory" ) return lowercase : Dict = os.path.join( snake_case ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) lowercase : int = os.path.join( snake_case ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""] ) with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as f: f.write(json.dumps(self.encoder ,indent=2 ,sort_keys=snake_case ,ensure_ascii=snake_case ) + """\n""" ) lowercase : Union[str, Any] = 0 with open(snake_case ,"""w""" ,encoding="""utf-8""" ) as writer: writer.write("""#version: 0.2\n""" ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,key=lambda snake_case : kv[1] ): if index != token_index: logger.warning( f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive." """ Please check that the tokenizer is not corrupted!""" ) lowercase : List[Any] = token_index writer.write(""" """.join(snake_case ) + """\n""" ) index += 1 return vocab_file, merge_file # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True): # filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens)) # tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens) # tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far) # return ''.join(tokens_generated_so_far)
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def _snake_case( *SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=2 ) -> Optional[Any]: from .. import __version__ lowercase : int = take_from lowercase : Tuple = () if not isinstance(args[0] , SCREAMING_SNAKE_CASE__ ): lowercase : Dict = (args,) for attribute, version_name, message in args: if version.parse(version.parse(SCREAMING_SNAKE_CASE__ ).base_version ) >= version.parse(SCREAMING_SNAKE_CASE__ ): raise ValueError( f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'" f" version {__version__} is >= {version_name}" ) lowercase : int = None if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(SCREAMING_SNAKE_CASE__ ),) lowercase : Union[str, Any] = f"The `{attribute}` argument is deprecated and will be removed in version {version_name}." elif hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): values += (getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ),) lowercase : int = f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}." elif deprecated_kwargs is None: lowercase : Dict = f"`{attribute}` is deprecated and will be removed in version {version_name}." if warning is not None: lowercase : Dict = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , SCREAMING_SNAKE_CASE__ , stacklevel=SCREAMING_SNAKE_CASE__ ) if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and len(SCREAMING_SNAKE_CASE__ ) > 0: lowercase : str = inspect.getouterframes(inspect.currentframe() )[1] lowercase : List[str] = call_frame.filename lowercase : Tuple = call_frame.lineno lowercase : List[str] = call_frame.function lowercase , lowercase : Optional[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`" ) if len(SCREAMING_SNAKE_CASE__ ) == 0: return elif len(SCREAMING_SNAKE_CASE__ ) == 1: return values[0] return values
20
1
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase : List[Any] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : List[str] = {} lowercase : Optional[Any] = {} if prompt is not None: lowercase : Any = prompt if generate_kwargs is not None: lowercase : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: lowercase : Tuple = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) lowercase : Optional[int] = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Dict = load_image(snake_case ) if prompt is not None: if not isinstance(snake_case ,snake_case ): raise ValueError( f"Received an invalid text input, got - {type(snake_case )} - but expected a single string. " """Note also that one single text can be provided for conditional image to text generation.""" ) lowercase : Any = self.model.config.model_type if model_type == "git": lowercase : Optional[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) lowercase : Optional[Any] = self.tokenizer(text=snake_case ,add_special_tokens=snake_case ).input_ids lowercase : str = [self.tokenizer.cls_token_id] + input_ids lowercase : List[str] = torch.tensor(snake_case ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": lowercase : Union[str, Any] = self.image_processor(images=snake_case ,header_text=snake_case ,return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation lowercase : Tuple = self.image_processor(images=snake_case ,return_tensors=self.framework ) lowercase : int = self.tokenizer(snake_case ,return_tensors=self.framework ) model_inputs.update(snake_case ) else: raise ValueError(f"Model type {model_type} does not support conditional text generation" ) else: lowercase : Union[str, Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: lowercase : str = None return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] ,snake_case ) and all(x is None for x in model_inputs["""input_ids"""] ) ): lowercase : Optional[Any] = None if generate_kwargs is None: lowercase : int = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. lowercase : Union[str, Any] = model_inputs.pop(self.model.main_input_name ) lowercase : Tuple = self.model.generate(snake_case ,**snake_case ,**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Dict = [] for output_ids in model_outputs: lowercase : Optional[int] = { """generated_text""": self.tokenizer.decode( snake_case ,skip_special_tokens=snake_case ,) } records.append(snake_case ) return records
20
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: if index == r: for j in range(SCREAMING_SNAKE_CASE__ ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location lowercase : Tuple = arr[i] combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , index + 1 , SCREAMING_SNAKE_CASE__ , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # A temporary array to store all combination one by one lowercase : Optional[int] = [0] * r # Print all combination using temporary array 'data[]' combination_util(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , 0 , SCREAMING_SNAKE_CASE__ , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase : int = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
1
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : Optional[Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): lowercase : Any = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ , keep_in_memory=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = tmp_path / """cache""" lowercase : int = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} lowercase : str = features.copy() if features else default_expected_features lowercase : Optional[Any] = ( Features({feature: Value(SCREAMING_SNAKE_CASE__ ) for feature, dtype in features.items()} ) if features is not None else None ) lowercase : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=SCREAMING_SNAKE_CASE__ , cache_dir=SCREAMING_SNAKE_CASE__ ).read() _check_sql_dataset(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: with contextlib.closing(sqlitea.connect(SCREAMING_SNAKE_CASE__ ) ) as con: lowercase : Optional[int] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : Any = tmp_path / """cache""" lowercase : int = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() lowercase : List[str] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: lowercase : Dict = tmp_path / """cache""" lowercase : List[str] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : List[str] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() lowercase : Optional[int] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = iter_sql_file(SCREAMING_SNAKE_CASE__ ) for rowa, rowa in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): assert rowa == rowa @require_sqlalchemy def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : str = tmp_path / """cache""" lowercase : Optional[int] = os.path.join(SCREAMING_SNAKE_CASE__ , """tmp.sql""" ) lowercase : Optional[Any] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=SCREAMING_SNAKE_CASE__ ).read() with pytest.raises(SCREAMING_SNAKE_CASE__ ): SqlDatasetWriter(SCREAMING_SNAKE_CASE__ , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
1
from ..utils import DummyObject, requires_backends class __snake_case ( metaclass=lowerCAmelCase ): _a : Any= ["flax", "transformers"] def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(self ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) class __snake_case ( metaclass=lowerCAmelCase ): _a : str= ["flax", "transformers"] def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(self ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) class __snake_case ( metaclass=lowerCAmelCase ): _a : List[str]= ["flax", "transformers"] def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(self ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) class __snake_case ( metaclass=lowerCAmelCase ): _a : Any= ["flax", "transformers"] def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(self ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""flax""", """transformers"""] )
20
import os import numpy import onnx def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: lowercase : int = a.name lowercase : Any = b.name lowercase : Optional[Any] = """""" lowercase : Dict = """""" lowercase : int = a == b lowercase : int = name_a lowercase : List[str] = name_b return res def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) _graph_replace_input_with(node_proto.attribute[1].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: for n in graph_proto.node: _node_replace_input_with(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Any = list(model.graph.initializer ) lowercase : Dict = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i lowercase : Union[str, Any] = inits[i].name lowercase : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : Union[str, Any] = os.path.dirname(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = os.path.basename(SCREAMING_SNAKE_CASE__ ) lowercase : str = onnx.load(os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ) lowercase : List[str] = list(model.graph.initializer ) lowercase : Tuple = set() lowercase : int = {} lowercase : Optional[Any] = [] lowercase : Dict = 0 for i in range(len(SCREAMING_SNAKE_CASE__ ) ): if i in dup_set: continue for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(SCREAMING_SNAKE_CASE__ ) dup_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : int = inits[j].data_type lowercase : Optional[int] = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 11: mem_size *= 8 else: print("""unexpected data type: """ , SCREAMING_SNAKE_CASE__ ) total_reduced_size += mem_size lowercase : Tuple = inits[i].name lowercase : int = inits[j].name if name_i in dup_map: dup_map[name_i].append(SCREAMING_SNAKE_CASE__ ) else: lowercase : List[str] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_024 / 1_024 / 1_024 , """GB""" ) lowercase : str = sorted(SCREAMING_SNAKE_CASE__ ) _remove_dup_initializers_from_model(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = """optimized_""" + model_file_name lowercase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) onnx.save(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return new_model
20
1
import argparse import fairseq import torch from torch import nn from transformers import ( MBartaaTokenizer, MBartConfig, MBartForCausalLM, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaModel, logging, ) logging.set_verbosity_info() lowercase : List[Any] = logging.get_logger(__name__) lowercase : str = { """post_extract_proj""": """feature_projection.projection""", """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""", """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""", """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""", """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""", """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""", """self_attn_layer_norm""": """encoder.layers.*.layer_norm""", """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""", """fc2""": """encoder.layers.*.feed_forward.output_dense""", """final_layer_norm""": """encoder.layers.*.final_layer_norm""", """encoder.layer_norm""": """encoder.layer_norm""", """w2v_model.layer_norm""": """feature_projection.layer_norm""", """quantizer.weight_proj""": """quantizer.weight_proj""", """quantizer.vars""": """quantizer.codevectors""", """project_q""": """project_q""", """final_proj""": """project_hid""", """w2v_encoder.proj""": """lm_head""", """mask_emb""": """masked_spec_embed""", } lowercase : List[Any] = [ """lm_head""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", ] def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: for attribute in key.split(""".""" ): lowercase : Tuple = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if weight_type is not None: lowercase : Any = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ).shape else: lowercase : Dict = hf_pointer.shape assert hf_shape == value.shape, ( f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be" f" {value.shape} for {full_name}" ) if weight_type == "weight": lowercase : int = value elif weight_type == "weight_g": lowercase : Optional[int] = value elif weight_type == "weight_v": lowercase : Optional[int] = value elif weight_type == "bias": lowercase : List[Any] = value else: lowercase : Tuple = value logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}." ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : int = [] lowercase : str = fairseq_model.state_dict() lowercase : List[Any] = hf_model.feature_extractor lowercase : int = hf_model.adapter for name, value in fairseq_dict.items(): lowercase : Tuple = False if "conv_layers" in name: load_conv_layer( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , hf_model.config.feat_extract_norm == """group""" , ) lowercase : List[str] = True elif any(x in name for x in ["""adaptor""", """w2v_encoder.proj.""", """w2v_proj_ln."""] ): load_adapter(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split("""w2v_model.""" )[-1] == name.split(""".""" )[0]: lowercase : str = True if "*" in mapped_key: lowercase : Optional[Any] = name.split(SCREAMING_SNAKE_CASE__ )[0].split(""".""" )[-2] lowercase : Optional[int] = mapped_key.replace("""*""" , SCREAMING_SNAKE_CASE__ ) if "weight_g" in name: lowercase : str = """weight_g""" elif "weight_v" in name: lowercase : str = """weight_v""" elif "bias" in name: lowercase : int = """bias""" elif "weight" in name: lowercase : Dict = """weight""" else: lowercase : Optional[int] = None set_recursively(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) continue if not is_used: unused_weights.append(SCREAMING_SNAKE_CASE__ ) logger.warning(f"Unused weights: {unused_weights}" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Any: lowercase : str = full_name.split("""conv_layers.""" )[-1] lowercase : str = name.split(""".""" ) lowercase : str = int(items[0] ) lowercase : List[Any] = int(items[1] ) if type_id == 0: if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, ( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found." ) lowercase : Any = value logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}." ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( f"{full_name} has size {value.shape}, but" f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found." ) lowercase : Union[str, Any] = value logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}." ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was" " found." ) lowercase : List[Any] = value logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( f"{full_name} has size {value.shape}, but" f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found." ) lowercase : Any = value logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) else: unused_weights.append(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = full_name.split("""adaptor.""" )[-1] lowercase : int = name.split(""".""" ) if items[1].isdigit(): lowercase : int = int(items[1] ) else: lowercase : Optional[Any] = None if "adaptor" not in full_name: if "proj_ln" in full_name: # has to be layer norm if "bias" in name: assert ( value.shape == adapter.proj_layer_norm.bias.data.shape ), f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found." lowercase : Tuple = value logger.info(f"Adapter proj layer norm bias was initialized from {full_name}." ) if "weight" in name: assert ( value.shape == adapter.proj_layer_norm.weight.data.shape ), f"{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found." lowercase : Tuple = value else: # has to be projection layer if "bias" in name: assert ( value.shape == adapter.proj.bias.data.shape ), f"{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found." lowercase : Union[str, Any] = value logger.info(f"Adapter proj layer bias was initialized from {full_name}." ) if "weight" in name: assert ( value.shape == adapter.proj.weight.data.shape ), f"{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found." lowercase : Optional[int] = value logger.info(f"Adapter proj layer weight was initialized from {full_name}." ) elif isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): if "bias" in name: assert ( value.shape == adapter.layers[layer_id].conv.bias.data.shape ), f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found." lowercase : int = value logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}." ) elif "weight" in name: assert ( value.shape == adapter.layers[layer_id].conv.weight.data.shape ), f"{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found." lowercase : str = value logger.info(f"Adapter layer {layer_id} bias was initialized from {full_name}." ) else: unused_weights.append(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: lowercase , lowercase : Any = emb.weight.shape lowercase : Dict = nn.Linear(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , bias=SCREAMING_SNAKE_CASE__ ) lowercase : Any = emb.weight.data return lin_layer @torch.no_grad() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Union[str, Any]: lowercase : Union[str, Any] = WavaVecaConfig.from_pretrained( SCREAMING_SNAKE_CASE__ , add_adapter=SCREAMING_SNAKE_CASE__ , adapter_stride=SCREAMING_SNAKE_CASE__ , adapter_kernel_size=SCREAMING_SNAKE_CASE__ , use_auth_token=SCREAMING_SNAKE_CASE__ , output_hidden_size=SCREAMING_SNAKE_CASE__ , ) lowercase : str = MBartConfig.from_pretrained(SCREAMING_SNAKE_CASE__ ) # load model lowercase , lowercase , lowercase : Optional[int] = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={ """config_yaml""": config_yaml_path, """data""": """/""".join(dict_path.split("""/""" )[:-1] ), """w2v_path""": checkpoint_path, """load_pretrained_decoder_from""": None, } , ) lowercase : str = model[0].eval() # load feature extractor lowercase : str = WavaVecaFeatureExtractor.from_pretrained(SCREAMING_SNAKE_CASE__ , use_auth_token=SCREAMING_SNAKE_CASE__ ) # set weights for wav2vec2 encoder lowercase : Any = WavaVecaModel(SCREAMING_SNAKE_CASE__ ) recursively_load_weights_wavaveca(model.encoder , SCREAMING_SNAKE_CASE__ ) # load decoder weights lowercase : List[Any] = MBartForCausalLM(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : List[str] = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() , strict=SCREAMING_SNAKE_CASE__ ) logger.warning(f"The following keys are missing when loading the decoder weights: {missing_keys}" ) logger.warning(f"The following keys are unexpected when loading the decoder weights: {unexpected_keys}" ) lowercase : Tuple = SpeechEncoderDecoderModel(encoder=SCREAMING_SNAKE_CASE__ , decoder=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = False lowercase : List[Any] = MBartaaTokenizer(SCREAMING_SNAKE_CASE__ ) tokenizer.save_pretrained(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = hf_wavavec.config.to_dict() lowercase : Any = tokenizer.pad_token_id lowercase : Dict = tokenizer.bos_token_id lowercase : List[str] = tokenizer.eos_token_id lowercase : List[str] = """mbart50""" lowercase : Tuple = """wav2vec2""" lowercase : int = tokenizer.eos_token_id lowercase : Optional[Any] = 250_004 lowercase : Optional[int] = tokenizer.eos_token_id lowercase : Any = SpeechEncoderDecoderConfig.from_dict(SCREAMING_SNAKE_CASE__ ) hf_wavavec.save_pretrained(SCREAMING_SNAKE_CASE__ ) feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Any = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_yaml_path""", default=None, type=str, help="""Path to yaml file of fine-tuned model""") parser.add_argument( """--encoder_config_path""", default="""facebook/wav2vec2-xls-r-1b""", type=str, help="""Path to hf encoder wav2vec2 checkpoint config""", ) parser.add_argument( """--decoder_config_path""", default="""facebook/mbart-large-50-one-to-many-mmt""", type=str, help="""Path to hf decoder checkpoint config""", ) parser.add_argument("""--add_adapter""", default=True, type=bool, help="""whethere to add model adapter layers""") parser.add_argument("""--adapter_stride""", default=2, type=int, help="""stride of adapter layers""") parser.add_argument("""--adapter_kernel_size""", default=3, type=int, help="""kernel size of adapter layers""") parser.add_argument("""--encoder_output_dim""", default=1024, type=int, help="""encoder output dim""") parser.add_argument("""--start_token_id""", default=250004, type=int, help="""`decoder_start_token_id` of model config""") lowercase : Union[str, Any] = parser.parse_args() convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.dict_path, args.config_yaml_path, encoder_config_path=args.encoder_config_path, decoder_config_path=args.decoder_config_path, add_adapter=args.add_adapter, adapter_kernel_size=args.adapter_kernel_size, adapter_stride=args.adapter_stride, decoder_start_token_id=args.start_token_id, encoder_output_dim=args.encoder_output_dim, )
20
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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = [] embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight", f"stage{idx}.patch_embed.proj.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias", f"stage{idx}.patch_embed.proj.bias", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight", f"stage{idx}.patch_embed.norm.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias", f"stage{idx}.patch_embed.norm.bias", ) ) return embed def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Optional[Any] = [] 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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Optional[Any] = [] token.append((f"cvt.encoder.stages.{idx}.cls_token", """stage2.cls_token""") ) return token def _snake_case( ) -> Dict: lowercase : Optional[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 _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = """imagenet-1k-id2label.json""" lowercase : List[str] = 1_000 lowercase : int = """huggingface/label-files""" lowercase : Union[str, Any] = num_labels lowercase : Optional[Any] = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) ) , """r""" ) ) lowercase : List[Any] = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Dict = idalabel lowercase : List[str] = {v: k for k, v in idalabel.items()} lowercase : List[str] = CvtConfig(num_labels=SCREAMING_SNAKE_CASE__ , idalabel=SCREAMING_SNAKE_CASE__ , labelaid=SCREAMING_SNAKE_CASE__ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": lowercase : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": lowercase : Dict = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: lowercase : int = [2, 2, 20] lowercase : Optional[int] = [3, 12, 16] lowercase : str = [192, 768, 1_024] lowercase : Union[str, Any] = CvtForImageClassification(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) lowercase : Optional[Any] = image_size lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ , map_location=torch.device("""cpu""" ) ) lowercase : Optional[Any] = OrderedDict() lowercase : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: lowercase : Optional[Any] = list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__ ) lowercase : str = list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__ ) for cnt in range(config.depth[idx] ): lowercase : List[str] = list_of_state_dict + attention(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = list_of_state_dict + final() for gg in list_of_state_dict: print(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=384, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : Optional[int] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
1
import json import os import shutil import tempfile import unittest from multiprocessing import get_context from pathlib import Path import datasets import numpy as np from datasets import load_dataset from parameterized import parameterized from transformers import AutoProcessor from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available from ..wavaveca.test_feature_extraction_wavaveca import floats_list if is_pyctcdecode_available(): from huggingface_hub import snapshot_download from pyctcdecode import BeamSearchDecoderCTC from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput if is_torch_available(): from transformers import WavaVecaForCTC @require_pyctcdecode class __snake_case ( unittest.TestCase ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() lowercase : Tuple = dict(zip(snake_case ,range(len(snake_case ) ) ) ) lowercase : int = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } lowercase : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 16000, """return_attention_mask""": False, """do_normalize""": True, } lowercase : Optional[Any] = tempfile.mkdtemp() lowercase : Optional[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["""vocab_file"""] ) lowercase : Optional[Any] = os.path.join(self.tmpdirname ,snake_case ) with open(self.vocab_file ,"""w""" ,encoding="""utf-8""" ) as fp: fp.write(json.dumps(snake_case ) + """\n""" ) with open(self.feature_extraction_file ,"""w""" ,encoding="""utf-8""" ) as fp: fp.write(json.dumps(snake_case ) + """\n""" ) # load decoder from hub lowercase : Tuple = """hf-internal-testing/ngram-beam-search-decoder""" def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' lowercase : List[str] = self.add_kwargs_tokens_map.copy() kwargs.update(snake_case ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,**snake_case ): '''simple docstring''' return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' shutil.rmtree(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.get_tokenizer() lowercase : Tuple = self.get_feature_extractor() lowercase : Optional[Any] = self.get_decoder() lowercase : Any = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) processor.save_pretrained(self.tmpdirname ) lowercase : List[str] = WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname ) # tokenizer self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer ,snake_case ) # feature extractor self.assertEqual(processor.feature_extractor.to_json_string() ,feature_extractor.to_json_string() ) self.assertIsInstance(processor.feature_extractor ,snake_case ) # decoder self.assertEqual(processor.decoder._alphabet.labels ,decoder._alphabet.labels ) self.assertEqual( processor.decoder.model_container[decoder._model_key]._unigram_set ,decoder.model_container[decoder._model_key]._unigram_set ,) self.assertIsInstance(processor.decoder ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = WavaVecaProcessorWithLM( tokenizer=self.get_tokenizer() ,feature_extractor=self.get_feature_extractor() ,decoder=self.get_decoder() ) processor.save_pretrained(self.tmpdirname ) # make sure that error is thrown when decoder alphabet doesn't match lowercase : Any = WavaVecaProcessorWithLM.from_pretrained( self.tmpdirname ,alpha=5.0 ,beta=3.0 ,score_boundary=-7.0 ,unk_score_offset=3 ) # decoder self.assertEqual(processor.language_model.alpha ,5.0 ) self.assertEqual(processor.language_model.beta ,3.0 ) self.assertEqual(processor.language_model.score_boundary ,-7.0 ) self.assertEqual(processor.language_model.unk_score_offset ,3 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.get_tokenizer() # add token to trigger raise tokenizer.add_tokens(["""xx"""] ) with self.assertRaisesRegex(snake_case ,"""include""" ): WavaVecaProcessorWithLM( tokenizer=snake_case ,feature_extractor=self.get_feature_extractor() ,decoder=self.get_decoder() ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_feature_extractor() lowercase : Union[str, Any] = self.get_tokenizer() lowercase : Optional[int] = self.get_decoder() lowercase : str = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : Union[str, Any] = floats_list((3, 1000) ) lowercase : List[str] = feature_extractor(snake_case ,return_tensors="""np""" ) lowercase : Optional[int] = processor(snake_case ,return_tensors="""np""" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_feature_extractor() lowercase : List[str] = self.get_tokenizer() lowercase : str = self.get_decoder() lowercase : Union[str, Any] = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : str = """This is a test string""" lowercase : Tuple = processor(text=snake_case ) lowercase : Union[str, Any] = tokenizer(snake_case ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] ,encoded_processor[key] ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=(2, 10, 16) ,snake_case=77 ): '''simple docstring''' np.random.seed(snake_case ) return np.random.rand(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_feature_extractor() lowercase : Any = self.get_tokenizer() lowercase : Union[str, Any] = self.get_decoder() lowercase : Optional[int] = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : int = self._get_dummy_logits(shape=(10, 16) ,seed=13 ) lowercase : Optional[int] = processor.decode(snake_case ) lowercase : Tuple = decoder.decode_beams(snake_case )[0] self.assertEqual(decoded_decoder[0] ,decoded_processor.text ) self.assertEqual("""</s> <s> </s>""" ,decoded_processor.text ) self.assertEqual(decoded_decoder[-2] ,decoded_processor.logit_score ) self.assertEqual(decoded_decoder[-1] ,decoded_processor.lm_score ) @parameterized.expand([[None], ["""fork"""], ["""spawn"""]] ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : str = self.get_feature_extractor() lowercase : Tuple = self.get_tokenizer() lowercase : Dict = self.get_decoder() lowercase : Tuple = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : Optional[int] = self._get_dummy_logits() # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM. # otherwise, the LM won't be available to the pool's sub-processes. # manual logic used to allow parameterized test for both pool=None and pool=Pool(...) if pool_context is None: lowercase : Any = processor.batch_decode(snake_case ) else: with get_context(snake_case ).Pool() as pool: lowercase : Optional[Any] = processor.batch_decode(snake_case ,snake_case ) lowercase : Dict = list(snake_case ) with get_context("""fork""" ).Pool() as p: lowercase : List[str] = decoder.decode_beams_batch(snake_case ,snake_case ) lowercase , lowercase , lowercase : List[str] = [], [], [] for beams in decoded_beams: texts_decoder.append(beams[0][0] ) logit_scores_decoder.append(beams[0][-2] ) lm_scores_decoder.append(beams[0][-1] ) self.assertListEqual(snake_case ,decoded_processor.text ) self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""] ,decoded_processor.text ) self.assertListEqual(snake_case ,decoded_processor.logit_score ) self.assertListEqual(snake_case ,decoded_processor.lm_score ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.get_feature_extractor() lowercase : int = self.get_tokenizer() lowercase : Dict = self.get_decoder() lowercase : int = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : int = self._get_dummy_logits() lowercase : Any = 15 lowercase : Union[str, Any] = -20.0 lowercase : Any = -4.0 lowercase : Dict = processor.batch_decode( snake_case ,beam_width=snake_case ,beam_prune_logp=snake_case ,token_min_logp=snake_case ,) lowercase : Optional[int] = decoded_processor_out.text lowercase : Tuple = list(snake_case ) with get_context("""fork""" ).Pool() as pool: lowercase : int = decoder.decode_beams_batch( snake_case ,snake_case ,beam_width=snake_case ,beam_prune_logp=snake_case ,token_min_logp=snake_case ,) lowercase : Any = [d[0][0] for d in decoded_decoder_out] lowercase : Tuple = [d[0][2] for d in decoded_decoder_out] lowercase : List[Any] = [d[0][3] for d in decoded_decoder_out] self.assertListEqual(snake_case ,snake_case ) self.assertListEqual(["""</s> <s> <s>""", """<s> <s> <s>"""] ,snake_case ) self.assertTrue(np.array_equal(snake_case ,decoded_processor_out.logit_score ) ) self.assertTrue(np.allclose([-20.054, -18.447] ,snake_case ,atol=1e-3 ) ) self.assertTrue(np.array_equal(snake_case ,decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9_474] ,snake_case ,atol=1e-3 ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.get_feature_extractor() lowercase : Union[str, Any] = self.get_tokenizer() lowercase : Union[str, Any] = self.get_decoder() lowercase : Optional[int] = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) lowercase : Optional[int] = self._get_dummy_logits() lowercase : List[str] = 2.0 lowercase : Any = 5.0 lowercase : Tuple = -20.0 lowercase : List[Any] = True lowercase : Union[str, Any] = processor.batch_decode( snake_case ,alpha=snake_case ,beta=snake_case ,unk_score_offset=snake_case ,lm_score_boundary=snake_case ,) lowercase : Union[str, Any] = decoded_processor_out.text lowercase : List[Any] = list(snake_case ) decoder.reset_params( alpha=snake_case ,beta=snake_case ,unk_score_offset=snake_case ,lm_score_boundary=snake_case ,) with get_context("""fork""" ).Pool() as pool: lowercase : str = decoder.decode_beams_batch( snake_case ,snake_case ,) lowercase : Any = [d[0][0] for d in decoded_decoder_out] self.assertListEqual(snake_case ,snake_case ) self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""] ,snake_case ) lowercase : str = processor.decoder.model_container[processor.decoder._model_key] self.assertEqual(lm_model.alpha ,2.0 ) self.assertEqual(lm_model.beta ,5.0 ) self.assertEqual(lm_model.unk_score_offset ,-20.0 ) self.assertEqual(lm_model.score_boundary ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) lowercase : Optional[int] = processor.decoder.model_container[processor.decoder._model_key] lowercase : Dict = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() lowercase : List[str] = os.listdir(snake_case ) lowercase : Dict = ["""alphabet.json""", """language_model"""] downloaded_decoder_files.sort() expected_decoder_files.sort() # test that only decoder relevant files from # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main # are downloaded and none of the rest (e.g. README.md, ...) self.assertListEqual(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = snapshot_download("""hf-internal-testing/processor_with_lm""" ) lowercase : Optional[int] = WavaVecaProcessorWithLM.from_pretrained(snake_case ) lowercase : List[str] = processor.decoder.model_container[processor.decoder._model_key] lowercase : Dict = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() lowercase : List[str] = os.listdir(snake_case ) lowercase : Dict = os.listdir(snake_case ) local_decoder_files.sort() expected_decoder_files.sort() # test that both decoder form hub and local files in cache are the same self.assertListEqual(snake_case ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) lowercase : int = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) lowercase : Union[str, Any] = floats_list((3, 1000) ) lowercase : Optional[int] = processor_wavaveca(snake_case ,return_tensors="""np""" ) lowercase : Dict = processor_auto(snake_case ,return_tensors="""np""" ) for key in input_wavaveca.keys(): self.assertAlmostEqual(input_wavaveca[key].sum() ,input_auto[key].sum() ,delta=1e-2 ) lowercase : str = self._get_dummy_logits() lowercase : Optional[int] = processor_wavaveca.batch_decode(snake_case ) lowercase : Any = processor_auto.batch_decode(snake_case ) self.assertListEqual(decoded_wavaveca.text ,decoded_auto.text ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.get_feature_extractor() lowercase : str = self.get_tokenizer() lowercase : int = self.get_decoder() lowercase : List[str] = WavaVecaProcessorWithLM(tokenizer=snake_case ,feature_extractor=snake_case ,decoder=snake_case ) self.assertListEqual( processor.model_input_names ,feature_extractor.model_input_names ,msg="""`processor` and `feature_extractor` model input names do not match""" ,) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[Any] = [d[key] for d in offsets] return retrieved_list def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) lowercase : int = self._get_dummy_logits()[0] lowercase : Optional[int] = processor.decode(snake_case ,output_word_offsets=snake_case ) # check Wav2Vec2CTCTokenizerOutput keys for word self.assertEqual(len(outputs.keys() ) ,4 ) self.assertTrue("""text""" in outputs ) self.assertTrue("""word_offsets""" in outputs ) self.assertTrue(isinstance(snake_case ,snake_case ) ) self.assertEqual(""" """.join(self.get_from_offsets(outputs["""word_offsets"""] ,"""word""" ) ) ,outputs.text ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""] ,"""word""" ) ,["""<s>""", """<s>""", """</s>"""] ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""] ,"""start_offset""" ) ,[0, 2, 4] ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""] ,"""end_offset""" ) ,[1, 3, 5] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) lowercase : int = self._get_dummy_logits() lowercase : Tuple = processor.batch_decode(snake_case ,output_word_offsets=snake_case ) # check Wav2Vec2CTCTokenizerOutput keys for word self.assertEqual(len(outputs.keys() ) ,4 ) self.assertTrue("""text""" in outputs ) self.assertTrue("""word_offsets""" in outputs ) self.assertTrue(isinstance(snake_case ,snake_case ) ) self.assertListEqual( [""" """.join(self.get_from_offsets(snake_case ,"""word""" ) ) for o in outputs["""word_offsets"""]] ,outputs.text ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0] ,"""word""" ) ,["""<s>""", """<s>""", """</s>"""] ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0] ,"""start_offset""" ) ,[0, 2, 4] ) self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0] ,"""end_offset""" ) ,[1, 3, 5] ) @slow @require_torch @require_torchaudio def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' import torch lowercase : Any = load_dataset("""common_voice""" ,"""en""" ,split="""train""" ,streaming=snake_case ) lowercase : List[Any] = ds.cast_column("""audio""" ,datasets.Audio(sampling_rate=16000 ) ) lowercase : List[Any] = iter(snake_case ) lowercase : Optional[int] = next(snake_case ) lowercase : List[str] = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) lowercase : str = WavaVecaForCTC.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train lowercase : int = processor(sample["""audio"""]["""array"""] ,return_tensors="""pt""" ).input_values with torch.no_grad(): lowercase : Dict = model(snake_case ).logits.cpu().numpy() lowercase : Dict = processor.decode(logits[0] ,output_word_offsets=snake_case ) lowercase : str = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate lowercase : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] lowercase : Tuple = """WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL""" # output words self.assertEqual(""" """.join(self.get_from_offsets(snake_case ,"""word""" ) ) ,snake_case ) self.assertEqual(""" """.join(self.get_from_offsets(snake_case ,"""word""" ) ) ,output.text ) # output times lowercase : Tuple = torch.tensor(self.get_from_offsets(snake_case ,"""start_time""" ) ) lowercase : Union[str, Any] = torch.tensor(self.get_from_offsets(snake_case ,"""end_time""" ) ) # fmt: off lowercase : int = torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599] ) lowercase : List[str] = torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(snake_case ,snake_case ,atol=0.01 ) ) self.assertTrue(torch.allclose(snake_case ,snake_case ,atol=0.01 ) )
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "microsoft/speecht5_tts" _a : Tuple= ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) _a : Dict= "text_reader" _a : Optional[Any]= SpeechTaProcessor _a : Tuple= SpeechTaForTextToSpeech _a : Optional[int]= SpeechTaHifiGan _a : Union[str, Any]= ["text"] _a : Optional[int]= ["audio"] def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.post_processor is None: lowercase : Any = """microsoft/speecht5_hifigan""" super().setup() def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : int = self.pre_processor(text=snake_case ,return_tensors="""pt""" ,truncation=snake_case ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) lowercase : Tuple = load_dataset("""Matthijs/cmu-arctic-xvectors""" ,split="""validation""" ) lowercase : List[str] = torch.tensor(embeddings_dataset[7305]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.model.generate_speech(**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' with torch.no_grad(): return self.post_processor(snake_case ).cpu().detach()
20
1
from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase : List[Any] = logging.get_logger(__name__) lowercase : int = { """facebook/deit-base-distilled-patch16-224""": ( """https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json""" ), # See all DeiT models at https://huggingface.co/models?filter=deit } class __snake_case ( lowerCAmelCase ): _a : List[Any]= "deit" def __init__( self ,snake_case=768 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=224 ,snake_case=16 ,snake_case=3 ,snake_case=True ,snake_case=16 ,**snake_case ,): '''simple docstring''' super().__init__(**snake_case ) lowercase : List[Any] = hidden_size lowercase : Optional[Any] = num_hidden_layers lowercase : Optional[int] = num_attention_heads lowercase : Union[str, Any] = intermediate_size lowercase : int = hidden_act lowercase : Any = hidden_dropout_prob lowercase : List[str] = attention_probs_dropout_prob lowercase : List[str] = initializer_range lowercase : List[Any] = layer_norm_eps lowercase : Union[str, Any] = image_size lowercase : Any = patch_size lowercase : Union[str, Any] = num_channels lowercase : List[Any] = qkv_bias lowercase : Optional[int] = encoder_stride class __snake_case ( lowerCAmelCase ): _a : List[Any]= version.parse("1.11" ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ] ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 1e-4
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : str = { """configuration_funnel""": ["""FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FunnelConfig"""], """convert_funnel_original_tf_checkpoint_to_pytorch""": [], """tokenization_funnel""": ["""FunnelTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Tuple = ["""FunnelTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : List[str] = [ """FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """FunnelBaseModel""", """FunnelForMaskedLM""", """FunnelForMultipleChoice""", """FunnelForPreTraining""", """FunnelForQuestionAnswering""", """FunnelForSequenceClassification""", """FunnelForTokenClassification""", """FunnelModel""", """FunnelPreTrainedModel""", """load_tf_weights_in_funnel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFFunnelBaseModel""", """TFFunnelForMaskedLM""", """TFFunnelForMultipleChoice""", """TFFunnelForPreTraining""", """TFFunnelForQuestionAnswering""", """TFFunnelForSequenceClassification""", """TFFunnelForTokenClassification""", """TFFunnelModel""", """TFFunnelPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
1
import unittest from transformers import ( MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, Pipeline, ZeroShotClassificationPipeline, pipeline, ) from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow from .test_pipelines_common import ANY # These 2 model types require different inputs than those of the usual text models. lowercase : Tuple = {"""LayoutLMv2Config""", """LayoutLMv3Config"""} @is_pipeline_test class __snake_case ( unittest.TestCase ): _a : Optional[Any]= MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING _a : Dict= TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if model_mapping is not None: _a : Union[str, Any]= {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP} if tf_model_mapping is not None: _a : Dict= { config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP } def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = ZeroShotClassificationPipeline( model=snake_case ,tokenizer=snake_case ,candidate_labels=["""polics""", """health"""] ) return classifier, ["Who are you voting for in 2020?", "My stomach hurts."] def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Tuple = classifier("""Who are you voting for in 2020?""" ,candidate_labels="""politics""" ) self.assertEqual(snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case )], """scores""": [ANY(snake_case )]} ) # No kwarg lowercase : Tuple = classifier("""Who are you voting for in 2020?""" ,["""politics"""] ) self.assertEqual(snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case )], """scores""": [ANY(snake_case )]} ) lowercase : int = classifier("""Who are you voting for in 2020?""" ,candidate_labels=["""politics"""] ) self.assertEqual(snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case )], """scores""": [ANY(snake_case )]} ) lowercase : Union[str, Any] = classifier("""Who are you voting for in 2020?""" ,candidate_labels="""politics, public health""" ) self.assertEqual( snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case ), ANY(snake_case )], """scores""": [ANY(snake_case ), ANY(snake_case )]} ) self.assertAlmostEqual(sum(nested_simplify(outputs["""scores"""] ) ) ,1.0 ) lowercase : List[str] = classifier("""Who are you voting for in 2020?""" ,candidate_labels=["""politics""", """public health"""] ) self.assertEqual( snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case ), ANY(snake_case )], """scores""": [ANY(snake_case ), ANY(snake_case )]} ) self.assertAlmostEqual(sum(nested_simplify(outputs["""scores"""] ) ) ,1.0 ) lowercase : List[str] = classifier( """Who are you voting for in 2020?""" ,candidate_labels="""politics""" ,hypothesis_template="""This text is about {}""" ) self.assertEqual(snake_case ,{"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case )], """scores""": [ANY(snake_case )]} ) # https://github.com/huggingface/transformers/issues/13846 lowercase : Optional[Any] = classifier(["""I am happy"""] ,["""positive""", """negative"""] ) self.assertEqual( snake_case ,[ {"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case ), ANY(snake_case )], """scores""": [ANY(snake_case ), ANY(snake_case )]} for i in range(1 ) ] ,) lowercase : List[str] = classifier(["""I am happy""", """I am sad"""] ,["""positive""", """negative"""] ) self.assertEqual( snake_case ,[ {"""sequence""": ANY(snake_case ), """labels""": [ANY(snake_case ), ANY(snake_case )], """scores""": [ANY(snake_case ), ANY(snake_case )]} for i in range(2 ) ] ,) with self.assertRaises(snake_case ): classifier("""""" ,candidate_labels="""politics""" ) with self.assertRaises(snake_case ): classifier(snake_case ,candidate_labels="""politics""" ) with self.assertRaises(snake_case ): classifier("""Who are you voting for in 2020?""" ,candidate_labels="""""" ) with self.assertRaises(snake_case ): classifier("""Who are you voting for in 2020?""" ,candidate_labels=snake_case ) with self.assertRaises(snake_case ): classifier( """Who are you voting for in 2020?""" ,candidate_labels="""politics""" ,hypothesis_template="""Not formatting template""" ,) with self.assertRaises(snake_case ): classifier( """Who are you voting for in 2020?""" ,candidate_labels="""politics""" ,hypothesis_template=snake_case ,) self.run_entailment_id(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = zero_shot_classifier.model.config lowercase : Union[str, Any] = config.labelaid lowercase : Dict = zero_shot_classifier.entailment_id lowercase : Dict = {"""LABEL_0""": 0, """LABEL_1""": 1, """LABEL_2""": 2} self.assertEqual(zero_shot_classifier.entailment_id ,-1 ) lowercase : Dict = {"""entailment""": 0, """neutral""": 1, """contradiction""": 2} self.assertEqual(zero_shot_classifier.entailment_id ,0 ) lowercase : Any = {"""ENTAIL""": 0, """NON-ENTAIL""": 1} self.assertEqual(zero_shot_classifier.entailment_id ,0 ) lowercase : Optional[Any] = {"""ENTAIL""": 2, """NEUTRAL""": 1, """CONTR""": 0} self.assertEqual(zero_shot_classifier.entailment_id ,2 ) lowercase : Optional[int] = original_labelaid self.assertEqual(snake_case ,zero_shot_classifier.entailment_id ) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = pipeline( """zero-shot-classification""" ,model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" ,framework="""pt""" ,) # There was a regression in 4.10 for this # Adding a test so we don't make the mistake again. # https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499 zero_shot_classifier( """Who are you voting for in 2020?""" * 100 ,candidate_labels=["""politics""", """public health""", """science"""] ) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = pipeline( """zero-shot-classification""" ,model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" ,framework="""pt""" ,) lowercase : Union[str, Any] = zero_shot_classifier( """Who are you voting for in 2020?""" ,candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": """Who are you voting for in 2020?""", """labels""": ["""science""", """public health""", """politics"""], """scores""": [0.333, 0.333, 0.333], } ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = pipeline( """zero-shot-classification""" ,model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" ,framework="""tf""" ,) lowercase : Tuple = zero_shot_classifier( """Who are you voting for in 2020?""" ,candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": """Who are you voting for in 2020?""", """labels""": ["""science""", """public health""", """politics"""], """scores""": [0.333, 0.333, 0.333], } ,) @slow @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = pipeline("""zero-shot-classification""" ,model="""roberta-large-mnli""" ,framework="""pt""" ) lowercase : List[Any] = zero_shot_classifier( """Who are you voting for in 2020?""" ,candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": """Who are you voting for in 2020?""", """labels""": ["""politics""", """public health""", """science"""], """scores""": [0.976, 0.015, 0.009], } ,) lowercase : Union[str, Any] = zero_shot_classifier( """The dominant sequence transduction models are based on complex recurrent or convolutional neural networks""" """ in an encoder-decoder configuration. The best performing models also connect the encoder and decoder""" """ through an attention mechanism. We propose a new simple network architecture, the Transformer, based""" """ solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two""" """ machine translation tasks show these models to be superior in quality while being more parallelizable""" """ and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014""" """ English-to-German translation task, improving over the existing best results, including ensembles by""" """ over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new""" """ single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small""" """ fraction of the training costs of the best models from the literature. We show that the Transformer""" """ generalizes well to other tasks by applying it successfully to English constituency parsing both with""" """ large and limited training data.""" ,candidate_labels=["""machine learning""", """statistics""", """translation""", """vision"""] ,multi_label=snake_case ,) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": ( """The dominant sequence transduction models are based on complex recurrent or convolutional neural""" """ networks in an encoder-decoder configuration. The best performing models also connect the""" """ encoder and decoder through an attention mechanism. We propose a new simple network""" """ architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence""" """ and convolutions entirely. Experiments on two machine translation tasks show these models to be""" """ superior in quality while being more parallelizable and requiring significantly less time to""" """ train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,""" """ improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014""" """ English-to-French translation task, our model establishes a new single-model state-of-the-art""" """ BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training""" """ costs of the best models from the literature. We show that the Transformer generalizes well to""" """ other tasks by applying it successfully to English constituency parsing both with large and""" """ limited training data.""" ), """labels""": ["""translation""", """machine learning""", """vision""", """statistics"""], """scores""": [0.817, 0.713, 0.018, 0.018], } ,) @slow @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = pipeline("""zero-shot-classification""" ,model="""roberta-large-mnli""" ,framework="""tf""" ) lowercase : List[Any] = zero_shot_classifier( """Who are you voting for in 2020?""" ,candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": """Who are you voting for in 2020?""", """labels""": ["""politics""", """public health""", """science"""], """scores""": [0.976, 0.015, 0.009], } ,) lowercase : Optional[int] = zero_shot_classifier( """The dominant sequence transduction models are based on complex recurrent or convolutional neural networks""" """ in an encoder-decoder configuration. The best performing models also connect the encoder and decoder""" """ through an attention mechanism. We propose a new simple network architecture, the Transformer, based""" """ solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two""" """ machine translation tasks show these models to be superior in quality while being more parallelizable""" """ and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014""" """ English-to-German translation task, improving over the existing best results, including ensembles by""" """ over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new""" """ single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small""" """ fraction of the training costs of the best models from the literature. We show that the Transformer""" """ generalizes well to other tasks by applying it successfully to English constituency parsing both with""" """ large and limited training data.""" ,candidate_labels=["""machine learning""", """statistics""", """translation""", """vision"""] ,multi_label=snake_case ,) self.assertEqual( nested_simplify(snake_case ) ,{ """sequence""": ( """The dominant sequence transduction models are based on complex recurrent or convolutional neural""" """ networks in an encoder-decoder configuration. The best performing models also connect the""" """ encoder and decoder through an attention mechanism. We propose a new simple network""" """ architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence""" """ and convolutions entirely. Experiments on two machine translation tasks show these models to be""" """ superior in quality while being more parallelizable and requiring significantly less time to""" """ train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,""" """ improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014""" """ English-to-French translation task, our model establishes a new single-model state-of-the-art""" """ BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training""" """ costs of the best models from the literature. We show that the Transformer generalizes well to""" """ other tasks by applying it successfully to English constituency parsing both with large and""" """ limited training data.""" ), """labels""": ["""translation""", """machine learning""", """vision""", """statistics"""], """scores""": [0.817, 0.713, 0.018, 0.018], } ,)
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Any: lowercase : Dict = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } lowercase , lowercase : Optional[Any] = input_paths_and_base_extractors[compression_format] if input_path is None: lowercase : Dict = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) assert base_extractor.is_extractable(SCREAMING_SNAKE_CASE__ ) lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : str = file_path.read_text(encoding="""utf-8""" ) else: lowercase : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) lowercase : Tuple = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) -> Dict: lowercase : str = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } lowercase : Optional[Any] = input_paths[compression_format] if input_path is None: lowercase : int = f"for '{compression_format}' compression_format, " if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = Extractor.infer_extractor_format(SCREAMING_SNAKE_CASE__ ) assert extractor_format is not None lowercase : Any = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name lowercase : Dict = file_path.read_text(encoding="""utf-8""" ) else: lowercase : int = output_path.read_text(encoding="""utf-8""" ) lowercase : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: import tarfile lowercase : Tuple = tmp_path / """data_dot_dot""" directory.mkdir() lowercase : str = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(SCREAMING_SNAKE_CASE__ , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[str]: import tarfile lowercase : Tuple = tmp_path / """data_sym_link""" directory.mkdir() lowercase : int = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=SCREAMING_SNAKE_CASE__ ) with tarfile.TarFile(SCREAMING_SNAKE_CASE__ , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : List[Any] = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } lowercase : Optional[int] = insecure_tar_files[insecure_tar_file] lowercase : List[str] = tmp_path / """extracted""" TarExtractor.extract(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[int]: # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number lowercase : Any = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 lowercase : str = ( B"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" B"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" B"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" B"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(SCREAMING_SNAKE_CASE__ ) assert zipfile.is_zipfile(str(SCREAMING_SNAKE_CASE__ ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(SCREAMING_SNAKE_CASE__ ) # but we're right
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase , lowercase : Union[str, Any] = len(SCREAMING_SNAKE_CASE__ ), len(grid[0] ) if ( min(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) < 0 or row == row_length or col == col_length or (row, col) in visit or grid[row][col] == 1 ): return 0 if row == row_length - 1 and col == col_length - 1: return 1 visit.add((row, col) ) lowercase : str = 0 count += depth_first_search(SCREAMING_SNAKE_CASE__ , row + 1 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) count += depth_first_search(SCREAMING_SNAKE_CASE__ , row - 1 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) count += depth_first_search(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , col + 1 , SCREAMING_SNAKE_CASE__ ) count += depth_first_search(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , col - 1 , SCREAMING_SNAKE_CASE__ ) visit.remove((row, col) ) return count if __name__ == "__main__": import doctest doctest.testmod()
20
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 lowercase : List[str] = logging.get_logger(__name__) lowercase : Optional[Any] = { """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 ( lowerCAmelCase ): _a : str= "gpt_neo" _a : Optional[int]= ["past_key_values"] _a : Dict= {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self ,snake_case=50257 ,snake_case=2048 ,snake_case=2048 ,snake_case=24 ,snake_case=[[["global", "local"], 12]] ,snake_case=16 ,snake_case=None ,snake_case=256 ,snake_case="gelu_new" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.1 ,snake_case=1e-5 ,snake_case=0.02 ,snake_case=True ,snake_case=50256 ,snake_case=50256 ,**snake_case ,): '''simple docstring''' lowercase : int = vocab_size lowercase : Union[str, Any] = max_position_embeddings lowercase : Dict = hidden_size lowercase : Union[str, Any] = num_layers lowercase : Union[str, Any] = num_heads lowercase : Optional[int] = intermediate_size lowercase : List[str] = window_size lowercase : Optional[int] = activation_function lowercase : List[str] = resid_dropout lowercase : int = embed_dropout lowercase : Optional[int] = attention_dropout lowercase : Tuple = classifier_dropout lowercase : Optional[int] = layer_norm_epsilon lowercase : Dict = initializer_range lowercase : List[str] = use_cache lowercase : Optional[int] = bos_token_id lowercase : int = eos_token_id lowercase : Union[str, Any] = attention_types lowercase : Dict = self.expand_attention_types_params(snake_case ) 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=snake_case ,eos_token_id=snake_case ,**snake_case ) @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : List[Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: import torch lowercase : Tuple = input.size() lowercase : int = len(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = shape[dimension] lowercase : int = torch.arange(0 , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.div(sizedim - size , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) + 1 lowercase : Dict = torch.arange(SCREAMING_SNAKE_CASE__ ) + low_indices[:min_length][:, None] lowercase : Union[str, Any] = [slice(SCREAMING_SNAKE_CASE__ )] * rank lowercase : Optional[Any] = indices lowercase : List[str] = input[s] lowercase : Optional[int] = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: import torch lowercase : Union[str, Any] = torch.arange(1 , SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.remainder(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = remainders == 0 lowercase : Optional[int] = candidates[divisor_indices] lowercase : List[Any] = torch.max(SCREAMING_SNAKE_CASE__ ) return largest_divisor, torch.div(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , rounding_mode="""floor""" ) class __snake_case ( lowerCAmelCase ): @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(snake_case ,direction="""inputs""" ) lowercase : Dict = {0: """batch""", 1: """past_sequence + sequence"""} else: lowercase : List[str] = {0: """batch""", 1: """sequence"""} return common_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self._config.num_heads def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = -1 ,snake_case = -1 ,snake_case = False ,snake_case = None ,): '''simple docstring''' lowercase : Any = super(snake_case ,self ).generate_dummy_inputs( snake_case ,batch_size=snake_case ,seq_length=snake_case ,is_pair=snake_case ,framework=snake_case ) # We need to order the input in the way they appears in the forward() lowercase : List[str] = 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 lowercase , lowercase : List[Any] = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowercase : Optional[int] = seqlen + 2 lowercase : int = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowercase : Optional[Any] = [ (torch.zeros(snake_case ), torch.zeros(snake_case )) for _ in range(self.num_layers ) ] lowercase : Optional[Any] = common_inputs["""attention_mask"""] if self.use_past: lowercase : Any = ordered_inputs["""attention_mask"""].dtype lowercase : Union[str, Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(snake_case ,snake_case ,dtype=snake_case )] ,dim=1 ) return ordered_inputs @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 13
20
1
import os import sys import tempfile import torch from .state import AcceleratorState from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=() , SCREAMING_SNAKE_CASE__=None , SCREAMING_SNAKE_CASE__="no" , SCREAMING_SNAKE_CASE__="29500" ) -> Union[str, Any]: lowercase : str = False lowercase : List[Any] = False if any(key.startswith("""KAGGLE""" ) for key in os.environ.keys() ): lowercase : Tuple = True elif "IPython" in sys.modules: lowercase : Dict = """google.colab""" in str(sys.modules["""IPython"""].get_ipython() ) try: lowercase : List[str] = PrecisionType(mixed_precision.lower() ) except ValueError: raise ValueError( f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}." ) if (in_colab or in_kaggle) and (os.environ.get("""TPU_NAME""" , SCREAMING_SNAKE_CASE__ ) is not None): # TPU launch import torch_xla.distributed.xla_multiprocessing as xmp if len(AcceleratorState._shared_state ) > 0: raise ValueError( """To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside """ """your training function. Restart your notebook and make sure no cells initializes an """ """`Accelerator`.""" ) if num_processes is None: lowercase : List[Any] = 8 lowercase : List[str] = PrepareForLaunch(SCREAMING_SNAKE_CASE__ , distributed_type="""TPU""" ) print(f"Launching a training on {num_processes} TPU cores." ) xmp.spawn(SCREAMING_SNAKE_CASE__ , args=SCREAMING_SNAKE_CASE__ , nprocs=SCREAMING_SNAKE_CASE__ , start_method="""fork""" ) elif in_colab: # No need for a distributed launch otherwise as it's either CPU or one GPU. if torch.cuda.is_available(): print("""Launching training on one GPU.""" ) else: print("""Launching training on one CPU.""" ) function(*SCREAMING_SNAKE_CASE__ ) else: if num_processes is None: raise ValueError( """You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.""" ) if num_processes > 1: # Multi-GPU launch from torch.multiprocessing import start_processes from torch.multiprocessing.spawn import ProcessRaisedException if len(AcceleratorState._shared_state ) > 0: raise ValueError( """To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized """ """inside your training function. Restart your notebook and make sure no cells initializes an """ """`Accelerator`.""" ) if torch.cuda.is_initialized(): raise ValueError( """To launch a multi-GPU training from your notebook, you need to avoid running any instruction """ """using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA """ """function.""" ) # torch.distributed will expect a few environment variable to be here. We set the ones common to each # process here (the other ones will be set be the launcher). with patch_environment( world_size=SCREAMING_SNAKE_CASE__ , master_addr="""127.0.01""" , master_port=SCREAMING_SNAKE_CASE__ , mixed_precision=SCREAMING_SNAKE_CASE__ ): lowercase : Optional[Any] = PrepareForLaunch(SCREAMING_SNAKE_CASE__ , distributed_type="""MULTI_GPU""" ) print(f"Launching training on {num_processes} GPUs." ) try: start_processes(SCREAMING_SNAKE_CASE__ , args=SCREAMING_SNAKE_CASE__ , nprocs=SCREAMING_SNAKE_CASE__ , start_method="""fork""" ) except ProcessRaisedException as e: if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]: raise RuntimeError( """CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. """ """This likely stems from an outside import causing issues once the `notebook_launcher()` is called. """ """Please review your imports and test them when running the `notebook_launcher()` to identify """ """which one is problematic.""" ) from e else: # No need for a distributed launch otherwise as it's either CPU, GPU or MPS. if is_mps_available(): lowercase : Union[str, Any] = """1""" print("""Launching training on MPS.""" ) elif torch.cuda.is_available(): print("""Launching training on one GPU.""" ) else: print("""Launching training on CPU.""" ) function(*SCREAMING_SNAKE_CASE__ ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=() , SCREAMING_SNAKE_CASE__=2 ) -> List[Any]: from torch.multiprocessing import start_processes with tempfile.NamedTemporaryFile() as tmp_file: # torch.distributed will expect a few environment variable to be here. We set the ones common to each # process here (the other ones will be set be the launcher). with patch_environment( world_size=SCREAMING_SNAKE_CASE__ , master_addr="""127.0.01""" , master_port="""29500""" , accelerate_mixed_precision="""no""" , accelerate_debug_rdv_file=tmp_file.name , accelerate_use_cpu="""yes""" , ): lowercase : Tuple = PrepareForLaunch(SCREAMING_SNAKE_CASE__ , debug=SCREAMING_SNAKE_CASE__ ) start_processes(SCREAMING_SNAKE_CASE__ , args=SCREAMING_SNAKE_CASE__ , nprocs=SCREAMING_SNAKE_CASE__ , start_method="""fork""" )
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING lowercase : Any = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase ) class __snake_case ( lowerCAmelCase ): def __init__( self ,*snake_case ,**snake_case ): '''simple docstring''' super().__init__(*snake_case ,**snake_case ) requires_backends(self ,"""vision""" ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == """tf""" else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ): '''simple docstring''' lowercase : List[Any] = {} if top_k is not None: lowercase : int = top_k return {}, {}, postprocess_params def __call__( self ,snake_case ,**snake_case ): '''simple docstring''' return super().__call__(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Any = load_image(snake_case ) lowercase : List[Any] = self.image_processor(images=snake_case ,return_tensors=self.framework ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : int = self.model(**snake_case ) return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ): '''simple docstring''' if top_k > self.model.config.num_labels: lowercase : Tuple = self.model.config.num_labels if self.framework == "pt": lowercase : str = model_outputs.logits.softmax(-1 )[0] lowercase , lowercase : Dict = probs.topk(snake_case ) elif self.framework == "tf": lowercase : Optional[int] = stable_softmax(model_outputs.logits ,axis=-1 )[0] lowercase : Union[str, Any] = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : List[str] = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f"Unsupported framework: {self.framework}" ) lowercase : Tuple = scores.tolist() lowercase : Dict = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case ,snake_case )]
20
1
from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase : Tuple = logging.get_logger(__name__) lowercase : Tuple = { """google/vit-base-patch16-224""": """https://huggingface.co/vit-base-patch16-224/resolve/main/config.json""", # See all ViT models at https://huggingface.co/models?filter=vit } class __snake_case ( lowerCAmelCase ): _a : Tuple= "vit" def __init__( self ,snake_case=768 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.0 ,snake_case=0.0 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=224 ,snake_case=16 ,snake_case=3 ,snake_case=True ,snake_case=16 ,**snake_case ,): '''simple docstring''' super().__init__(**snake_case ) lowercase : Union[str, Any] = hidden_size lowercase : int = num_hidden_layers lowercase : Optional[int] = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : Dict = attention_probs_dropout_prob lowercase : Tuple = initializer_range lowercase : int = layer_norm_eps lowercase : Optional[Any] = image_size lowercase : Any = patch_size lowercase : List[Any] = num_channels lowercase : Dict = qkv_bias lowercase : List[Any] = encoder_stride class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= version.parse("1.11" ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ] ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return 1e-4
20
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class __snake_case : def __init__( self ,snake_case ,): '''simple docstring''' lowercase : Any = parent lowercase : Tuple = 13 lowercase : str = 7 lowercase : Dict = True lowercase : Dict = True lowercase : str = True lowercase : List[str] = True lowercase : int = True lowercase : Union[str, Any] = False lowercase : Dict = False lowercase : List[Any] = False lowercase : List[Any] = 2 lowercase : Optional[Any] = 99 lowercase : int = 0 lowercase : Tuple = 32 lowercase : int = 2 lowercase : Tuple = 4 lowercase : List[Any] = 0.1 lowercase : Tuple = 0.1 lowercase : List[Any] = 512 lowercase : int = 16 lowercase : Dict = 2 lowercase : int = 0.02 lowercase : Union[str, Any] = 3 lowercase : Any = 4 lowercase : List[Any] = """last""" lowercase : Tuple = True lowercase : List[Any] = None lowercase : Any = 0 def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size ) lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length] ,dtype=tf.floataa ) lowercase : Tuple = None if self.use_input_lengths: lowercase : List[str] = ( ids_tensor([self.batch_size] ,vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length lowercase : Tuple = None if self.use_token_type_ids: lowercase : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.n_langs ) lowercase : List[str] = None lowercase : List[str] = None lowercase : Optional[Any] = None if self.use_labels: lowercase : List[str] = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) lowercase : List[str] = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels ) lowercase : str = ids_tensor([self.batch_size] ,2 ,dtype=tf.floataa ) lowercase : Optional[Any] = ids_tensor([self.batch_size] ,self.num_choices ) lowercase : str = FlaubertConfig( vocab_size=self.vocab_size ,n_special=self.n_special ,emb_dim=self.hidden_size ,n_layers=self.num_hidden_layers ,n_heads=self.num_attention_heads ,dropout=self.hidden_dropout_prob ,attention_dropout=self.attention_probs_dropout_prob ,gelu_activation=self.gelu_activation ,sinusoidal_embeddings=self.sinusoidal_embeddings ,asm=self.asm ,causal=self.causal ,n_langs=self.n_langs ,max_position_embeddings=self.max_position_embeddings ,initializer_range=self.initializer_range ,summary_type=self.summary_type ,use_proj=self.use_proj ,bos_token_id=self.bos_token_id ,) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertModel(config=snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : Optional[Any] = model(snake_case ) lowercase : List[Any] = [input_ids, input_mask] lowercase : int = model(snake_case ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : List[Any] = TFFlaubertWithLMHeadModel(snake_case ) lowercase : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Tuple = TFFlaubertForQuestionAnsweringSimple(snake_case ) lowercase : Union[str, Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : Tuple = model(snake_case ) self.parent.assertEqual(result.start_logits.shape ,(self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape ,(self.batch_size, self.seq_length) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Union[str, Any] = TFFlaubertForSequenceClassification(snake_case ) lowercase : str = {"""input_ids""": input_ids, """lengths""": input_lengths} lowercase : str = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_labels lowercase : List[str] = TFFlaubertForTokenClassification(config=snake_case ) lowercase : Dict = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Any = self.num_choices lowercase : Dict = TFFlaubertForMultipleChoice(config=snake_case ) lowercase : Any = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Optional[Any] = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Dict = tf.tile(tf.expand_dims(snake_case ,1 ) ,(1, self.num_choices, 1) ) lowercase : Union[str, Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } lowercase : int = model(snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_choices) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.prepare_config_and_inputs() ( ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ( lowercase ) , ) : int = config_and_inputs lowercase : List[str] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Dict= ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) _a : Optional[Any]= ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable _a : Any= ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) _a : Tuple= False _a : int= False def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case ,snake_case ): '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = TFFlaubertModelTester(self ) lowercase : List[Any] = ConfigTester(self ,config_class=snake_case ,emb_dim=37 ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Dict = TFFlaubertModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) @require_tf @require_sentencepiece @require_tokenizers class __snake_case ( unittest.TestCase ): @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) lowercase : int = tf.convert_to_tensor( [[0, 158, 735, 2592, 1424, 6727, 82, 1]] ,dtype=tf.intaa ,) # "J'aime flaubert !" lowercase : Dict = model(snake_case )[0] lowercase : Union[str, Any] = tf.TensorShape((1, 8, 512) ) self.assertEqual(output.shape ,snake_case ) # compare the actual values for a slice. lowercase : Tuple = tf.convert_to_tensor( [ [ [-1.8_768_773, -1.566_555, 0.27_072_418], [-1.6_920_038, -0.5_873_505, 1.9_329_599], [-2.9_563_985, -1.6_993_835, 1.7_972_052], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1e-4 ) )
20
1
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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: lowercase : Union[str, Any] = [] embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight", f"stage{idx}.patch_embed.proj.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias", f"stage{idx}.patch_embed.proj.bias", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight", f"stage{idx}.patch_embed.norm.weight", ) ) embed.append( ( f"cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias", f"stage{idx}.patch_embed.norm.bias", ) ) return embed def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Optional[Any] = [] 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 _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Optional[Any] = [] token.append((f"cvt.encoder.stages.{idx}.cls_token", """stage2.cls_token""") ) return token def _snake_case( ) -> Dict: lowercase : Optional[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 _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = """imagenet-1k-id2label.json""" lowercase : List[str] = 1_000 lowercase : int = """huggingface/label-files""" lowercase : Union[str, Any] = num_labels lowercase : Optional[Any] = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , repo_type="""dataset""" ) ) , """r""" ) ) lowercase : List[Any] = {int(SCREAMING_SNAKE_CASE__ ): v for k, v in idalabel.items()} lowercase : Dict = idalabel lowercase : List[str] = {v: k for k, v in idalabel.items()} lowercase : List[str] = CvtConfig(num_labels=SCREAMING_SNAKE_CASE__ , idalabel=SCREAMING_SNAKE_CASE__ , labelaid=SCREAMING_SNAKE_CASE__ ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": lowercase : Tuple = [1, 2, 10] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": lowercase : Dict = [1, 4, 16] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: lowercase : int = [2, 2, 20] lowercase : Optional[int] = [3, 12, 16] lowercase : str = [192, 768, 1_024] lowercase : Union[str, Any] = CvtForImageClassification(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) lowercase : Optional[Any] = image_size lowercase : Union[str, Any] = torch.load(SCREAMING_SNAKE_CASE__ , map_location=torch.device("""cpu""" ) ) lowercase : Optional[Any] = OrderedDict() lowercase : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: lowercase : Optional[Any] = list_of_state_dict + cls_token(SCREAMING_SNAKE_CASE__ ) lowercase : str = list_of_state_dict + embeddings(SCREAMING_SNAKE_CASE__ ) for cnt in range(config.depth[idx] ): lowercase : List[str] = list_of_state_dict + attention(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = list_of_state_dict + final() for gg in list_of_state_dict: print(SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) ): lowercase : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser() parser.add_argument( """--cvt_model""", default="""cvt-w24""", type=str, help="""Name of the cvt model you'd like to convert.""", ) parser.add_argument( """--image_size""", default=384, type=int, help="""Input Image Size""", ) parser.add_argument( """--cvt_file_name""", default=R"""cvtmodels\CvT-w24-384x384-IN-22k.pth""", type=str, help="""Input Image Size""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : Optional[int] = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
import json import os from dataclasses import dataclass from functools import partial from typing import Callable import flax.linen as nn import jax import jax.numpy as jnp import joblib import optax import wandb from flax import jax_utils, struct, traverse_util from flax.serialization import from_bytes, to_bytes from flax.training import train_state from flax.training.common_utils import shard from tqdm.auto import tqdm from transformers import BigBirdConfig, FlaxBigBirdForQuestionAnswering from transformers.models.big_bird.modeling_flax_big_bird import FlaxBigBirdForQuestionAnsweringModule class __snake_case ( lowerCAmelCase ): _a : BigBirdConfig _a : jnp.dtype= jnp.floataa _a : bool= True def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' super().setup() lowercase : List[str] = nn.Dense(5 ,dtype=self.dtype ) def __call__( self ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : int = super().__call__(*snake_case ,**snake_case ) lowercase : Any = self.cls(outputs[2] ) return outputs[:2] + (cls_out,) class __snake_case ( lowerCAmelCase ): _a : List[Any]= FlaxBigBirdForNaturalQuestionsModule def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: def cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ): lowercase : int = logits.shape[-1] lowercase : Dict = (labels[..., None] == jnp.arange(SCREAMING_SNAKE_CASE__ )[None]).astype("""f4""" ) lowercase : Any = jax.nn.log_softmax(SCREAMING_SNAKE_CASE__ , axis=-1 ) lowercase : Optional[Any] = -jnp.sum(labels * logits , axis=-1 ) if reduction is not None: lowercase : Any = reduction(SCREAMING_SNAKE_CASE__ ) return loss lowercase : Optional[Any] = partial(SCREAMING_SNAKE_CASE__ , reduction=jnp.mean ) lowercase : Optional[int] = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Dict = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : int = cross_entropy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return (start_loss + end_loss + pooled_loss) / 3 @dataclass class __snake_case : _a : str= "google/bigbird-roberta-base" _a : int= 3000 _a : int= 1_0500 _a : int= 128 _a : int= 3 _a : int= 1 _a : int= 5 # tx_args _a : float= 3E-5 _a : float= 0.0 _a : int= 2_0000 _a : float= 0.00_95 _a : str= "bigbird-roberta-natural-questions" _a : str= "training-expt" _a : str= "data/nq-training.jsonl" _a : str= "data/nq-validation.jsonl" def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' os.makedirs(self.base_dir ,exist_ok=snake_case ) lowercase : Optional[int] = os.path.join(self.base_dir ,self.save_dir ) lowercase : Optional[int] = self.batch_size_per_device * jax.device_count() @dataclass class __snake_case : _a : int _a : int= 4096 # no dynamic padding on TPUs def __call__( self ,snake_case ): '''simple docstring''' lowercase : int = self.collate_fn(snake_case ) lowercase : Union[str, Any] = jax.tree_util.tree_map(snake_case ,snake_case ) return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase , lowercase : Union[str, Any] = self.fetch_inputs(features["""input_ids"""] ) lowercase : Tuple = { """input_ids""": jnp.array(snake_case ,dtype=jnp.intaa ), """attention_mask""": jnp.array(snake_case ,dtype=jnp.intaa ), """start_labels""": jnp.array(features["""start_token"""] ,dtype=jnp.intaa ), """end_labels""": jnp.array(features["""end_token"""] ,dtype=jnp.intaa ), """pooled_labels""": jnp.array(features["""category"""] ,dtype=jnp.intaa ), } return batch def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = [self._fetch_inputs(snake_case ) for ids in input_ids] return zip(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Union[str, Any] = [1 for _ in range(len(snake_case ) )] while len(snake_case ) < self.max_length: input_ids.append(self.pad_id ) attention_mask.append(0 ) return input_ids, attention_mask def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None ) -> Any: if seed is not None: lowercase : Optional[int] = dataset.shuffle(seed=SCREAMING_SNAKE_CASE__ ) for i in range(len(SCREAMING_SNAKE_CASE__ ) // batch_size ): lowercase : Optional[Any] = dataset[i * batch_size : (i + 1) * batch_size] yield dict(SCREAMING_SNAKE_CASE__ ) @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[Any]: def loss_fn(SCREAMING_SNAKE_CASE__ ): lowercase : List[str] = model_inputs.pop("""start_labels""" ) lowercase : Optional[int] = model_inputs.pop("""end_labels""" ) lowercase : str = model_inputs.pop("""pooled_labels""" ) lowercase : Union[str, Any] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=SCREAMING_SNAKE_CASE__ , dropout_rng=SCREAMING_SNAKE_CASE__ , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[str] = outputs return state.loss_fn( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , ) lowercase , lowercase : int = jax.random.split(SCREAMING_SNAKE_CASE__ ) lowercase : Dict = jax.value_and_grad(SCREAMING_SNAKE_CASE__ ) lowercase , lowercase : Union[str, Any] = grad_fn(state.params ) lowercase : List[Any] = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) lowercase : List[Any] = jax.lax.pmean(SCREAMING_SNAKE_CASE__ , """batch""" ) lowercase : str = state.apply_gradients(grads=SCREAMING_SNAKE_CASE__ ) return state, metrics, new_drp_rng @partial(jax.pmap , axis_name="""batch""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) -> List[str]: lowercase : int = model_inputs.pop("""start_labels""" ) lowercase : Dict = model_inputs.pop("""end_labels""" ) lowercase : Optional[Any] = model_inputs.pop("""pooled_labels""" ) lowercase : Optional[int] = state.apply_fn(**SCREAMING_SNAKE_CASE__ , params=state.params , train=SCREAMING_SNAKE_CASE__ ) lowercase , lowercase , lowercase : List[Any] = outputs lowercase : Dict = state.loss_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : str = jax.lax.pmean({"""loss""": loss} , axis_name="""batch""" ) return metrics class __snake_case ( train_state.TrainState ): _a : Callable= struct.field(pytree_node=lowerCAmelCase ) @dataclass class __snake_case : _a : Args _a : Callable _a : Callable _a : Callable _a : Callable _a : wandb _a : Callable= None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case=None ): '''simple docstring''' lowercase : Tuple = model.params lowercase : Any = TrainState.create( apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,loss_fn=snake_case ,) if ckpt_dir is not None: lowercase , lowercase , lowercase , lowercase , lowercase : Tuple = restore_checkpoint(snake_case ,snake_case ) lowercase : List[str] = { """lr""": args.lr, """init_lr""": args.init_lr, """warmup_steps""": args.warmup_steps, """num_train_steps""": num_train_steps, """weight_decay""": args.weight_decay, } lowercase , lowercase : Tuple = build_tx(**snake_case ) lowercase : str = train_state.TrainState( step=snake_case ,apply_fn=model.__call__ ,params=snake_case ,tx=snake_case ,opt_state=snake_case ,) lowercase : Any = args lowercase : Optional[Any] = data_collator lowercase : List[str] = lr lowercase : str = params lowercase : Tuple = jax_utils.replicate(snake_case ) return state def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = self.args lowercase : Optional[Any] = len(snake_case ) // args.batch_size lowercase : int = jax.random.PRNGKey(0 ) lowercase : List[str] = jax.random.split(snake_case ,jax.device_count() ) for epoch in range(args.max_epochs ): lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : List[str] = get_batched_dataset(snake_case ,args.batch_size ,seed=snake_case ) lowercase : int = 0 for batch in tqdm(snake_case ,total=snake_case ,desc=f"Running EPOCH-{epoch}" ): lowercase : Dict = self.data_collator(snake_case ) lowercase , lowercase , lowercase : Optional[int] = self.train_step_fn(snake_case ,snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 if i % args.logging_steps == 0: lowercase : Optional[Any] = jax_utils.unreplicate(state.step ) lowercase : List[str] = running_loss.item() / i lowercase : List[str] = self.scheduler_fn(state_step - 1 ) lowercase : int = self.evaluate(snake_case ,snake_case ) lowercase : Tuple = { """step""": state_step.item(), """eval_loss""": eval_loss.item(), """tr_loss""": tr_loss, """lr""": lr.item(), } tqdm.write(str(snake_case ) ) self.logger.log(snake_case ,commit=snake_case ) if i % args.save_steps == 0: self.save_checkpoint(args.save_dir + f"-e{epoch}-s{i}" ,state=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : List[str] = get_batched_dataset(snake_case ,self.args.batch_size ) lowercase : Any = len(snake_case ) // self.args.batch_size lowercase : List[Any] = jnp.array(0 ,dtype=jnp.floataa ) lowercase : Optional[int] = 0 for batch in tqdm(snake_case ,total=snake_case ,desc="""Evaluating ... """ ): lowercase : Tuple = self.data_collator(snake_case ) lowercase : Optional[int] = self.val_step_fn(snake_case ,**snake_case ) running_loss += jax_utils.unreplicate(metrics["""loss"""] ) i += 1 return running_loss / i def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : str = jax_utils.unreplicate(snake_case ) print(f"SAVING CHECKPOINT IN {save_dir}" ,end=""" ... """ ) self.model_save_fn(snake_case ,params=state.params ) with open(os.path.join(snake_case ,"""opt_state.msgpack""" ) ,"""wb""" ) as f: f.write(to_bytes(state.opt_state ) ) joblib.dump(self.args ,os.path.join(snake_case ,"""args.joblib""" ) ) joblib.dump(self.data_collator ,os.path.join(snake_case ,"""data_collator.joblib""" ) ) with open(os.path.join(snake_case ,"""training_state.json""" ) ,"""w""" ) as f: json.dump({"""step""": state.step.item()} ,snake_case ) print("""DONE""" ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: print(f"RESTORING CHECKPOINT FROM {save_dir}" , end=""" ... """ ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """flax_model.msgpack""" ) , """rb""" ) as f: lowercase : str = from_bytes(state.params , f.read() ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """opt_state.msgpack""" ) , """rb""" ) as f: lowercase : Optional[int] = from_bytes(state.opt_state , f.read() ) lowercase : Optional[Any] = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """args.joblib""" ) ) lowercase : int = joblib.load(os.path.join(SCREAMING_SNAKE_CASE__ , """data_collator.joblib""" ) ) with open(os.path.join(SCREAMING_SNAKE_CASE__ , """training_state.json""" ) , """r""" ) as f: lowercase : Tuple = json.load(SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = training_state["""step"""] print("""DONE""" ) return params, opt_state, step, args, data_collator def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : List[str] = num_train_steps - warmup_steps lowercase : Dict = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=SCREAMING_SNAKE_CASE__ , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.linear_schedule(init_value=SCREAMING_SNAKE_CASE__ , end_value=1e-7 , transition_steps=SCREAMING_SNAKE_CASE__ ) lowercase : Tuple = optax.join_schedules(schedules=[warmup_fn, decay_fn] , boundaries=[warmup_steps] ) return lr def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: def weight_decay_mask(SCREAMING_SNAKE_CASE__ ): lowercase : List[Any] = traverse_util.flatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = {k: (v[-1] != """bias""" and v[-2:] != ("""LayerNorm""", """scale""")) for k, v in params.items()} return traverse_util.unflatten_dict(SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = scheduler_fn(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[str] = optax.adamw(learning_rate=SCREAMING_SNAKE_CASE__ , weight_decay=SCREAMING_SNAKE_CASE__ , mask=SCREAMING_SNAKE_CASE__ ) return tx, lr
20
1
import inspect import unittest from transformers import BitConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class __snake_case : def __init__( self ,snake_case ,snake_case=3 ,snake_case=32 ,snake_case=3 ,snake_case=10 ,snake_case=[8, 16, 32, 64] ,snake_case=[1, 1, 2, 1] ,snake_case=True ,snake_case=True ,snake_case="relu" ,snake_case=3 ,snake_case=None ,snake_case=["stage2", "stage3", "stage4"] ,snake_case=[2, 3, 4] ,snake_case=1 ,): '''simple docstring''' lowercase : Union[str, Any] = parent lowercase : List[Any] = batch_size lowercase : Optional[Any] = image_size lowercase : str = num_channels lowercase : Union[str, Any] = embeddings_size lowercase : Any = hidden_sizes lowercase : Union[str, Any] = depths lowercase : int = is_training lowercase : List[Any] = use_labels lowercase : List[str] = hidden_act lowercase : Tuple = num_labels lowercase : Optional[Any] = scope lowercase : str = len(snake_case ) lowercase : int = out_features lowercase : Any = out_indices lowercase : Any = num_groups def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) lowercase : int = None if self.use_labels: lowercase : Dict = ids_tensor([self.batch_size] ,self.num_labels ) lowercase : Tuple = self.get_config() return config, pixel_values, labels def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return BitConfig( 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 ,out_features=self.out_features ,out_indices=self.out_indices ,num_groups=self.num_groups ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Tuple = BitModel(config=snake_case ) model.to(snake_case ) model.eval() lowercase : List[Any] = model(snake_case ) self.parent.assertEqual( result.last_hidden_state.shape ,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[Any] = self.num_labels lowercase : List[str] = BitForImageClassification(snake_case ) model.to(snake_case ) model.eval() lowercase : List[str] = model(snake_case ,labels=snake_case ) self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels) ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Dict = BitBackbone(config=snake_case ) model.to(snake_case ) model.eval() lowercase : List[str] = model(snake_case ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) ,len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) ,[self.batch_size, self.hidden_sizes[1], 4, 4] ) # verify channels self.parent.assertEqual(len(model.channels ) ,len(config.out_features ) ) self.parent.assertListEqual(model.channels ,config.hidden_sizes[1:] ) # verify backbone works with out_features=None lowercase : Optional[Any] = None lowercase : List[str] = BitBackbone(config=snake_case ) model.to(snake_case ) model.eval() lowercase : Any = model(snake_case ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) ,1 ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) ,[self.batch_size, self.hidden_sizes[-1], 1, 1] ) # verify channels self.parent.assertEqual(len(model.channels ) ,1 ) self.parent.assertListEqual(model.channels ,[config.hidden_sizes[-1]] ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Dict = self.prepare_config_and_inputs() lowercase , lowercase , lowercase : str = config_and_inputs lowercase : Tuple = {"""pixel_values""": pixel_values} return config, inputs_dict @require_torch class __snake_case ( lowerCAmelCase , lowerCAmelCase , unittest.TestCase ): _a : Optional[int]= (BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else () _a : Any= ( {"feature-extraction": BitModel, "image-classification": BitForImageClassification} if is_torch_available() else {} ) _a : List[Any]= False _a : List[Any]= False _a : Optional[int]= False _a : Tuple= False _a : Optional[Any]= False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = BitModelTester(self ) lowercase : Tuple = ConfigTester(self ,config_class=snake_case ,has_text_modality=snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return @unittest.skip(reason="""Bit does not output attentions""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass @unittest.skip(reason="""Bit does not use inputs_embeds""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass @unittest.skip(reason="""Bit does not support input and output embeddings""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase , lowercase : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowercase : List[str] = model_class(snake_case ) lowercase : Any = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic lowercase : int = [*signature.parameters.keys()] lowercase : List[Any] = ["""pixel_values"""] self.assertListEqual(arg_names[:1] ,snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*snake_case ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase , lowercase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowercase : int = model_class(config=snake_case ) for name, module in model.named_modules(): if isinstance(snake_case ,(nn.BatchNormad, nn.GroupNorm) ): self.assertTrue( torch.all(module.weight == 1 ) ,msg=f"Parameter {name} of model {model_class} seems not properly initialized" ,) self.assertTrue( torch.all(module.bias == 0 ) ,msg=f"Parameter {name} of model {model_class} seems not properly initialized" ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' def check_hidden_states_output(snake_case ,snake_case ,snake_case ): lowercase : Any = model_class(snake_case ) model.to(snake_case ) model.eval() with torch.no_grad(): lowercase : str = model(**self._prepare_for_class(snake_case ,snake_case ) ) lowercase : Optional[int] = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states lowercase : Optional[int] = self.model_tester.num_stages self.assertEqual(len(snake_case ) ,expected_num_stages + 1 ) # Bit's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) ,[self.model_tester.image_size // 4, self.model_tester.image_size // 4] ,) lowercase , lowercase : int = self.model_tester.prepare_config_and_inputs_for_common() lowercase : Tuple = ["""preactivation""", """bottleneck"""] for model_class in self.all_model_classes: for layer_type in layers_type: lowercase : Dict = layer_type lowercase : int = True check_hidden_states_output(snake_case ,snake_case ,snake_case ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] lowercase : Union[str, Any] = True check_hidden_states_output(snake_case ,snake_case ,snake_case ) @unittest.skip(reason="""Bit does not use feedforward chunking""" ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowercase : Optional[Any] = BitModel.from_pretrained(snake_case ) self.assertIsNotNone(snake_case ) def _snake_case( ) -> Optional[int]: lowercase : str = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision class __snake_case ( unittest.TestCase ): @cached_property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return ( BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(snake_case ) lowercase : Union[str, Any] = self.default_image_processor lowercase : int = prepare_img() lowercase : str = image_processor(images=snake_case ,return_tensors="""pt""" ).to(snake_case ) # forward pass with torch.no_grad(): lowercase : Optional[int] = model(**snake_case ) # verify the logits lowercase : int = torch.Size((1, 1000) ) self.assertEqual(outputs.logits.shape ,snake_case ) lowercase : Optional[Any] = torch.tensor([[-0.6_526, -0.5_263, -1.4_398]] ).to(snake_case ) self.assertTrue(torch.allclose(outputs.logits[0, :3] ,snake_case ,atol=1e-4 ) ) @require_torch class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Tuple= (BitBackbone,) if is_torch_available() else () _a : str= BitConfig _a : str= False def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = BitModelTester(self )
20
from math import sqrt def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' must been an int and positive" lowercase : Union[str, Any] = True # 0 and 1 are none primes. if number <= 1: lowercase : str = False for divisor in range(2 , int(round(sqrt(SCREAMING_SNAKE_CASE__ ) ) ) + 1 ): # if 'number' divisible by 'divisor' then sets 'status' # of false and break up the loop. if number % divisor == 0: lowercase : Any = False break # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'status' must been from type bool" return status def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" # beginList: contains all natural numbers from 2 up to N lowercase : str = list(range(2 , n + 1 ) ) lowercase : Tuple = [] # this list will be returns. # actual sieve of erathostenes for i in range(len(SCREAMING_SNAKE_CASE__ ) ): for j in range(i + 1 , len(SCREAMING_SNAKE_CASE__ ) ): if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0): lowercase : Tuple = 0 # filters actual prime numbers. lowercase : int = [x for x in begin_list if x != 0] # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n > 2), "'N' must been an int and > 2" lowercase : Dict = [] # iterates over all numbers between 2 up to N+1 # if a number is prime then appends to list 'ans' for number in range(2 , n + 1 ): if is_prime(SCREAMING_SNAKE_CASE__ ): ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and number >= 0, "'number' must been an int and >= 0" lowercase : Tuple = [] # this list will be returns of the function. # potential prime number factors. lowercase : Optional[Any] = 2 lowercase : Any = number if number == 0 or number == 1: ans.append(SCREAMING_SNAKE_CASE__ ) # if 'number' not prime then builds the prime factorization of 'number' elif not is_prime(SCREAMING_SNAKE_CASE__ ): while quotient != 1: if is_prime(SCREAMING_SNAKE_CASE__ ) and (quotient % factor == 0): ans.append(SCREAMING_SNAKE_CASE__ ) quotient /= factor else: factor += 1 else: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type list" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Tuple = 0 # prime factorization of 'number' lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = max(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> str: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number >= 0 ), "'number' bust been an int and >= 0" lowercase : Union[str, Any] = 0 # prime factorization of 'number' lowercase : Tuple = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = min(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'ans' must been from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 == 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 == 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), "'number' must been an int" assert isinstance(number % 2 != 0 , SCREAMING_SNAKE_CASE__ ), "compare bust been from type bool" return number % 2 != 0 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (number > 2) and is_even(SCREAMING_SNAKE_CASE__ ) ), "'number' must been an int, even and > 2" lowercase : Union[str, Any] = [] # this list will returned # creates a list of prime numbers between 2 up to 'number' lowercase : str = get_prime_numbers(SCREAMING_SNAKE_CASE__ ) lowercase : Any = len(SCREAMING_SNAKE_CASE__ ) # run variable for while-loops. lowercase : Optional[Any] = 0 lowercase : List[Any] = None # exit variable. for break up the loops lowercase : Any = True while i < len_pn and loop: lowercase : str = i + 1 while j < len_pn and loop: if prime_numbers[i] + prime_numbers[j] == number: lowercase : Union[str, Any] = False ans.append(prime_numbers[i] ) ans.append(prime_numbers[j] ) j += 1 i += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (len(SCREAMING_SNAKE_CASE__ ) == 2) and (ans[0] + ans[1] == number) and is_prime(ans[0] ) and is_prime(ans[1] ) ), "'ans' must contains two primes. And sum of elements must been eq 'number'" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 0) and (numbera >= 0) ), "'number1' and 'number2' must been positive integer." lowercase : Union[str, Any] = 0 while numbera != 0: lowercase : Optional[int] = numbera % numbera lowercase : Optional[int] = numbera lowercase : Dict = rest # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( numbera >= 0 ), "'number' must been from type int and positive" return numbera def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Tuple: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numbera >= 1) and (numbera >= 1) ), "'number1' and 'number2' must been positive integer." lowercase : Dict = 1 # actual answer that will be return. # for kgV (x,1) if numbera > 1 and numbera > 1: # builds the prime factorization of 'number1' and 'number2' lowercase : Optional[Any] = prime_factorization(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = prime_factorization(SCREAMING_SNAKE_CASE__ ) elif numbera == 1 or numbera == 1: lowercase : Union[str, Any] = [] lowercase : List[str] = [] lowercase : Dict = max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = 0 lowercase : Optional[Any] = 0 lowercase : List[str] = [] # captured numbers int both 'primeFac1' and 'primeFac2' # iterates through primeFac1 for n in prime_fac_a: if n not in done: if n in prime_fac_a: lowercase : Dict = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(max(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) ): ans *= n else: lowercase : List[Any] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # iterates through primeFac2 for n in prime_fac_a: if n not in done: lowercase : Optional[int] = prime_fac_a.count(SCREAMING_SNAKE_CASE__ ) for _ in range(SCREAMING_SNAKE_CASE__ ): ans *= n done.append(SCREAMING_SNAKE_CASE__ ) # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( ans >= 0 ), "'ans' must been from type int and positive" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'number' must been a positive int" lowercase : Dict = 0 lowercase : List[str] = 2 # this variable holds the answer while index < n: index += 1 ans += 1 # counts to the next number # if ans not prime then # runs to the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): ans += 1 # precondition assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and is_prime( SCREAMING_SNAKE_CASE__ ), "'ans' must been a prime number and from type int" return ans def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: assert ( is_prime(SCREAMING_SNAKE_CASE__ ) and is_prime(SCREAMING_SNAKE_CASE__ ) and (p_number_a < p_number_a) ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'" lowercase : List[str] = p_number_a + 1 # jump to the next number lowercase : List[Any] = [] # this list will be returns. # if number is not prime then # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 while number < p_number_a: ans.append(SCREAMING_SNAKE_CASE__ ) number += 1 # fetch the next prime number. while not is_prime(SCREAMING_SNAKE_CASE__ ): number += 1 # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ans[0] != p_number_a and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] != p_number_a ), "'ans' must been a list without the arguments" # 'ans' contains not 'pNumber1' and 'pNumber2' ! return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 1), "'n' must been int and >= 1" lowercase : Optional[Any] = [] # will be returned. for divisor in range(1 , n + 1 ): if n % divisor == 0: ans.append(SCREAMING_SNAKE_CASE__ ) # precondition assert ans[0] == 1 and ans[len(SCREAMING_SNAKE_CASE__ ) - 1] == n, "Error in function getDivisiors(...)" return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Any: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and ( number > 1 ), "'number' must been an int and >= 1" lowercase : str = get_divisors(SCREAMING_SNAKE_CASE__ ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (divisors[0] == 1) and (divisors[len(SCREAMING_SNAKE_CASE__ ) - 1] == number) ), "Error in help-function getDivisiors(...)" # summed all divisors up to 'number' (exclusive), hence [:-1] return sum(divisors[:-1] ) == number def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Dict: assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (denominator != 0) ), "The arguments must been from type int and 'denominator' != 0" # build the greatest common divisor of numerator and denominator. lowercase : Tuple = gcd(abs(SCREAMING_SNAKE_CASE__ ) , abs(SCREAMING_SNAKE_CASE__ ) ) # precondition assert ( isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (numerator % gcd_of_fraction == 0) and (denominator % gcd_of_fraction == 0) ), "Error in function gcd(...,...)" return (numerator // gcd_of_fraction, denominator // gcd_of_fraction) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been a int and >= 0" lowercase : List[str] = 1 # this will be return. for factor in range(1 , n + 1 ): ans *= factor return ans def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Union[str, Any]: assert isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and (n >= 0), "'n' must been an int and >= 0" lowercase : int = 0 lowercase : Union[str, Any] = 1 lowercase : int = 1 # this will be return for _ in range(n - 1 ): lowercase : Optional[int] = ans ans += fiba lowercase : Optional[int] = tmp return ans
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase : int = { """configuration_mobilebert""": [ """MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MobileBertConfig""", """MobileBertOnnxConfig""", ], """tokenization_mobilebert""": ["""MobileBertTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[int] = ["""MobileBertTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : Optional[Any] = [ """MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """MobileBertForMaskedLM""", """MobileBertForMultipleChoice""", """MobileBertForNextSentencePrediction""", """MobileBertForPreTraining""", """MobileBertForQuestionAnswering""", """MobileBertForSequenceClassification""", """MobileBertForTokenClassification""", """MobileBertLayer""", """MobileBertModel""", """MobileBertPreTrainedModel""", """load_tf_weights_in_mobilebert""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase : int = [ """TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFMobileBertForMaskedLM""", """TFMobileBertForMultipleChoice""", """TFMobileBertForNextSentencePrediction""", """TFMobileBertForPreTraining""", """TFMobileBertForQuestionAnswering""", """TFMobileBertForSequenceClassification""", """TFMobileBertForTokenClassification""", """TFMobileBertMainLayer""", """TFMobileBertModel""", """TFMobileBertPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_mobilebert import ( MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileBertConfig, MobileBertOnnxConfig, ) from .tokenization_mobilebert import MobileBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mobilebert_fast import MobileBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mobilebert import ( MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, MobileBertForMaskedLM, MobileBertForMultipleChoice, MobileBertForNextSentencePrediction, MobileBertForPreTraining, MobileBertForQuestionAnswering, MobileBertForSequenceClassification, MobileBertForTokenClassification, MobileBertLayer, MobileBertModel, MobileBertPreTrainedModel, load_tf_weights_in_mobilebert, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mobilebert import ( TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFMobileBertForMaskedLM, TFMobileBertForMultipleChoice, TFMobileBertForNextSentencePrediction, TFMobileBertForPreTraining, TFMobileBertForQuestionAnswering, TFMobileBertForSequenceClassification, TFMobileBertForTokenClassification, TFMobileBertMainLayer, TFMobileBertModel, TFMobileBertPreTrainedModel, ) else: import sys lowercase : Union[str, Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
20
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase : List[str] = logging.get_logger(__name__) lowercase : Any = { """uclanlp/visualbert-vqa""": """https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json""", """uclanlp/visualbert-vqa-pre""": """https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json""", """uclanlp/visualbert-vqa-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-vcr""": """https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json""", """uclanlp/visualbert-vcr-pre""": """https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json""", """uclanlp/visualbert-vcr-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json""" ), """uclanlp/visualbert-nlvr2""": """https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-pre""": """https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json""", """uclanlp/visualbert-nlvr2-coco-pre""": ( """https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json""" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class __snake_case ( lowerCAmelCase ): _a : Union[str, Any]= "visual_bert" def __init__( self ,snake_case=30522 ,snake_case=768 ,snake_case=512 ,snake_case=12 ,snake_case=12 ,snake_case=3072 ,snake_case="gelu" ,snake_case=0.1 ,snake_case=0.1 ,snake_case=512 ,snake_case=2 ,snake_case=0.02 ,snake_case=1e-12 ,snake_case=False ,snake_case=True ,snake_case=1 ,snake_case=0 ,snake_case=2 ,**snake_case ,): '''simple docstring''' super().__init__(pad_token_id=snake_case ,bos_token_id=snake_case ,eos_token_id=snake_case ,**snake_case ) lowercase : Tuple = vocab_size lowercase : int = max_position_embeddings lowercase : Optional[Any] = hidden_size lowercase : int = visual_embedding_dim lowercase : Tuple = num_hidden_layers lowercase : str = num_attention_heads lowercase : Optional[Any] = intermediate_size lowercase : str = hidden_act lowercase : Tuple = hidden_dropout_prob lowercase : List[Any] = attention_probs_dropout_prob lowercase : Union[str, Any] = initializer_range lowercase : int = type_vocab_size lowercase : Union[str, Any] = layer_norm_eps lowercase : Union[str, Any] = bypass_transformer lowercase : int = special_visual_initialize
20
1
from __future__ import annotations def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[str]: # Checks if the entire collection has been sorted if len(SCREAMING_SNAKE_CASE__ ) <= 1 or n <= 1: return insert_next(SCREAMING_SNAKE_CASE__ , n - 1 ) rec_insertion_sort(SCREAMING_SNAKE_CASE__ , n - 1 ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: # Checks order between adjacent elements if index >= len(SCREAMING_SNAKE_CASE__ ) or collection[index - 1] <= collection[index]: return # Swaps adjacent elements since they are not in ascending order lowercase , lowercase : str = ( collection[index], collection[index - 1], ) insert_next(SCREAMING_SNAKE_CASE__ , index + 1 ) if __name__ == "__main__": lowercase : Tuple = input("""Enter integers separated by spaces: """) lowercase : list[int] = [int(num) for num in numbers.split()] rec_insertion_sort(number_list, len(number_list)) print(number_list)
20
import argparse import requests import torch from PIL import Image from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: if "cls_token" in name: lowercase : List[Any] = name.replace("""cls_token""" , """vit.embeddings.cls_token""" ) if "mask_token" in name: lowercase : Any = name.replace("""mask_token""" , """decoder.mask_token""" ) if "decoder_pos_embed" in name: lowercase : str = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: lowercase : List[str] = name.replace("""pos_embed""" , """vit.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: lowercase : Tuple = name.replace("""patch_embed.proj""" , """vit.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: lowercase : int = name.replace("""patch_embed.norm""" , """vit.embeddings.norm""" ) if "decoder_blocks" in name: lowercase : Tuple = name.replace("""decoder_blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: lowercase : List[Any] = name.replace("""blocks""" , """vit.encoder.layer""" ) if "attn.proj" in name: lowercase : List[str] = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name: lowercase : Union[str, Any] = name.replace("""attn""" , """attention.self""" ) if "norm1" in name: lowercase : Optional[Any] = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: lowercase : Union[str, Any] = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: lowercase : Dict = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: lowercase : Dict = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: lowercase : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: lowercase : Dict = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: lowercase : List[str] = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name: lowercase : Tuple = name.replace("""norm.weight""" , """vit.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name: lowercase : int = name.replace("""norm.bias""" , """vit.layernorm.bias""" ) return name def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: for key in orig_state_dict.copy().keys(): lowercase : List[Any] = orig_state_dict.pop(SCREAMING_SNAKE_CASE__ ) if "qkv" in key: lowercase : int = key.split(""".""" ) lowercase : List[str] = int(key_split[1] ) if "decoder_blocks" in key: lowercase : Tuple = config.decoder_hidden_size lowercase : int = """decoder.decoder_layers.""" if "weight" in key: lowercase : List[Any] = val[:dim, :] lowercase : Tuple = val[dim : dim * 2, :] lowercase : List[Any] = val[-dim:, :] elif "bias" in key: lowercase : str = val[:dim] lowercase : Dict = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Tuple = config.hidden_size lowercase : Union[str, Any] = """vit.encoder.layer.""" if "weight" in key: lowercase : Tuple = val[:dim, :] lowercase : List[str] = val[dim : dim * 2, :] lowercase : Dict = val[-dim:, :] elif "bias" in key: lowercase : Any = val[:dim] lowercase : str = val[dim : dim * 2] lowercase : Union[str, Any] = val[-dim:] else: lowercase : Union[str, Any] = val return orig_state_dict def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: lowercase : int = ViTMAEConfig() if "large" in checkpoint_url: lowercase : Dict = 1_024 lowercase : str = 4_096 lowercase : Optional[Any] = 24 lowercase : Optional[Any] = 16 elif "huge" in checkpoint_url: lowercase : int = 14 lowercase : List[Any] = 1_280 lowercase : int = 5_120 lowercase : List[Any] = 32 lowercase : Any = 16 lowercase : List[str] = ViTMAEForPreTraining(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__ , map_location="""cpu""" )["""model"""] lowercase : Tuple = ViTMAEImageProcessor(size=config.image_size ) lowercase : Optional[int] = convert_state_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) model.load_state_dict(SCREAMING_SNAKE_CASE__ ) model.eval() lowercase : Union[str, Any] = """https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg""" lowercase : Union[str, Any] = Image.open(requests.get(SCREAMING_SNAKE_CASE__ , stream=SCREAMING_SNAKE_CASE__ ).raw ) lowercase : Optional[Any] = ViTMAEImageProcessor(size=config.image_size ) lowercase : List[Any] = image_processor(images=SCREAMING_SNAKE_CASE__ , return_tensors="""pt""" ) # forward pass torch.manual_seed(2 ) lowercase : int = model(**SCREAMING_SNAKE_CASE__ ) lowercase : str = outputs.logits if "large" in checkpoint_url: lowercase : List[Any] = torch.tensor( [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]] ) elif "huge" in checkpoint_url: lowercase : Tuple = torch.tensor( [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]] ) else: lowercase : List[str] = torch.tensor( [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]] ) # verify logits assert torch.allclose(logits[0, :3, :3] , SCREAMING_SNAKE_CASE__ , atol=1e-4 ) print(f"Saving model to {pytorch_dump_folder_path}" ) model.save_pretrained(SCREAMING_SNAKE_CASE__ ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Union[str, Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--checkpoint_url""", default="""https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth""", type=str, help="""URL of the checkpoint you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) lowercase : List[Any] = parser.parse_args() convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
20
1
import logging import os from .state import PartialState class __snake_case ( logging.LoggerAdapter ): @staticmethod def _SCREAMING_SNAKE_CASE ( snake_case ): '''simple docstring''' lowercase : str = PartialState() return not main_process_only or (main_process_only and state.is_main_process) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' if PartialState._shared_state == {}: raise RuntimeError( """You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.""" ) lowercase : Any = kwargs.pop("""main_process_only""" ,snake_case ) lowercase : Any = kwargs.pop("""in_order""" ,snake_case ) if self.isEnabledFor(snake_case ): if self._should_log(snake_case ): lowercase , lowercase : Optional[int] = self.process(snake_case ,snake_case ) self.logger.log(snake_case ,snake_case ,*snake_case ,**snake_case ) elif in_order: lowercase : Any = PartialState() for i in range(state.num_processes ): if i == state.process_index: lowercase , lowercase : Union[str, Any] = self.process(snake_case ,snake_case ) self.logger.log(snake_case ,snake_case ,*snake_case ,**snake_case ) state.wait_for_everyone() def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = None ) -> Dict: if log_level is None: lowercase : Dict = os.environ.get("""ACCELERATE_LOG_LEVEL""" , SCREAMING_SNAKE_CASE__ ) lowercase : int = logging.getLogger(SCREAMING_SNAKE_CASE__ ) if log_level is not None: logger.setLevel(log_level.upper() ) logger.root.setLevel(log_level.upper() ) return MultiProcessAdapter(SCREAMING_SNAKE_CASE__ , {} )
20
import math from collections import defaultdict from typing import List, Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=0.999 , SCREAMING_SNAKE_CASE__="cosine" , ) -> List[Any]: if alpha_transform_type == "cosine": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(SCREAMING_SNAKE_CASE__ ): return math.exp(t * -12.0 ) else: raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}" ) lowercase : int = [] for i in range(SCREAMING_SNAKE_CASE__ ): lowercase : Dict = i / num_diffusion_timesteps lowercase : Optional[int] = (i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) / alpha_bar_fn(SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ ) ) return torch.tensor(SCREAMING_SNAKE_CASE__ , dtype=torch.floataa ) class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : Tuple= [e.name for e in KarrasDiffusionSchedulers] _a : int= 2 @register_to_config def __init__( self ,snake_case = 1000 ,snake_case = 0.00_085 ,snake_case = 0.012 ,snake_case = "linear" ,snake_case = None ,snake_case = "epsilon" ,snake_case = False ,snake_case = False ,snake_case = 1.0 ,snake_case = "linspace" ,snake_case = 0 ,): '''simple docstring''' if trained_betas is not None: lowercase : List[str] = torch.tensor(snake_case ,dtype=torch.floataa ) elif beta_schedule == "linear": lowercase : Optional[Any] = torch.linspace(snake_case ,snake_case ,snake_case ,dtype=torch.floataa ) elif beta_schedule == "scaled_linear": # this schedule is very specific to the latent diffusion model. lowercase : int = ( torch.linspace(beta_start**0.5 ,beta_end**0.5 ,snake_case ,dtype=torch.floataa ) ** 2 ) elif beta_schedule == "squaredcos_cap_v2": # Glide cosine schedule lowercase : Union[str, Any] = betas_for_alpha_bar(snake_case ,alpha_transform_type="""cosine""" ) elif beta_schedule == "exp": lowercase : int = betas_for_alpha_bar(snake_case ,alpha_transform_type="""exp""" ) else: raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}" ) lowercase : Any = 1.0 - self.betas lowercase : Dict = torch.cumprod(self.alphas ,dim=0 ) # set all values self.set_timesteps(snake_case ,snake_case ,snake_case ) lowercase : Tuple = use_karras_sigmas def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if schedule_timesteps is None: lowercase : Union[str, Any] = self.timesteps lowercase : Dict = (schedule_timesteps == timestep).nonzero() # The sigma index that is taken for the **very** first `step` # is always the second index (or the last index if there is only 1) # This way we can ensure we don't accidentally skip a sigma in # case we start in the middle of the denoising schedule (e.g. for image-to-image) if len(self._index_counter ) == 0: lowercase : Dict = 1 if len(snake_case ) > 1 else 0 else: lowercase : Union[str, Any] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep lowercase : str = self._index_counter[timestep_int] return indices[pos].item() @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config.timestep_spacing in ["linspace", "trailing"]: return self.sigmas.max() return (self.sigmas.max() ** 2 + 1) ** 0.5 def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[Any] = self.index_for_timestep(snake_case ) lowercase : Dict = self.sigmas[step_index] lowercase : List[str] = sample / ((sigma**2 + 1) ** 0.5) return sample def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case = None ,snake_case = None ,): '''simple docstring''' lowercase : Any = num_inference_steps lowercase : List[Any] = num_train_timesteps or self.config.num_train_timesteps # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891 if self.config.timestep_spacing == "linspace": lowercase : Optional[int] = np.linspace(0 ,num_train_timesteps - 1 ,snake_case ,dtype=snake_case )[::-1].copy() elif self.config.timestep_spacing == "leading": lowercase : int = num_train_timesteps // self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : List[str] = (np.arange(0 ,snake_case ) * step_ratio).round()[::-1].copy().astype(snake_case ) timesteps += self.config.steps_offset elif self.config.timestep_spacing == "trailing": lowercase : List[str] = num_train_timesteps / self.num_inference_steps # creates integer timesteps by multiplying by ratio # casting to int to avoid issues when num_inference_step is power of 3 lowercase : Optional[int] = (np.arange(snake_case ,0 ,-step_ratio )).round().copy().astype(snake_case ) timesteps -= 1 else: raise ValueError( f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'." ) lowercase : Optional[int] = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 ) lowercase : Dict = np.log(snake_case ) lowercase : Union[str, Any] = np.interp(snake_case ,np.arange(0 ,len(snake_case ) ) ,snake_case ) if self.config.use_karras_sigmas: lowercase : List[Any] = self._convert_to_karras(in_sigmas=snake_case ,num_inference_steps=self.num_inference_steps ) lowercase : Tuple = np.array([self._sigma_to_t(snake_case ,snake_case ) for sigma in sigmas] ) lowercase : Any = np.concatenate([sigmas, [0.0]] ).astype(np.floataa ) lowercase : List[Any] = torch.from_numpy(snake_case ).to(device=snake_case ) lowercase : List[Any] = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2 ), sigmas[-1:]] ) lowercase : Dict = torch.from_numpy(snake_case ) lowercase : List[Any] = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2 )] ) if str(snake_case ).startswith("""mps""" ): # mps does not support float64 lowercase : Any = timesteps.to(snake_case ,dtype=torch.floataa ) else: lowercase : str = timesteps.to(device=snake_case ) # empty dt and derivative lowercase : Union[str, Any] = None lowercase : Any = None # for exp beta schedules, such as the one for `pipeline_shap_e.py` # we need an index counter lowercase : str = defaultdict(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : Optional[int] = np.log(snake_case ) # get distribution lowercase : Union[str, Any] = log_sigma - log_sigmas[:, np.newaxis] # get sigmas range lowercase : Optional[int] = np.cumsum((dists >= 0) ,axis=0 ).argmax(axis=0 ).clip(max=log_sigmas.shape[0] - 2 ) lowercase : Any = low_idx + 1 lowercase : str = log_sigmas[low_idx] lowercase : Dict = log_sigmas[high_idx] # interpolate sigmas lowercase : int = (low - log_sigma) / (low - high) lowercase : Dict = np.clip(snake_case ,0 ,1 ) # transform interpolation to time range lowercase : Optional[Any] = (1 - w) * low_idx + w * high_idx lowercase : Tuple = t.reshape(sigma.shape ) return t def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' lowercase : float = in_sigmas[-1].item() lowercase : float = in_sigmas[0].item() lowercase : Dict = 7.0 # 7.0 is the value used in the paper lowercase : Optional[int] = np.linspace(0 ,1 ,snake_case ) lowercase : int = sigma_min ** (1 / rho) lowercase : Any = sigma_max ** (1 / rho) lowercase : Tuple = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho return sigmas @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.dt is None def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,snake_case = True ,): '''simple docstring''' lowercase : Union[str, Any] = self.index_for_timestep(snake_case ) # advance index counter by 1 lowercase : Optional[int] = timestep.cpu().item() if torch.is_tensor(snake_case ) else timestep self._index_counter[timestep_int] += 1 if self.state_in_first_order: lowercase : str = self.sigmas[step_index] lowercase : Optional[int] = self.sigmas[step_index + 1] else: # 2nd order / Heun's method lowercase : Dict = self.sigmas[step_index - 1] lowercase : Optional[Any] = self.sigmas[step_index] # currently only gamma=0 is supported. This usually works best anyways. # We can support gamma in the future but then need to scale the timestep before # passing it to the model which requires a change in API lowercase : Union[str, Any] = 0 lowercase : Any = sigma * (gamma + 1) # Note: sigma_hat == sigma for now # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise if self.config.prediction_type == "epsilon": lowercase : Any = sigma_hat if self.state_in_first_order else sigma_next lowercase : int = sample - sigma_input * model_output elif self.config.prediction_type == "v_prediction": lowercase : Union[str, Any] = sigma_hat if self.state_in_first_order else sigma_next lowercase : Optional[Any] = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + ( sample / (sigma_input**2 + 1) ) elif self.config.prediction_type == "sample": lowercase : Optional[Any] = model_output else: raise ValueError( f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`" ) if self.config.clip_sample: lowercase : str = pred_original_sample.clamp( -self.config.clip_sample_range ,self.config.clip_sample_range ) if self.state_in_first_order: # 2. Convert to an ODE derivative for 1st order lowercase : Optional[int] = (sample - pred_original_sample) / sigma_hat # 3. delta timestep lowercase : Union[str, Any] = sigma_next - sigma_hat # store for 2nd order step lowercase : Optional[int] = derivative lowercase : Union[str, Any] = dt lowercase : Union[str, Any] = sample else: # 2. 2nd order / Heun's method lowercase : Tuple = (sample - pred_original_sample) / sigma_next lowercase : Dict = (self.prev_derivative + derivative) / 2 # 3. take prev timestep & sample lowercase : Tuple = self.dt lowercase : Optional[Any] = self.sample # free dt and derivative # Note, this puts the scheduler in "first order mode" lowercase : List[str] = None lowercase : Tuple = None lowercase : Dict = None lowercase : List[Any] = sample + derivative * dt if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ,): '''simple docstring''' lowercase : Optional[int] = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype ) if original_samples.device.type == "mps" and torch.is_floating_point(snake_case ): # mps does not support float64 lowercase : List[Any] = self.timesteps.to(original_samples.device ,dtype=torch.floataa ) lowercase : List[str] = timesteps.to(original_samples.device ,dtype=torch.floataa ) else: lowercase : List[str] = self.timesteps.to(original_samples.device ) lowercase : Tuple = timesteps.to(original_samples.device ) lowercase : Any = [self.index_for_timestep(snake_case ,snake_case ) for t in timesteps] lowercase : int = sigmas[step_indices].flatten() while len(sigma.shape ) < len(original_samples.shape ): lowercase : Any = sigma.unsqueeze(-1 ) lowercase : Optional[int] = original_samples + noise * sigma return noisy_samples def __len__( self ): '''simple docstring''' return self.config.num_train_timesteps
20
1
import numpy as np import torch import torch.nn as nn from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel from ...utils import logging lowercase : Optional[Any] = logging.get_logger(__name__) class __snake_case ( lowerCAmelCase ): _a : List[str]= CLIPConfig _a : Tuple= ["CLIPEncoderLayer"] def __init__( self ,snake_case ): '''simple docstring''' super().__init__(snake_case ) lowercase : Union[str, Any] = CLIPVisionModelWithProjection(config.vision_config ) lowercase : Tuple = nn.Linear(config.vision_config.projection_dim ,1 ) lowercase : Optional[Any] = nn.Linear(config.vision_config.projection_dim ,1 ) @torch.no_grad() def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case=0.5 ,snake_case=0.5 ): '''simple docstring''' lowercase : str = self.vision_model(snake_case )[0] lowercase : List[str] = self.p_head(snake_case ) lowercase : List[Any] = nsfw_detected.flatten() lowercase : Union[str, Any] = nsfw_detected > p_threshold lowercase : Dict = nsfw_detected.tolist() if any(snake_case ): logger.warning( """Potential NSFW content was detected in one or more images. A black image will be returned instead.""" """ Try again with a different prompt and/or seed.""" ) for idx, nsfw_detected_ in enumerate(snake_case ): if nsfw_detected_: lowercase : Any = np.zeros(images[idx].shape ) lowercase : int = self.w_head(snake_case ) lowercase : List[str] = watermark_detected.flatten() lowercase : List[Any] = watermark_detected > w_threshold lowercase : List[Any] = watermark_detected.tolist() if any(snake_case ): logger.warning( """Potential watermarked content was detected in one or more images. A black image will be returned instead.""" """ Try again with a different prompt and/or seed.""" ) for idx, watermark_detected_ in enumerate(snake_case ): if watermark_detected_: lowercase : List[Any] = np.zeros(images[idx].shape ) return images, nsfw_detected, watermark_detected
20
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch lowercase : List[str] = logging.get_logger(__name__) @add_end_docstrings( lowerCAmelCase , R"\n top_k (`int`, defaults to 5):\n The number of predictions to return.\n targets (`str` or `List[str]`, *optional*):\n When passed, the model will limit the scores to the passed targets instead of looking up in the whole\n vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting\n token will be used (with a warning, and that might be slower).\n\n " , ) class __snake_case ( lowerCAmelCase ): def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if self.framework == "tf": lowercase : str = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": lowercase : Optional[int] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ) else: raise ValueError("""Unsupported framework""" ) return masked_index def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Tuple = self.get_masked_index(snake_case ) lowercase : Dict = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,f"No mask_token ({self.tokenizer.mask_token}) found on the input" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' if isinstance(snake_case ,snake_case ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input["""input_ids"""][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,**snake_case ): '''simple docstring''' if return_tensors is None: lowercase : int = self.framework lowercase : Optional[Any] = self.tokenizer(snake_case ,return_tensors=snake_case ) self.ensure_exactly_one_mask_token(snake_case ) return model_inputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' lowercase : Optional[int] = self.model(**snake_case ) lowercase : Tuple = model_inputs["""input_ids"""] return model_outputs def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=5 ,snake_case=None ): '''simple docstring''' if target_ids is not None and target_ids.shape[0] < top_k: lowercase : str = target_ids.shape[0] lowercase : Optional[Any] = model_outputs["""input_ids"""][0] lowercase : List[str] = model_outputs["""logits"""] if self.framework == "tf": lowercase : List[str] = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] lowercase : Tuple = outputs.numpy() lowercase : Tuple = outputs[0, masked_index, :] lowercase : Any = stable_softmax(snake_case ,axis=-1 ) if target_ids is not None: lowercase : Union[str, Any] = tf.gather_nd(tf.squeeze(snake_case ,0 ) ,target_ids.reshape(-1 ,1 ) ) lowercase : int = tf.expand_dims(snake_case ,0 ) lowercase : Tuple = tf.math.top_k(snake_case ,k=snake_case ) lowercase , lowercase : int = topk.values.numpy(), topk.indices.numpy() else: lowercase : Optional[Any] = torch.nonzero(input_ids == self.tokenizer.mask_token_id ,as_tuple=snake_case ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample lowercase : Union[str, Any] = outputs[0, masked_index, :] lowercase : Tuple = logits.softmax(dim=-1 ) if target_ids is not None: lowercase : List[str] = probs[..., target_ids] lowercase , lowercase : Union[str, Any] = probs.topk(snake_case ) lowercase : Any = [] lowercase : List[Any] = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() ,predictions.tolist() ) ): lowercase : Dict = [] for v, p in zip(_values ,_predictions ): # Copy is important since we're going to modify this array in place lowercase : Dict = input_ids.numpy().copy() if target_ids is not None: lowercase : Union[str, Any] = target_ids[p].tolist() lowercase : Tuple = p # Filter padding out: lowercase : List[str] = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back lowercase : Tuple = self.tokenizer.decode(snake_case ,skip_special_tokens=snake_case ) lowercase : Optional[Any] = {"""score""": v, """token""": p, """token_str""": self.tokenizer.decode([p] ), """sequence""": sequence} row.append(snake_case ) result.append(snake_case ) if single_mask: return result[0] return result def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ): '''simple docstring''' if isinstance(snake_case ,snake_case ): lowercase : List[Any] = [targets] try: lowercase : List[str] = self.tokenizer.get_vocab() except Exception: lowercase : Any = {} lowercase : Dict = [] for target in targets: lowercase : Dict = vocab.get(snake_case ,snake_case ) if id_ is None: lowercase : Optional[int] = self.tokenizer( snake_case ,add_special_tokens=snake_case ,return_attention_mask=snake_case ,return_token_type_ids=snake_case ,max_length=1 ,truncation=snake_case ,)["""input_ids"""] if len(snake_case ) == 0: logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " """We cannot replace it with anything meaningful, ignoring it""" ) continue lowercase : Union[str, Any] = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"The specified target token `{target}` does not exist in the model vocabulary. " f"Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`." ) target_ids.append(id_ ) lowercase : Optional[Any] = list(set(snake_case ) ) if len(snake_case ) == 0: raise ValueError("""At least one target must be provided when passed.""" ) lowercase : Optional[Any] = np.array(snake_case ) return target_ids def _SCREAMING_SNAKE_CASE ( self ,snake_case=None ,snake_case=None ): '''simple docstring''' lowercase : Dict = {} if targets is not None: lowercase : str = self.get_target_ids(snake_case ,snake_case ) lowercase : List[Any] = target_ids if top_k is not None: lowercase : List[str] = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( """fill-mask""" ,self.model.base_model_prefix ,"""The tokenizer does not define a `mask_token`.""" ) return {}, {}, postprocess_params def __call__( self ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' lowercase : Tuple = super().__call__(snake_case ,**snake_case ) if isinstance(snake_case ,snake_case ) and len(snake_case ) == 1: return outputs[0] return outputs
20
1
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) lowercase : Tuple = logging.getLogger() def _snake_case( ) -> Tuple: lowercase : Any = argparse.ArgumentParser() parser.add_argument("""-f""" ) lowercase : Optional[int] = parser.parse_args() return args.f def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Optional[int] = {} lowercase : List[Any] = os.path.join(SCREAMING_SNAKE_CASE__ , """all_results.json""" ) if os.path.exists(SCREAMING_SNAKE_CASE__ ): with open(SCREAMING_SNAKE_CASE__ , """r""" ) as f: lowercase : Optional[int] = json.load(SCREAMING_SNAKE_CASE__ ) else: raise ValueError(f"can't find {path}" ) return results def _snake_case( ) -> Dict: lowercase : Any = torch.cuda.is_available() and torch_device == """cuda""" return is_using_cuda and is_apex_available() lowercase : List[Any] = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class __snake_case ( lowerCAmelCase ): @classmethod def _SCREAMING_SNAKE_CASE ( cls ): '''simple docstring''' lowercase : Union[str, Any] = tempfile.mkdtemp() lowercase : List[Any] = os.path.join(cls.tmpdir ,"""default_config.yml""" ) write_basic_config(save_location=cls.configPath ) lowercase : int = ["""accelerate""", """launch""", """--config_file""", cls.configPath] @classmethod def _SCREAMING_SNAKE_CASE ( cls ): '''simple docstring''' shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.get_auto_remove_tmp_dir() lowercase : List[str] = f"\n {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n --model_name_or_path distilbert-base-uncased\n --output_dir {tmp_dir}\n --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --learning_rate=1e-4\n --seed=42\n --checkpointing_steps epoch\n --with_tracking\n ".split() if is_cuda_and_apex_available(): testargs.append("""--fp16""" ) run_command(self._launch_args + testargs ) lowercase : Dict = get_results(snake_case ) self.assertGreaterEqual(result["""eval_accuracy"""] ,0.75 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""glue_no_trainer""" ) ) ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : str = self.get_auto_remove_tmp_dir() lowercase : Optional[Any] = f"\n {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n --model_name_or_path distilgpt2\n --train_file ./tests/fixtures/sample_text.txt\n --validation_file ./tests/fixtures/sample_text.txt\n --block_size 128\n --per_device_train_batch_size 5\n --per_device_eval_batch_size 5\n --num_train_epochs 2\n --output_dir {tmp_dir}\n --checkpointing_steps epoch\n --with_tracking\n ".split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) lowercase : Tuple = get_results(snake_case ) self.assertLess(result["""perplexity"""] ,100 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""clm_no_trainer""" ) ) ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.get_auto_remove_tmp_dir() lowercase : Tuple = f"\n {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n --model_name_or_path distilroberta-base\n --train_file ./tests/fixtures/sample_text.txt\n --validation_file ./tests/fixtures/sample_text.txt\n --output_dir {tmp_dir}\n --num_train_epochs=1\n --checkpointing_steps epoch\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Dict = get_results(snake_case ) self.assertLess(result["""perplexity"""] ,42 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""mlm_no_trainer""" ) ) ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = 7 if get_gpu_count() > 1 else 2 lowercase : Dict = self.get_auto_remove_tmp_dir() lowercase : Union[str, Any] = f"\n {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n --model_name_or_path bert-base-uncased\n --train_file tests/fixtures/tests_samples/conll/sample.json\n --validation_file tests/fixtures/tests_samples/conll/sample.json\n --output_dir {tmp_dir}\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=2\n --num_train_epochs={epochs}\n --seed 7\n --checkpointing_steps epoch\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Optional[int] = get_results(snake_case ) self.assertGreaterEqual(result["""eval_accuracy"""] ,0.75 ) self.assertLess(result["""train_loss"""] ,0.5 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""ner_no_trainer""" ) ) ) @unittest.skip(reason="""Fix me @muellerzr""" ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Tuple = self.get_auto_remove_tmp_dir() lowercase : Tuple = f"\n {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n --model_name_or_path bert-base-uncased\n --version_2_with_negative\n --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n --output_dir {tmp_dir}\n --seed=42\n --max_train_steps=10\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Union[str, Any] = get_results(snake_case ) # 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(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""qa_no_trainer""" ) ) ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.get_auto_remove_tmp_dir() lowercase : Optional[int] = f"\n {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n --model_name_or_path bert-base-uncased\n --train_file tests/fixtures/tests_samples/swag/sample.json\n --validation_file tests/fixtures/tests_samples/swag/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=20\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Dict = get_results(snake_case ) self.assertGreaterEqual(result["""eval_accuracy"""] ,0.8 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""swag_no_trainer""" ) ) ) @slow @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.get_auto_remove_tmp_dir() lowercase : Dict = f"\n {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n --model_name_or_path t5-small\n --train_file tests/fixtures/tests_samples/xsum/sample.json\n --validation_file tests/fixtures/tests_samples/xsum/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=50\n --num_warmup_steps=8\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Tuple = get_results(snake_case ) 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(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""summarization_no_trainer""" ) ) ) @slow @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[str] = self.get_auto_remove_tmp_dir() lowercase : Any = f"\n {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n --model_name_or_path sshleifer/student_marian_en_ro_6_1\n --source_lang en\n --target_lang ro\n --train_file tests/fixtures/tests_samples/wmt16/sample.json\n --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n --output_dir {tmp_dir}\n --max_train_steps=50\n --num_warmup_steps=8\n --num_beams=6\n --learning_rate=3e-3\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --source_lang en_XX\n --target_lang ro_RO\n --checkpointing_steps epoch\n --with_tracking\n ".split() run_command(self._launch_args + testargs ) lowercase : Optional[int] = get_results(snake_case ) self.assertGreaterEqual(result["""eval_bleu"""] ,30 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""translation_no_trainer""" ) ) ) @slow def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = logging.StreamHandler(sys.stdout ) logger.addHandler(snake_case ) lowercase : str = self.get_auto_remove_tmp_dir() lowercase : Optional[int] = f"\n {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n --dataset_name huggingface/semantic-segmentation-test-sample\n --output_dir {tmp_dir}\n --max_train_steps=10\n --num_warmup_steps=2\n --learning_rate=2e-4\n --per_device_train_batch_size=2\n --per_device_eval_batch_size=1\n --checkpointing_steps epoch\n ".split() run_command(self._launch_args + testargs ) lowercase : Optional[int] = get_results(snake_case ) self.assertGreaterEqual(result["""eval_overall_accuracy"""] ,0.10 ) @mock.patch.dict(os.environ ,{"""WANDB_MODE""": """offline"""} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = self.get_auto_remove_tmp_dir() lowercase : Dict = f"\n {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n --model_name_or_path google/vit-base-patch16-224-in21k\n --dataset_name hf-internal-testing/cats_vs_dogs_sample\n --learning_rate 1e-4\n --per_device_train_batch_size 2\n --per_device_eval_batch_size 1\n --max_train_steps 2\n --train_val_split 0.1\n --seed 42\n --output_dir {tmp_dir}\n --with_tracking\n --checkpointing_steps 1\n ".split() if is_cuda_and_apex_available(): testargs.append("""--fp16""" ) run_command(self._launch_args + testargs ) lowercase : Union[str, Any] = get_results(snake_case ) # The base model scores a 25% self.assertGreaterEqual(result["""eval_accuracy"""] ,0.6 ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""step_1""" ) ) ) self.assertTrue(os.path.exists(os.path.join(snake_case ,"""image_classification_no_trainer""" ) ) )
20
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 MobileNetVaImageProcessor class __snake_case ( unittest.TestCase ): def __init__( self ,snake_case ,snake_case=7 ,snake_case=3 ,snake_case=18 ,snake_case=30 ,snake_case=400 ,snake_case=True ,snake_case=None ,snake_case=True ,snake_case=None ,): '''simple docstring''' lowercase : Dict = size if size is not None else {"""shortest_edge""": 20} lowercase : Union[str, Any] = crop_size if crop_size is not None else {"""height""": 18, """width""": 18} lowercase : str = parent lowercase : int = batch_size lowercase : str = num_channels lowercase : int = image_size lowercase : List[str] = min_resolution lowercase : str = max_resolution lowercase : Dict = do_resize lowercase : Dict = size lowercase : Dict = do_center_crop lowercase : str = crop_size def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return { "do_resize": self.do_resize, "size": self.size, "do_center_crop": self.do_center_crop, "crop_size": self.crop_size, } @require_torch @require_vision class __snake_case ( lowerCAmelCase , unittest.TestCase ): _a : Any= MobileNetVaImageProcessor if is_vision_available() else None def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = MobileNetVaImageProcessingTester(self ) @property def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case ,"""do_resize""" ) ) self.assertTrue(hasattr(snake_case ,"""size""" ) ) self.assertTrue(hasattr(snake_case ,"""do_center_crop""" ) ) self.assertTrue(hasattr(snake_case ,"""crop_size""" ) ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 20} ) self.assertEqual(image_processor.crop_size ,{"""height""": 18, """width""": 18} ) lowercase : int = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 ,crop_size=84 ) self.assertEqual(image_processor.size ,{"""shortest_edge""": 42} ) self.assertEqual(image_processor.crop_size ,{"""height""": 84, """width""": 84} ) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowercase : str = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,Image.Image ) # Test not batched input lowercase : Dict = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : Tuple = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,numpify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,np.ndarray ) # Test not batched input lowercase : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=snake_case ,torchify=snake_case ) for image in image_inputs: self.assertIsInstance(snake_case ,torch.Tensor ) # Test not batched input lowercase : Optional[int] = image_processing(image_inputs[0] ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( 1, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,) # Test batched lowercase : List[str] = image_processing(snake_case ,return_tensors="""pt""" ).pixel_values self.assertEqual( encoded_images.shape ,( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size["""height"""], self.image_processor_tester.crop_size["""width"""], ) ,)
20
1
from typing import Tuple, Union from ...modeling_outputs import BackboneOutput from ...modeling_utils import PreTrainedModel from ...utils import is_timm_available, is_torch_available, requires_backends from ...utils.backbone_utils import BackboneMixin from .configuration_timm_backbone import TimmBackboneConfig if is_timm_available(): import timm if is_torch_available(): from torch import Tensor class __snake_case ( lowerCAmelCase , lowerCAmelCase ): _a : int= "pixel_values" _a : List[str]= False _a : Union[str, Any]= TimmBackboneConfig def __init__( self ,snake_case ,**snake_case ): '''simple docstring''' requires_backends(self ,"""timm""" ) super().__init__(snake_case ) lowercase : int = config if config.backbone is None: raise ValueError("""backbone is not set in the config. Please set it to a timm model name.""" ) if config.backbone not in timm.list_models(): raise ValueError(f"backbone {config.backbone} is not supported by timm." ) if hasattr(snake_case ,"""out_features""" ) and config.out_features is not None: raise ValueError("""out_features is not supported by TimmBackbone. Please use out_indices instead.""" ) lowercase : str = getattr(snake_case ,"""use_pretrained_backbone""" ,snake_case ) if pretrained is None: raise ValueError("""use_pretrained_backbone is not set in the config. Please set it to True or False.""" ) # We just take the final layer by default. This matches the default for the transformers models. lowercase : Optional[int] = config.out_indices if getattr(snake_case ,"""out_indices""" ,snake_case ) is not None else (-1,) lowercase : List[Any] = timm.create_model( config.backbone ,pretrained=snake_case ,features_only=config.features_only ,in_chans=config.num_channels ,out_indices=snake_case ,**snake_case ,) # These are used to control the output of the model when called. If output_hidden_states is True, then # return_layers is modified to include all layers. lowercase : Optional[int] = self._backbone.return_layers lowercase : Tuple = {layer["""module"""]: str(snake_case ) for i, layer in enumerate(self._backbone.feature_info.info )} super()._init_backbone(snake_case ) @classmethod def _SCREAMING_SNAKE_CASE ( cls ,snake_case ,*snake_case ,**snake_case ): '''simple docstring''' requires_backends(cls ,["""vision""", """timm"""] ) from ...models.timm_backbone import TimmBackboneConfig lowercase : Tuple = kwargs.pop("""config""" ,TimmBackboneConfig() ) lowercase : int = kwargs.pop("""use_timm_backbone""" ,snake_case ) if not use_timm: raise ValueError("""use_timm_backbone must be True for timm backbones""" ) lowercase : Any = kwargs.pop("""num_channels""" ,config.num_channels ) lowercase : List[Any] = kwargs.pop("""features_only""" ,config.features_only ) lowercase : Any = kwargs.pop("""use_pretrained_backbone""" ,config.use_pretrained_backbone ) lowercase : Dict = kwargs.pop("""out_indices""" ,config.out_indices ) lowercase : Any = TimmBackboneConfig( backbone=snake_case ,num_channels=snake_case ,features_only=snake_case ,use_pretrained_backbone=snake_case ,out_indices=snake_case ,) return super()._from_config(snake_case ,**snake_case ) def _SCREAMING_SNAKE_CASE ( self ,snake_case ): '''simple docstring''' pass def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case=None ,snake_case=None ,snake_case=None ,**snake_case ): '''simple docstring''' lowercase : List[Any] = return_dict if return_dict is not None else self.config.use_return_dict lowercase : Union[str, Any] = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) lowercase : Any = output_attentions if output_attentions is not None else self.config.output_attentions if output_attentions: raise ValueError("""Cannot output attentions for timm backbones at the moment""" ) if output_hidden_states: # We modify the return layers to include all the stages of the backbone lowercase : str = self._all_layers lowercase : Any = self._backbone(snake_case ,**snake_case ) lowercase : List[str] = self._return_layers lowercase : List[Any] = tuple(hidden_states[i] for i in self.out_indices ) else: lowercase : List[Any] = self._backbone(snake_case ,**snake_case ) lowercase : Tuple = None lowercase : Any = tuple(snake_case ) lowercase : Dict = tuple(snake_case ) if hidden_states is not None else None if not return_dict: lowercase : Union[str, Any] = (feature_maps,) if output_hidden_states: lowercase : Optional[Any] = output + (hidden_states,) return output return BackboneOutput(feature_maps=snake_case ,hidden_states=snake_case ,attentions=snake_case )
20
from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef import datasets lowercase : str = """\ @inproceedings{wang2019glue, title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding}, author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.}, note={In the Proceedings of ICLR.}, year={2019} } """ lowercase : Dict = """\ GLUE, the General Language Understanding Evaluation benchmark (https://gluebenchmark.com/) is a collection of resources for training, evaluating, and analyzing natural language understanding systems. """ lowercase : int = """ Compute GLUE evaluation metric associated to each GLUE dataset. Args: predictions: list of predictions to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. Returns: depending on the GLUE subset, one or several of: \"accuracy\": Accuracy \"f1\": F1 score \"pearson\": Pearson Correlation \"spearmanr\": Spearman Correlation \"matthews_correlation\": Matthew Correlation Examples: >>> glue_metric = datasets.load_metric('glue', 'sst2') # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"] >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> glue_metric = datasets.load_metric('glue', 'mrpc') # 'mrpc' or 'qqp' >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> glue_metric = datasets.load_metric('glue', 'stsb') >>> references = [0., 1., 2., 3., 4., 5.] >>> predictions = [0., 1., 2., 3., 4., 5.] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)}) {'pearson': 1.0, 'spearmanr': 1.0} >>> glue_metric = datasets.load_metric('glue', 'cola') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[int]: return float((preds == labels).mean() ) def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> Optional[Any]: lowercase : Any = simple_accuracy(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = float(fa_score(y_true=SCREAMING_SNAKE_CASE__ , y_pred=SCREAMING_SNAKE_CASE__ ) ) return { "accuracy": acc, "f1": fa, } def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = float(pearsonr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) lowercase : Dict = float(spearmanr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )[0] ) return { "pearson": pearson_corr, "spearmanr": spearman_corr, } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __snake_case ( datasets.Metric ): def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' if self.config_name not in [ "sst2", "mnli", "mnli_mismatched", "mnli_matched", "cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans", ]: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" ) return datasets.MetricInfo( description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32""" ), } ) ,codebase_urls=[] ,reference_urls=[] ,format="""numpy""" ,) def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' if self.config_name == "cola": return {"matthews_correlation": matthews_corrcoef(snake_case ,snake_case )} elif self.config_name == "stsb": return pearson_and_spearman(snake_case ,snake_case ) elif self.config_name in ["mrpc", "qqp"]: return acc_and_fa(snake_case ,snake_case ) elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]: return {"accuracy": simple_accuracy(snake_case ,snake_case )} else: raise KeyError( """You should supply a configuration name selected in """ """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """ """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]""" )
20
1
def _snake_case( SCREAMING_SNAKE_CASE__ = 1_000_000 ) -> int: lowercase : Optional[Any] = 1 lowercase : List[Any] = 1 lowercase : Any = {1: 1} for inputa in range(2 , SCREAMING_SNAKE_CASE__ ): lowercase : Any = 0 lowercase : int = inputa while True: if number in counters: counter += counters[number] break if number % 2 == 0: number //= 2 counter += 1 else: lowercase : Optional[Any] = (3 * number) + 1 counter += 1 if inputa not in counters: lowercase : Union[str, Any] = counter if counter > pre_counter: lowercase : List[Any] = inputa lowercase : str = counter return largest_number if __name__ == "__main__": print(solution(int(input().strip())))
20
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class __snake_case ( unittest.TestCase ): _a : Optional[int]= MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ,snake_case ): '''simple docstring''' lowercase : Any = hf_hub_download( repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : List[str] = VideoClassificationPipeline(model=snake_case ,image_processor=snake_case ,top_k=2 ) lowercase : Dict = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def _SCREAMING_SNAKE_CASE ( self ,snake_case ,snake_case ): '''simple docstring''' for example in examples: lowercase : int = video_classifier(snake_case ) self.assertEqual( snake_case ,[ {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, {"""score""": ANY(snake_case ), """label""": ANY(snake_case )}, ] ,) @require_torch def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' lowercase : Any = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" lowercase : str = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} ,crop_size={"""height""": 10, """width""": 10} ) lowercase : List[Any] = pipeline( """video-classification""" ,model=snake_case ,feature_extractor=snake_case ,frame_sampling_rate=4 ) lowercase : Dict = hf_hub_download(repo_id="""nateraw/video-demo""" ,filename="""archery.mp4""" ,repo_type="""dataset""" ) lowercase : Any = video_classifier(snake_case ,top_k=2 ) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}] ,) lowercase : str = video_classifier( [ video_file_path, video_file_path, ] ,top_k=2 ,) self.assertEqual( nested_simplify(snake_case ,decimals=4 ) ,[ [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], [{"""score""": 0.5_199, """label""": """LABEL_0"""}, {"""score""": 0.4_801, """label""": """LABEL_1"""}], ] ,) @require_tf def _SCREAMING_SNAKE_CASE ( self ): '''simple docstring''' pass
20
1
import argparse import json from typing import List from ltp import LTP from transformers.models.bert.tokenization_bert import BertTokenizer def _snake_case( SCREAMING_SNAKE_CASE__ ) -> Tuple: # This defines a "chinese character" as anything in the CJK Unicode block: # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) # # Note that the CJK Unicode block is NOT all Japanese and Korean characters, # despite its name. The modern Korean Hangul alphabet is a different block, # as is Japanese Hiragana and Katakana. Those alphabets are used to write # space-separated words, so they are not treated specially and handled # like the all of the other languages. if ( (cp >= 0x4_e_0_0 and cp <= 0x9_f_f_f) or (cp >= 0x3_4_0_0 and cp <= 0x4_d_b_f) # or (cp >= 0x2_0_0_0_0 and cp <= 0x2_a_6_d_f) # or (cp >= 0x2_a_7_0_0 and cp <= 0x2_b_7_3_f) # or (cp >= 0x2_b_7_4_0 and cp <= 0x2_b_8_1_f) # or (cp >= 0x2_b_8_2_0 and cp <= 0x2_c_e_a_f) # or (cp >= 0xf_9_0_0 and cp <= 0xf_a_f_f) or (cp >= 0x2_f_8_0_0 and cp <= 0x2_f_a_1_f) # ): # return True return False def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: # word like '180' or '身高' or '神' for char in word: lowercase : Dict = ord(SCREAMING_SNAKE_CASE__ ) if not _is_chinese_char(SCREAMING_SNAKE_CASE__ ): return 0 return 1 def _snake_case( SCREAMING_SNAKE_CASE__ ) -> List[Any]: lowercase : Union[str, Any] = set() for token in tokens: lowercase : List[str] = len(SCREAMING_SNAKE_CASE__ ) > 1 and is_chinese(SCREAMING_SNAKE_CASE__ ) if chinese_word: word_set.add(SCREAMING_SNAKE_CASE__ ) lowercase : Union[str, Any] = list(SCREAMING_SNAKE_CASE__ ) return word_list def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> int: if not chinese_word_set: return bert_tokens lowercase : List[str] = max([len(SCREAMING_SNAKE_CASE__ ) for w in chinese_word_set] ) lowercase : str = bert_tokens lowercase , lowercase : Any = 0, len(SCREAMING_SNAKE_CASE__ ) while start < end: lowercase : Optional[Any] = True if is_chinese(bert_word[start] ): lowercase : str = min(end - start , SCREAMING_SNAKE_CASE__ ) for i in range(SCREAMING_SNAKE_CASE__ , 1 , -1 ): lowercase : Any = """""".join(bert_word[start : start + i] ) if whole_word in chinese_word_set: for j in range(start + 1 , start + i ): lowercase : Any = """##""" + bert_word[j] lowercase : List[Any] = start + i lowercase : int = False break if single_word: start += 1 return bert_word def _snake_case( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) -> str: lowercase : Any = [] for i in range(0 , len(SCREAMING_SNAKE_CASE__ ) , 100 ): lowercase : Any = ltp_tokenizer.pipeline(lines[i : i + 100] , tasks=["""cws"""] ).cws lowercase : Tuple = [get_chinese_word(SCREAMING_SNAKE_CASE__ ) for r in res] ltp_res.extend(SCREAMING_SNAKE_CASE__ ) assert len(SCREAMING_SNAKE_CASE__ ) == len(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[Any] = [] for i in range(0 , len(SCREAMING_SNAKE_CASE__ ) , 100 ): lowercase : Union[str, Any] = bert_tokenizer(lines[i : i + 100] , add_special_tokens=SCREAMING_SNAKE_CASE__ , truncation=SCREAMING_SNAKE_CASE__ , max_length=512 ) bert_res.extend(res["""input_ids"""] ) assert len(SCREAMING_SNAKE_CASE__ ) == len(SCREAMING_SNAKE_CASE__ ) lowercase : Optional[int] = [] for input_ids, chinese_word in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): lowercase : str = [] for id in input_ids: lowercase : Optional[Any] = bert_tokenizer._convert_id_to_token(SCREAMING_SNAKE_CASE__ ) input_tokens.append(SCREAMING_SNAKE_CASE__ ) lowercase : int = add_sub_symbol(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) lowercase : List[Any] = [] # We only save pos of chinese subwords start with ##, which mean is part of a whole word. for i, token in enumerate(SCREAMING_SNAKE_CASE__ ): if token[:2] == "##": lowercase : Dict = token[2:] # save chinese tokens' pos if len(SCREAMING_SNAKE_CASE__ ) == 1 and _is_chinese_char(ord(SCREAMING_SNAKE_CASE__ ) ): ref_id.append(SCREAMING_SNAKE_CASE__ ) ref_ids.append(SCREAMING_SNAKE_CASE__ ) assert len(SCREAMING_SNAKE_CASE__ ) == len(SCREAMING_SNAKE_CASE__ ) return ref_ids def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: # For Chinese (Ro)Bert, the best result is from : RoBERTa-wwm-ext (https://github.com/ymcui/Chinese-BERT-wwm) # If we want to fine-tune these model, we have to use same tokenizer : LTP (https://github.com/HIT-SCIR/ltp) with open(args.file_name , """r""" , encoding="""utf-8""" ) as f: lowercase : Dict = f.readlines() lowercase : Tuple = [line.strip() for line in data if len(SCREAMING_SNAKE_CASE__ ) > 0 and not line.isspace()] # avoid delimiter like '\u2029' lowercase : Tuple = LTP(args.ltp ) # faster in GPU device lowercase : Dict = BertTokenizer.from_pretrained(args.bert ) lowercase : Any = prepare_ref(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) with open(args.save_path , """w""" , encoding="""utf-8""" ) as f: lowercase : Optional[Any] = [json.dumps(SCREAMING_SNAKE_CASE__ ) + """\n""" for ref in ref_ids] f.writelines(SCREAMING_SNAKE_CASE__ ) if __name__ == "__main__": lowercase : Tuple = argparse.ArgumentParser(description="""prepare_chinese_ref""") parser.add_argument( """--file_name""", required=False, type=str, default="""./resources/chinese-demo.txt""", help="""file need process, same as training data in lm""", ) parser.add_argument( """--ltp""", required=False, type=str, default="""./resources/ltp""", help="""resources for LTP tokenizer, usually a path""", ) parser.add_argument( """--bert""", required=False, type=str, default="""./resources/robert""", help="""resources for Bert tokenizer""", ) parser.add_argument( """--save_path""", required=False, type=str, default="""./resources/ref.txt""", help="""path to save res""", ) lowercase : Tuple = parser.parse_args() main(args)
20
from __future__ import annotations from collections import namedtuple from dataclasses import dataclass @dataclass class __snake_case : _a : int _a : TreeNode | None= None _a : TreeNode | None= None lowercase : Dict = namedtuple("""CoinsDistribResult""", """moves excess""") def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: if root is None: return 0 # Validation def count_nodes(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_nodes(node.left ) + count_nodes(node.right ) + 1 def count_coins(SCREAMING_SNAKE_CASE__ ) -> int: if node is None: return 0 return count_coins(node.left ) + count_coins(node.right ) + node.data if count_nodes(SCREAMING_SNAKE_CASE__ ) != count_coins(SCREAMING_SNAKE_CASE__ ): raise ValueError("""The nodes number should be same as the number of coins""" ) # Main calculation def get_distrib(SCREAMING_SNAKE_CASE__ ) -> CoinsDistribResult: if node is None: return CoinsDistribResult(0 , 1 ) lowercase , lowercase : int = get_distrib(node.left ) lowercase , lowercase : List[Any] = get_distrib(node.right ) lowercase : Optional[Any] = 1 - left_distrib_excess lowercase : Union[str, Any] = 1 - right_distrib_excess lowercase : List[Any] = ( left_distrib_moves + right_distrib_moves + abs(SCREAMING_SNAKE_CASE__ ) + abs(SCREAMING_SNAKE_CASE__ ) ) lowercase : Any = node.data - coins_to_left - coins_to_right return CoinsDistribResult(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) return get_distrib(SCREAMING_SNAKE_CASE__ )[0] if __name__ == "__main__": import doctest doctest.testmod()
20
1