code
stringlengths 82
53.2k
| code_codestyle
int64 0
721
| style_context
stringlengths 91
41.9k
| style_context_codestyle
int64 0
699
| label
int64 0
1
|
|---|---|---|---|---|
from typing import List, Optional, Union
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class lowerCAmelCase ( __UpperCamelCase ):
'''simple docstring'''
snake_case = ['image_processor', 'tokenizer']
snake_case = 'Pix2StructImageProcessor'
snake_case = ('T5Tokenizer', 'T5TokenizerFast')
def __init__( self : str , __snake_case : Optional[int] , __snake_case : Tuple ) -> Union[str, Any]:
'''simple docstring'''
lowerCamelCase = False
super().__init__(__snake_case , __snake_case )
def __call__( self : Dict , __snake_case : Dict=None , __snake_case : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None , __snake_case : bool = True , __snake_case : Union[bool, str, PaddingStrategy] = False , __snake_case : Union[bool, str, TruncationStrategy] = None , __snake_case : Optional[int] = None , __snake_case : Optional[int] = 2048 , __snake_case : int = 0 , __snake_case : Optional[int] = None , __snake_case : Optional[bool] = None , __snake_case : bool = False , __snake_case : bool = False , __snake_case : bool = False , __snake_case : bool = False , __snake_case : bool = False , __snake_case : bool = True , __snake_case : Optional[Union[str, TensorType]] = None , **__snake_case : List[str] , ) -> BatchEncoding:
'''simple docstring'''
if images is None and text is None:
raise ValueError('You have to specify either images or text.' )
# Get only text
if images is None and not self.image_processor.is_vqa:
lowerCamelCase = self.tokenizer
lowerCamelCase = self.tokenizer(
text=__snake_case , add_special_tokens=__snake_case , padding=__snake_case , truncation=__snake_case , max_length=__snake_case , stride=__snake_case , pad_to_multiple_of=__snake_case , return_attention_mask=__snake_case , return_overflowing_tokens=__snake_case , return_special_tokens_mask=__snake_case , return_offsets_mapping=__snake_case , return_token_type_ids=__snake_case , return_length=__snake_case , verbose=__snake_case , return_tensors=__snake_case , **__snake_case , )
return text_encoding
if not self.image_processor.is_vqa:
# add pixel_values
lowerCamelCase = self.image_processor(
__snake_case , return_tensors=__snake_case , max_patches=__snake_case , **__snake_case )
else:
# add pixel_values and bbox
lowerCamelCase = self.image_processor(
__snake_case , return_tensors=__snake_case , max_patches=__snake_case , header_text=__snake_case , **__snake_case )
if text is not None and not self.image_processor.is_vqa:
lowerCamelCase = self.tokenizer(
text=__snake_case , add_special_tokens=__snake_case , padding=__snake_case , truncation=__snake_case , max_length=__snake_case , stride=__snake_case , pad_to_multiple_of=__snake_case , return_attention_mask=__snake_case , return_overflowing_tokens=__snake_case , return_special_tokens_mask=__snake_case , return_offsets_mapping=__snake_case , return_token_type_ids=__snake_case , return_length=__snake_case , verbose=__snake_case , return_tensors=__snake_case , **__snake_case , )
if "attention_mask" in text_encoding:
lowerCamelCase = text_encoding.pop('attention_mask' )
if "input_ids" in text_encoding:
lowerCamelCase = text_encoding.pop('input_ids' )
else:
lowerCamelCase = None
if text_encoding is not None:
encoding_image_processor.update(__snake_case )
return encoding_image_processor
def lowerCamelCase__ ( self : Optional[int] , *__snake_case : Any , **__snake_case : Optional[int] ) -> List[Any]:
'''simple docstring'''
return self.tokenizer.batch_decode(*__snake_case , **__snake_case )
def lowerCamelCase__ ( self : Union[str, Any] , *__snake_case : Optional[Any] , **__snake_case : Optional[Any] ) -> Optional[int]:
'''simple docstring'''
return self.tokenizer.decode(*__snake_case , **__snake_case )
@property
def lowerCamelCase__ ( self : str ) -> Optional[Any]:
'''simple docstring'''
lowerCamelCase = self.tokenizer.model_input_names
lowerCamelCase = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 246
|
from __future__ import annotations
import unittest
from transformers import DebertaVaConfig, is_tf_available
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TFDebertaVaForMaskedLM,
TFDebertaVaForQuestionAnswering,
TFDebertaVaForSequenceClassification,
TFDebertaVaForTokenClassification,
TFDebertaVaModel,
)
class lowerCAmelCase :
'''simple docstring'''
def __init__( self : Dict , __snake_case : Tuple , __snake_case : Optional[int]=13 , __snake_case : int=7 , __snake_case : Tuple=True , __snake_case : Optional[Any]=True , __snake_case : List[Any]=True , __snake_case : Optional[Any]=True , __snake_case : Optional[Any]=99 , __snake_case : Union[str, Any]=32 , __snake_case : str=2 , __snake_case : Tuple=4 , __snake_case : Tuple=37 , __snake_case : Any="gelu" , __snake_case : List[Any]=0.1 , __snake_case : Optional[int]=0.1 , __snake_case : Tuple=512 , __snake_case : str=16 , __snake_case : str=2 , __snake_case : Dict=0.02 , __snake_case : Union[str, Any]=False , __snake_case : Tuple=True , __snake_case : Union[str, Any]="None" , __snake_case : Union[str, Any]=3 , __snake_case : Optional[Any]=4 , __snake_case : List[str]=None , ) -> Dict:
'''simple docstring'''
lowerCamelCase = parent
lowerCamelCase = batch_size
lowerCamelCase = seq_length
lowerCamelCase = is_training
lowerCamelCase = use_input_mask
lowerCamelCase = use_token_type_ids
lowerCamelCase = use_labels
lowerCamelCase = vocab_size
lowerCamelCase = hidden_size
lowerCamelCase = num_hidden_layers
lowerCamelCase = num_attention_heads
lowerCamelCase = intermediate_size
lowerCamelCase = hidden_act
lowerCamelCase = hidden_dropout_prob
lowerCamelCase = attention_probs_dropout_prob
lowerCamelCase = max_position_embeddings
lowerCamelCase = type_vocab_size
lowerCamelCase = type_sequence_label_size
lowerCamelCase = initializer_range
lowerCamelCase = num_labels
lowerCamelCase = num_choices
lowerCamelCase = relative_attention
lowerCamelCase = position_biased_input
lowerCamelCase = pos_att_type
lowerCamelCase = scope
def lowerCamelCase__ ( self : Union[str, Any] ) -> Optional[int]:
'''simple docstring'''
lowerCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
lowerCamelCase = None
if self.use_input_mask:
lowerCamelCase = random_attention_mask([self.batch_size, self.seq_length] )
lowerCamelCase = None
if self.use_token_type_ids:
lowerCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
lowerCamelCase = None
lowerCamelCase = None
lowerCamelCase = None
if self.use_labels:
lowerCamelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowerCamelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
lowerCamelCase = DebertaVaConfig(
vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , relative_attention=self.relative_attention , position_biased_input=self.position_biased_input , initializer_range=self.initializer_range , return_dict=__snake_case , )
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def lowerCamelCase__ ( self : Optional[Any] , __snake_case : List[str] , __snake_case : Optional[Any] , __snake_case : Optional[Any] , __snake_case : str , __snake_case : Tuple , __snake_case : List[Any] , __snake_case : Optional[Any] ) -> Any:
'''simple docstring'''
lowerCamelCase = TFDebertaVaModel(config=__snake_case )
lowerCamelCase = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
lowerCamelCase = [input_ids, input_mask]
lowerCamelCase = model(__snake_case )
lowerCamelCase = model(__snake_case )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def lowerCamelCase__ ( self : int , __snake_case : Optional[int] , __snake_case : str , __snake_case : Any , __snake_case : List[str] , __snake_case : Optional[int] , __snake_case : Optional[int] , __snake_case : Union[str, Any] ) -> Any:
'''simple docstring'''
lowerCamelCase = TFDebertaVaForMaskedLM(config=__snake_case )
lowerCamelCase = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
lowerCamelCase = model(__snake_case )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def lowerCamelCase__ ( self : Optional[int] , __snake_case : str , __snake_case : Union[str, Any] , __snake_case : Optional[Any] , __snake_case : List[Any] , __snake_case : Optional[Any] , __snake_case : Dict , __snake_case : Union[str, Any] ) -> List[Any]:
'''simple docstring'''
lowerCamelCase = self.num_labels
lowerCamelCase = TFDebertaVaForSequenceClassification(config=__snake_case )
lowerCamelCase = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
lowerCamelCase = model(__snake_case )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def lowerCamelCase__ ( self : Tuple , __snake_case : List[Any] , __snake_case : Optional[Any] , __snake_case : Optional[Any] , __snake_case : Optional[int] , __snake_case : Dict , __snake_case : str , __snake_case : List[str] ) -> int:
'''simple docstring'''
lowerCamelCase = self.num_labels
lowerCamelCase = TFDebertaVaForTokenClassification(config=__snake_case )
lowerCamelCase = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
lowerCamelCase = model(__snake_case )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def lowerCamelCase__ ( self : Tuple , __snake_case : Dict , __snake_case : str , __snake_case : Tuple , __snake_case : str , __snake_case : List[str] , __snake_case : int , __snake_case : Any ) -> Dict:
'''simple docstring'''
lowerCamelCase = TFDebertaVaForQuestionAnswering(config=__snake_case )
lowerCamelCase = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
lowerCamelCase = 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 lowerCamelCase__ ( self : Any ) -> List[Any]:
'''simple docstring'''
lowerCamelCase = self.prepare_config_and_inputs()
(
(
lowerCamelCase
) , (
lowerCamelCase
) , (
lowerCamelCase
) , (
lowerCamelCase
) , (
lowerCamelCase
) , (
lowerCamelCase
) , (
lowerCamelCase
) ,
) = config_and_inputs
lowerCamelCase = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
return config, inputs_dict
@require_tf
class lowerCAmelCase ( __UpperCamelCase , __UpperCamelCase , unittest.TestCase ):
'''simple docstring'''
snake_case = (
(
TFDebertaVaModel,
TFDebertaVaForMaskedLM,
TFDebertaVaForQuestionAnswering,
TFDebertaVaForSequenceClassification,
TFDebertaVaForTokenClassification,
)
if is_tf_available()
else ()
)
snake_case = (
{
'feature-extraction': TFDebertaVaModel,
'fill-mask': TFDebertaVaForMaskedLM,
'question-answering': TFDebertaVaForQuestionAnswering,
'text-classification': TFDebertaVaForSequenceClassification,
'token-classification': TFDebertaVaForTokenClassification,
'zero-shot': TFDebertaVaForSequenceClassification,
}
if is_tf_available()
else {}
)
snake_case = False
snake_case = False
def lowerCamelCase__ ( self : List[Any] ) -> List[str]:
'''simple docstring'''
lowerCamelCase = TFDebertaVaModelTester(self )
lowerCamelCase = ConfigTester(self , config_class=__snake_case , hidden_size=37 )
def lowerCamelCase__ ( self : Any ) -> int:
'''simple docstring'''
self.config_tester.run_common_tests()
def lowerCamelCase__ ( self : List[Any] ) -> Tuple:
'''simple docstring'''
lowerCamelCase = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*__snake_case )
def lowerCamelCase__ ( self : int ) -> Union[str, Any]:
'''simple docstring'''
lowerCamelCase = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*__snake_case )
def lowerCamelCase__ ( self : Tuple ) -> List[str]:
'''simple docstring'''
lowerCamelCase = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*__snake_case )
def lowerCamelCase__ ( self : Optional[Any] ) -> Tuple:
'''simple docstring'''
lowerCamelCase = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*__snake_case )
def lowerCamelCase__ ( self : Tuple ) -> str:
'''simple docstring'''
lowerCamelCase = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*__snake_case )
@slow
def lowerCamelCase__ ( self : Dict ) -> List[str]:
'''simple docstring'''
lowerCamelCase = TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge' )
self.assertIsNotNone(__snake_case )
@require_tf
class lowerCAmelCase ( unittest.TestCase ):
'''simple docstring'''
@unittest.skip(reason='Model not available yet' )
def lowerCamelCase__ ( self : Optional[int] ) -> Optional[Any]:
'''simple docstring'''
pass
@slow
def lowerCamelCase__ ( self : List[Any] ) -> List[Any]:
'''simple docstring'''
lowerCamelCase = TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge' )
lowerCamelCase = tf.constant([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]] )
lowerCamelCase = tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
lowerCamelCase = model(__snake_case , attention_mask=__snake_case )[0]
lowerCamelCase = tf.constant(
[[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
tf.debugging.assert_near(output[:, 1:4, 1:4] , __snake_case , atol=1e-4 )
| 246
| 1
|
from ...utils import (
OptionalDependencyNotAvailable,
is_torch_available,
is_transformers_available,
is_transformers_version,
)
try:
if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import (
VersatileDiffusionDualGuidedPipeline,
VersatileDiffusionImageVariationPipeline,
VersatileDiffusionPipeline,
VersatileDiffusionTextToImagePipeline,
)
else:
from .modeling_text_unet import UNetFlatConditionModel
from .pipeline_versatile_diffusion import VersatileDiffusionPipeline
from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline
from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline
from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
| 703
|
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 __A( unittest.TestCase ):
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = '''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
_UpperCamelCase = dict(zip(A, range(len(A ) ) ) )
_UpperCamelCase = {
'''unk_token''': '''<unk>''',
'''bos_token''': '''<s>''',
'''eos_token''': '''</s>''',
}
_UpperCamelCase = {
'''feature_size''': 1,
'''padding_value''': 0.0,
'''sampling_rate''': 1_6000,
'''return_attention_mask''': False,
'''do_normalize''': True,
}
_UpperCamelCase = tempfile.mkdtemp()
_UpperCamelCase = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''vocab_file'''] )
_UpperCamelCase = os.path.join(self.tmpdirname, A )
with open(self.vocab_file, '''w''', encoding='''utf-8''' ) as fp:
fp.write(json.dumps(A ) + '''\n''' )
with open(self.feature_extraction_file, '''w''', encoding='''utf-8''' ) as fp:
fp.write(json.dumps(A ) + '''\n''' )
# load decoder from hub
_UpperCamelCase = '''hf-internal-testing/ngram-beam-search-decoder'''
def _UpperCamelCase ( self, **A ):
"""simple docstring"""
_UpperCamelCase = self.add_kwargs_tokens_map.copy()
kwargs.update(A )
return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname, **A )
def _UpperCamelCase ( self, **A ):
"""simple docstring"""
return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname, **A )
def _UpperCamelCase ( self, **A ):
"""simple docstring"""
return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name, **A )
def _UpperCamelCase ( self ):
"""simple docstring"""
shutil.rmtree(self.tmpdirname )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
processor.save_pretrained(self.tmpdirname )
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname )
# tokenizer
self.assertEqual(processor.tokenizer.get_vocab(), tokenizer.get_vocab() )
self.assertIsInstance(processor.tokenizer, A )
# feature extractor
self.assertEqual(processor.feature_extractor.to_json_string(), feature_extractor.to_json_string() )
self.assertIsInstance(processor.feature_extractor, A )
# 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, A )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = 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
_UpperCamelCase = 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 _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_tokenizer()
# add token to trigger raise
tokenizer.add_tokens(['''xx'''] )
with self.assertRaisesRegex(A, '''include''' ):
WavaVecaProcessorWithLM(
tokenizer=A, feature_extractor=self.get_feature_extractor(), decoder=self.get_decoder() )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = floats_list((3, 1000) )
_UpperCamelCase = feature_extractor(A, return_tensors='''np''' )
_UpperCamelCase = processor(A, return_tensors='''np''' )
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum(), input_processor[key].sum(), delta=1E-2 )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = '''This is a test string'''
_UpperCamelCase = processor(text=A )
_UpperCamelCase = tokenizer(A )
for key in encoded_tok.keys():
self.assertListEqual(encoded_tok[key], encoded_processor[key] )
def _UpperCamelCase ( self, A=(2, 10, 16), A=77 ):
"""simple docstring"""
np.random.seed(A )
return np.random.rand(*A )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = self._get_dummy_logits(shape=(10, 16), seed=13 )
_UpperCamelCase = processor.decode(A )
_UpperCamelCase = decoder.decode_beams(A )[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 _UpperCamelCase ( self, A ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = 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:
_UpperCamelCase = processor.batch_decode(A )
else:
with get_context(A ).Pool() as pool:
_UpperCamelCase = processor.batch_decode(A, A )
_UpperCamelCase = list(A )
with get_context('''fork''' ).Pool() as p:
_UpperCamelCase = decoder.decode_beams_batch(A, A )
_UpperCamelCase , _UpperCamelCase , _UpperCamelCase = [], [], []
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(A, decoded_processor.text )
self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>'''], decoded_processor.text )
self.assertListEqual(A, decoded_processor.logit_score )
self.assertListEqual(A, decoded_processor.lm_score )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = self._get_dummy_logits()
_UpperCamelCase = 15
_UpperCamelCase = -20.0
_UpperCamelCase = -4.0
_UpperCamelCase = processor.batch_decode(
A, beam_width=A, beam_prune_logp=A, token_min_logp=A, )
_UpperCamelCase = decoded_processor_out.text
_UpperCamelCase = list(A )
with get_context('''fork''' ).Pool() as pool:
_UpperCamelCase = decoder.decode_beams_batch(
A, A, beam_width=A, beam_prune_logp=A, token_min_logp=A, )
_UpperCamelCase = [d[0][0] for d in decoded_decoder_out]
_UpperCamelCase = [d[0][2] for d in decoded_decoder_out]
_UpperCamelCase = [d[0][3] for d in decoded_decoder_out]
self.assertListEqual(A, A )
self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>'''], A )
self.assertTrue(np.array_equal(A, decoded_processor_out.logit_score ) )
self.assertTrue(np.allclose([-20.054, -18.447], A, atol=1E-3 ) )
self.assertTrue(np.array_equal(A, decoded_processor_out.lm_score ) )
self.assertTrue(np.allclose([-15.554, -13.9_474], A, atol=1E-3 ) )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
_UpperCamelCase = self._get_dummy_logits()
_UpperCamelCase = 2.0
_UpperCamelCase = 5.0
_UpperCamelCase = -20.0
_UpperCamelCase = True
_UpperCamelCase = processor.batch_decode(
A, alpha=A, beta=A, unk_score_offset=A, lm_score_boundary=A, )
_UpperCamelCase = decoded_processor_out.text
_UpperCamelCase = list(A )
decoder.reset_params(
alpha=A, beta=A, unk_score_offset=A, lm_score_boundary=A, )
with get_context('''fork''' ).Pool() as pool:
_UpperCamelCase = decoder.decode_beams_batch(
A, A, )
_UpperCamelCase = [d[0][0] for d in decoded_decoder_out]
self.assertListEqual(A, A )
self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>'''], A )
_UpperCamelCase = 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, A )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = processor.decoder.model_container[processor.decoder._model_key]
_UpperCamelCase = Path(language_model._kenlm_model.path.decode('''utf-8''' ) ).parent.parent.absolute()
_UpperCamelCase = os.listdir(A )
_UpperCamelCase = ['''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(A, A )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = snapshot_download('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained(A )
_UpperCamelCase = processor.decoder.model_container[processor.decoder._model_key]
_UpperCamelCase = Path(language_model._kenlm_model.path.decode('''utf-8''' ) ).parent.parent.absolute()
_UpperCamelCase = os.listdir(A )
_UpperCamelCase = os.listdir(A )
local_decoder_files.sort()
expected_decoder_files.sort()
# test that both decoder form hub and local files in cache are the same
self.assertListEqual(A, A )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = floats_list((3, 1000) )
_UpperCamelCase = processor_wavaveca(A, return_tensors='''np''' )
_UpperCamelCase = processor_auto(A, return_tensors='''np''' )
for key in input_wavaveca.keys():
self.assertAlmostEqual(input_wavaveca[key].sum(), input_auto[key].sum(), delta=1E-2 )
_UpperCamelCase = self._get_dummy_logits()
_UpperCamelCase = processor_wavaveca.batch_decode(A )
_UpperCamelCase = processor_auto.batch_decode(A )
self.assertListEqual(decoded_wavaveca.text, decoded_auto.text )
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = self.get_feature_extractor()
_UpperCamelCase = self.get_tokenizer()
_UpperCamelCase = self.get_decoder()
_UpperCamelCase = WavaVecaProcessorWithLM(tokenizer=A, feature_extractor=A, decoder=A )
self.assertListEqual(
processor.model_input_names, feature_extractor.model_input_names, msg='''`processor` and `feature_extractor` model input names do not match''', )
@staticmethod
def _UpperCamelCase ( A, A ):
"""simple docstring"""
_UpperCamelCase = [d[key] for d in offsets]
return retrieved_list
def _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = self._get_dummy_logits()[0]
_UpperCamelCase = processor.decode(A, output_word_offsets=A )
# 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(A, A ) )
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 _UpperCamelCase ( self ):
"""simple docstring"""
_UpperCamelCase = WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
_UpperCamelCase = self._get_dummy_logits()
_UpperCamelCase = processor.batch_decode(A, output_word_offsets=A )
# 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(A, A ) )
self.assertListEqual(
[''' '''.join(self.get_from_offsets(A, '''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 _UpperCamelCase ( self ):
"""simple docstring"""
import torch
_UpperCamelCase = load_dataset('''common_voice''', '''en''', split='''train''', streaming=A )
_UpperCamelCase = ds.cast_column('''audio''', datasets.Audio(sampling_rate=1_6000 ) )
_UpperCamelCase = iter(A )
_UpperCamelCase = next(A )
_UpperCamelCase = AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm''' )
_UpperCamelCase = 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
_UpperCamelCase = processor(sample['''audio''']['''array'''], return_tensors='''pt''' ).input_values
with torch.no_grad():
_UpperCamelCase = model(A ).logits.cpu().numpy()
_UpperCamelCase = processor.decode(logits[0], output_word_offsets=A )
_UpperCamelCase = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
_UpperCamelCase = [
{
'''start_time''': d['''start_offset'''] * time_offset,
'''end_time''': d['''end_offset'''] * time_offset,
'''word''': d['''word'''],
}
for d in output['''word_offsets''']
]
_UpperCamelCase = '''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(A, '''word''' ) ), A )
self.assertEqual(''' '''.join(self.get_from_offsets(A, '''word''' ) ), output.text )
# output times
_UpperCamelCase = torch.tensor(self.get_from_offsets(A, '''start_time''' ) )
_UpperCamelCase = torch.tensor(self.get_from_offsets(A, '''end_time''' ) )
# fmt: off
_UpperCamelCase = 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] )
_UpperCamelCase = 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(A, A, atol=0.01 ) )
self.assertTrue(torch.allclose(A, A, atol=0.01 ) )
| 105
| 0
|
from math import pi, sqrt
def a (_lowerCAmelCase ):
if num <= 0:
raise ValueError('''math domain error''' )
if num > 171.5:
raise OverflowError('''math range error''' )
elif num - int(_lowerCAmelCase ) not in (0, 0.5):
raise NotImplementedError('''num must be an integer or a half-integer''' )
elif num == 0.5:
return sqrt(_lowerCAmelCase )
else:
return 1.0 if num == 1 else (num - 1) * gamma(num - 1 )
def a ():
assert gamma(0.5 ) == sqrt(_lowerCAmelCase )
assert gamma(1 ) == 1.0
assert gamma(2 ) == 1.0
if __name__ == "__main__":
from doctest import testmod
testmod()
__SCREAMING_SNAKE_CASE =1.0
while num:
__SCREAMING_SNAKE_CASE =float(input("""Gamma of: """))
print(f"""gamma({num}) = {gamma(num)}""")
print("""\nEnter 0 to exit...""")
| 234
|
import argparse
import os
from pathlib import Path
import fairseq
import torch
from packaging import version
from torch import nn
from transformers import (
BartConfig,
BartForConditionalGeneration,
BartForSequenceClassification,
BartModel,
BartTokenizer,
)
from transformers.utils import logging
__SCREAMING_SNAKE_CASE =["""bart.large""", """bart.large.mnli""", """bart.large.cnn""", """bart_xsum/model.pt"""]
__SCREAMING_SNAKE_CASE ={"""bart.large""": BartModel, """bart.large.mnli""": BartForSequenceClassification}
if version.parse(fairseq.__version__) < version.parse("""0.9.0"""):
raise Exception("""requires fairseq >= 0.9.0""")
logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE =logging.get_logger(__name__)
__SCREAMING_SNAKE_CASE =""" Hello world! cécé herlolip"""
__SCREAMING_SNAKE_CASE =[
("""model.classification_heads.mnli.dense.weight""", """classification_head.dense.weight"""),
("""model.classification_heads.mnli.dense.bias""", """classification_head.dense.bias"""),
("""model.classification_heads.mnli.out_proj.weight""", """classification_head.out_proj.weight"""),
("""model.classification_heads.mnli.out_proj.bias""", """classification_head.out_proj.bias"""),
]
def a (_lowerCAmelCase ):
SCREAMING_SNAKE_CASE_ = [
'''encoder.version''',
'''decoder.version''',
'''model.encoder.version''',
'''model.decoder.version''',
'''_float_tensor''',
]
for k in ignore_keys:
state_dict.pop(_lowerCAmelCase , _lowerCAmelCase )
def a (_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ):
SCREAMING_SNAKE_CASE_ = dct.pop(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = val
def a (_lowerCAmelCase ):
SCREAMING_SNAKE_CASE_ = torch.load(_lowerCAmelCase , map_location='''cpu''' )
SCREAMING_SNAKE_CASE_ = torch.hub.load('''pytorch/fairseq''' , '''bart.large.cnn''' ).eval()
hub_interface.model.load_state_dict(sd['''model'''] )
return hub_interface
def a (_lowerCAmelCase ):
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ = emb.weight.shape
SCREAMING_SNAKE_CASE_ = nn.Linear(_lowerCAmelCase , _lowerCAmelCase , bias=_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = emb.weight.data
return lin_layer
@torch.no_grad()
def a (_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase=None ):
if not os.path.exists(_lowerCAmelCase ):
SCREAMING_SNAKE_CASE_ = torch.hub.load('''pytorch/fairseq''' , _lowerCAmelCase ).eval()
else:
SCREAMING_SNAKE_CASE_ = load_xsum_checkpoint(_lowerCAmelCase )
bart.model.upgrade_state_dict(bart.model.state_dict() )
if hf_checkpoint_name is None:
SCREAMING_SNAKE_CASE_ = checkpoint_path.replace('''.''' , '''-''' )
SCREAMING_SNAKE_CASE_ = BartConfig.from_pretrained(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = bart.encode(_lowerCAmelCase ).unsqueeze(0 )
SCREAMING_SNAKE_CASE_ = BartTokenizer.from_pretrained(_lowerCAmelCase ).encode(_lowerCAmelCase , return_tensors='''pt''' ).unsqueeze(0 )
if not torch.eq(_lowerCAmelCase , _lowerCAmelCase ).all():
raise ValueError(
F"converted tokenizer and pretrained tokenizer returned different output: {tokens} != {tokensa}" )
if checkpoint_path == "bart.large.mnli":
SCREAMING_SNAKE_CASE_ = bart.state_dict()
remove_ignore_keys_(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = state_dict['''model.decoder.embed_tokens.weight''']
for src, dest in mnli_rename_keys:
rename_key(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = BartForSequenceClassification(_lowerCAmelCase ).eval()
model.load_state_dict(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = bart.predict('''mnli''' , _lowerCAmelCase , return_logits=_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = model(_lowerCAmelCase )[0] # logits
else: # no classification heads to worry about
SCREAMING_SNAKE_CASE_ = bart.model.state_dict()
remove_ignore_keys_(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = state_dict['''decoder.embed_tokens.weight''']
SCREAMING_SNAKE_CASE_ = bart.extract_features(_lowerCAmelCase )
if hf_checkpoint_name == "facebook/bart-large":
SCREAMING_SNAKE_CASE_ = BartModel(_lowerCAmelCase ).eval()
model.load_state_dict(_lowerCAmelCase )
SCREAMING_SNAKE_CASE_ = model(_lowerCAmelCase ).model[0]
else:
SCREAMING_SNAKE_CASE_ = BartForConditionalGeneration(_lowerCAmelCase ).eval() # an existing summarization ckpt
model.model.load_state_dict(_lowerCAmelCase )
if hasattr(_lowerCAmelCase , '''lm_head''' ):
SCREAMING_SNAKE_CASE_ = make_linear_from_emb(model.model.shared )
SCREAMING_SNAKE_CASE_ = model.model(_lowerCAmelCase )[0]
# Check results
if fairseq_output.shape != new_model_outputs.shape:
raise ValueError(
F"`fairseq_output` shape and `new_model_output` shape are different: {fairseq_output.shape=}, {new_model_outputs.shape}" )
if (fairseq_output != new_model_outputs).any().item():
raise ValueError('''Some values in `fairseq_output` are different from `new_model_outputs`''' )
Path(_lowerCAmelCase ).mkdir(exist_ok=_lowerCAmelCase )
model.save_pretrained(_lowerCAmelCase )
if __name__ == "__main__":
__SCREAMING_SNAKE_CASE =argparse.ArgumentParser()
# Required parameters
parser.add_argument(
"""fairseq_path""", type=str, help="""bart.large, bart.large.cnn or a path to a model.pt on local filesystem."""
)
parser.add_argument("""pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
parser.add_argument(
"""--hf_config""", default=None, type=str, help="""Which huggingface architecture to use: bart-large-xsum"""
)
__SCREAMING_SNAKE_CASE =parser.parse_args()
convert_bart_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, hf_checkpoint_name=args.hf_config)
| 234
| 1
|
'''simple docstring'''
import json
import multiprocessing as mp
import re
from collections import defaultdict
from functools import partial
from typing import Dict, List, Optional, Set, Tuple, Type
from datasets import Dataset
from datasketch import MinHash, MinHashLSH
from dpu_utils.utils.iterators import ThreadedIterator
from tqdm import tqdm
__lowerCamelCase : Optional[int] = re.compile("""[^A-Za-z_0-9]""")
# parameters used in DuplicationIndex
__lowerCamelCase : str = 10
__lowerCamelCase : Optional[Any] = 256
def __snake_case (__UpperCAmelCase ):
"""simple docstring"""
if len(__A ) < MIN_NUM_TOKENS:
return None
lowerCamelCase_ : Union[str, Any] = MinHash(num_perm=__A )
for token in set(__A ):
min_hash.update(token.encode() )
return min_hash
def __snake_case (__UpperCAmelCase ):
"""simple docstring"""
return {t for t in NON_ALPHA.split(__A ) if len(t.strip() ) > 0}
class lowerCAmelCase__ :
def __init__( self : Tuple , *,
UpperCamelCase_ : float = 0.85 , ) -> List[Any]:
"""simple docstring"""
lowerCamelCase_ : Union[str, Any] = duplication_jaccard_threshold
lowerCamelCase_ : List[str] = NUM_PERM
lowerCamelCase_ : Any = MinHashLSH(threshold=self._duplication_jaccard_threshold , num_perm=self._num_perm )
lowerCamelCase_ : Tuple = defaultdict(_UpperCamelCase )
def __UpperCamelCase ( self : List[Any] , UpperCamelCase_ : Tuple , UpperCamelCase_ : MinHash ) -> None:
"""simple docstring"""
lowerCamelCase_ : List[str] = self._index.query(_UpperCamelCase )
if code_key in self._index.keys:
print(F"""Duplicate key {code_key}""" )
return
self._index.insert(_UpperCamelCase , _UpperCamelCase )
if len(_UpperCamelCase ) > 0:
for base_duplicate in close_duplicates:
if base_duplicate in self._duplicate_clusters:
self._duplicate_clusters[base_duplicate].add(_UpperCamelCase )
break
else:
self._duplicate_clusters[close_duplicates[0]].add(_UpperCamelCase )
def __UpperCamelCase ( self : int ) -> List[List[Dict]]:
"""simple docstring"""
lowerCamelCase_ : Tuple = []
for base, duplicates in self._duplicate_clusters.items():
lowerCamelCase_ : Optional[int] = [base] + list(_UpperCamelCase )
# reformat the cluster to be a list of dict
lowerCamelCase_ : Dict = [{"""base_index""": el[0], """repo_name""": el[1], """path""": el[2]} for el in cluster]
duplicate_clusters.append(_UpperCamelCase )
return duplicate_clusters
def __UpperCamelCase ( self : List[str] , UpperCamelCase_ : Union[str, Any] ) -> None:
"""simple docstring"""
lowerCamelCase_ : List[Any] = self.get_duplicate_clusters()
with open(_UpperCamelCase , '''w''' ) as f:
json.dump(_UpperCamelCase , _UpperCamelCase )
def __snake_case (__UpperCAmelCase ):
"""simple docstring"""
lowerCamelCase_ : List[str] = element
lowerCamelCase_ : Optional[Any] = get_min_hash([t for t in NON_ALPHA.split(data['''content'''] ) if len(t.strip() ) > 0] )
if min_hash is not None:
return (index, data["repo_name"], data["path"]), min_hash
def __snake_case (__UpperCAmelCase ):
"""simple docstring"""
with mp.Pool() as pool:
for data in pool.imap_unordered(
_compute_min_hash , ThreadedIterator(__A , max_queue_size=10000 ) , chunksize=100 , ):
if data is not None:
yield data
def __snake_case (__UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
lowerCamelCase_ : List[Any] = DuplicationIndex(duplication_jaccard_threshold=__A )
for filename, min_hash in tqdm(ThreadedIterator(minhash_iter(enumerate(__A ) ) , max_queue_size=100 ) ):
di.add(__A , __A )
# Returns a List[Cluster] where Cluster is List[str] with the filenames.
return di.get_duplicate_clusters()
def __snake_case (__UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
lowerCamelCase_ : Any = get_tokens(__A )
lowerCamelCase_ : Any = get_tokens(__A )
return len(tokensa & tokensa ) / len(tokensa | tokensa )
__lowerCamelCase : Optional[int] = None
def __snake_case (__UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
lowerCamelCase_ : Any = []
for elementa in cluster:
lowerCamelCase_ : Dict = _shared_dataset[elementa["""base_index"""]]["""content"""]
for elementa in extremes:
lowerCamelCase_ : Union[str, Any] = _shared_dataset[elementa["""base_index"""]]["""content"""]
if jaccard_similarity(__A , __A ) >= jaccard_threshold:
elementa["copies"] += 1
break
else:
lowerCamelCase_ : str = 1
extremes.append(__A )
return extremes
def __snake_case (__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
global _shared_dataset
lowerCamelCase_ : int = dataset
lowerCamelCase_ : str = []
lowerCamelCase_ : Optional[Any] = partial(_find_cluster_extremes_shared , jaccard_threshold=__A )
with mp.Pool() as pool:
for extremes in tqdm(
pool.imap_unordered(
__A , __A , ) , total=len(__A ) , ):
extremes_list.append(__A )
return extremes_list
def __snake_case (__UpperCAmelCase , __UpperCAmelCase = 0.85 ):
"""simple docstring"""
lowerCamelCase_ : Tuple = make_duplicate_clusters(__A , __A )
lowerCamelCase_ : Optional[int] = {x["""base_index"""] for cluster in duplicate_clusters for x in cluster}
lowerCamelCase_ : Optional[int] = {}
lowerCamelCase_ : Optional[int] = find_extremes(__A , __A , __A )
for extremes in extremes_clusters:
for element in extremes:
lowerCamelCase_ : Optional[Any] = element
lowerCamelCase_ : Any = duplicate_indices - set(extreme_dict.keys() )
lowerCamelCase_ : List[Any] = dataset.filter(lambda __UpperCAmelCase , __UpperCAmelCase : idx not in remove_indices , with_indices=__A )
# update duplicate_clusters
for cluster in duplicate_clusters:
for element in cluster:
lowerCamelCase_ : str = element["""base_index"""] in extreme_dict
if element["is_extreme"]:
lowerCamelCase_ : List[str] = extreme_dict[element["""base_index"""]]["""copies"""]
print(F"""Original dataset size: {len(__A )}""" )
print(F"""Number of duplicate clusters: {len(__A )}""" )
print(F"""Files in duplicate cluster: {len(__A )}""" )
print(F"""Unique files in duplicate cluster: {len(__A )}""" )
print(F"""Filtered dataset size: {len(__A )}""" )
return ds_filter, duplicate_clusters
| 715
|
'''simple docstring'''
from typing import Any, Dict, Optional
import torch
import torch.nn.functional as F
from torch import nn
from ..utils import maybe_allow_in_graph
from .activations import get_activation
from .attention_processor import Attention
from .embeddings import CombinedTimestepLabelEmbeddings
@maybe_allow_in_graph
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : int , UpperCamelCase_ : int , UpperCamelCase_ : int , UpperCamelCase_ : int , UpperCamelCase_ : Tuple=0.0 , UpperCamelCase_ : Optional[int] = None , UpperCamelCase_ : str = "geglu" , UpperCamelCase_ : Optional[int] = None , UpperCamelCase_ : bool = False , UpperCamelCase_ : bool = False , UpperCamelCase_ : bool = False , UpperCamelCase_ : bool = False , UpperCamelCase_ : bool = True , UpperCamelCase_ : str = "layer_norm" , UpperCamelCase_ : bool = False , ) -> Tuple:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : int = only_cross_attention
lowerCamelCase_ : Dict = (num_embeds_ada_norm is not None) and norm_type == '''ada_norm_zero'''
lowerCamelCase_ : Optional[int] = (num_embeds_ada_norm is not None) and norm_type == '''ada_norm'''
if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None:
raise ValueError(
F"""`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to"""
F""" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}.""" )
# Define 3 blocks. Each block has its own normalization layer.
# 1. Self-Attn
if self.use_ada_layer_norm:
lowerCamelCase_ : Optional[int] = AdaLayerNorm(UpperCamelCase_ , UpperCamelCase_ )
elif self.use_ada_layer_norm_zero:
lowerCamelCase_ : Tuple = AdaLayerNormZero(UpperCamelCase_ , UpperCamelCase_ )
else:
lowerCamelCase_ : Any = nn.LayerNorm(UpperCamelCase_ , elementwise_affine=UpperCamelCase_ )
lowerCamelCase_ : Tuple = Attention(
query_dim=UpperCamelCase_ , heads=UpperCamelCase_ , dim_head=UpperCamelCase_ , dropout=UpperCamelCase_ , bias=UpperCamelCase_ , cross_attention_dim=cross_attention_dim if only_cross_attention else None , upcast_attention=UpperCamelCase_ , )
# 2. Cross-Attn
if cross_attention_dim is not None or double_self_attention:
# We currently only use AdaLayerNormZero for self attention where there will only be one attention block.
# I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during
# the second cross attention block.
lowerCamelCase_ : List[str] = (
AdaLayerNorm(UpperCamelCase_ , UpperCamelCase_ )
if self.use_ada_layer_norm
else nn.LayerNorm(UpperCamelCase_ , elementwise_affine=UpperCamelCase_ )
)
lowerCamelCase_ : List[str] = Attention(
query_dim=UpperCamelCase_ , cross_attention_dim=cross_attention_dim if not double_self_attention else None , heads=UpperCamelCase_ , dim_head=UpperCamelCase_ , dropout=UpperCamelCase_ , bias=UpperCamelCase_ , upcast_attention=UpperCamelCase_ , ) # is self-attn if encoder_hidden_states is none
else:
lowerCamelCase_ : Optional[int] = None
lowerCamelCase_ : List[str] = None
# 3. Feed-forward
lowerCamelCase_ : Union[str, Any] = nn.LayerNorm(UpperCamelCase_ , elementwise_affine=UpperCamelCase_ )
lowerCamelCase_ : Optional[int] = FeedForward(UpperCamelCase_ , dropout=UpperCamelCase_ , activation_fn=UpperCamelCase_ , final_dropout=UpperCamelCase_ )
# let chunk size default to None
lowerCamelCase_ : int = None
lowerCamelCase_ : str = 0
def __UpperCamelCase ( self : Dict , UpperCamelCase_ : Optional[int] , UpperCamelCase_ : int ) -> str:
"""simple docstring"""
lowerCamelCase_ : int = chunk_size
lowerCamelCase_ : Dict = dim
def __UpperCamelCase ( self : List[str] , UpperCamelCase_ : torch.FloatTensor , UpperCamelCase_ : Optional[torch.FloatTensor] = None , UpperCamelCase_ : Optional[torch.FloatTensor] = None , UpperCamelCase_ : Optional[torch.FloatTensor] = None , UpperCamelCase_ : Optional[torch.LongTensor] = None , UpperCamelCase_ : Dict[str, Any] = None , UpperCamelCase_ : Optional[torch.LongTensor] = None , ) -> Dict:
"""simple docstring"""
if self.use_ada_layer_norm:
lowerCamelCase_ : int = self.norma(UpperCamelCase_ , UpperCamelCase_ )
elif self.use_ada_layer_norm_zero:
lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ : Any = self.norma(
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , hidden_dtype=hidden_states.dtype )
else:
lowerCamelCase_ : Optional[Any] = self.norma(UpperCamelCase_ )
lowerCamelCase_ : str = cross_attention_kwargs if cross_attention_kwargs is not None else {}
lowerCamelCase_ : int = self.attna(
UpperCamelCase_ , encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None , attention_mask=UpperCamelCase_ , **UpperCamelCase_ , )
if self.use_ada_layer_norm_zero:
lowerCamelCase_ : str = gate_msa.unsqueeze(1 ) * attn_output
lowerCamelCase_ : Tuple = attn_output + hidden_states
# 2. Cross-Attention
if self.attna is not None:
lowerCamelCase_ : List[Any] = (
self.norma(UpperCamelCase_ , UpperCamelCase_ ) if self.use_ada_layer_norm else self.norma(UpperCamelCase_ )
)
lowerCamelCase_ : Tuple = self.attna(
UpperCamelCase_ , encoder_hidden_states=UpperCamelCase_ , attention_mask=UpperCamelCase_ , **UpperCamelCase_ , )
lowerCamelCase_ : str = attn_output + hidden_states
# 3. Feed-forward
lowerCamelCase_ : Tuple = self.norma(UpperCamelCase_ )
if self.use_ada_layer_norm_zero:
lowerCamelCase_ : str = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]
if self._chunk_size is not None:
# "feed_forward_chunk_size" can be used to save memory
if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0:
raise ValueError(
F"""`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`.""" )
lowerCamelCase_ : Optional[Any] = norm_hidden_states.shape[self._chunk_dim] // self._chunk_size
lowerCamelCase_ : Optional[int] = torch.cat(
[self.ff(UpperCamelCase_ ) for hid_slice in norm_hidden_states.chunk(UpperCamelCase_ , dim=self._chunk_dim )] , dim=self._chunk_dim , )
else:
lowerCamelCase_ : Optional[Any] = self.ff(UpperCamelCase_ )
if self.use_ada_layer_norm_zero:
lowerCamelCase_ : List[str] = gate_mlp.unsqueeze(1 ) * ff_output
lowerCamelCase_ : Optional[int] = ff_output + hidden_states
return hidden_states
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : List[Any] , UpperCamelCase_ : int , UpperCamelCase_ : Optional[int] = None , UpperCamelCase_ : int = 4 , UpperCamelCase_ : float = 0.0 , UpperCamelCase_ : str = "geglu" , UpperCamelCase_ : bool = False , ) -> Dict:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : Tuple = int(dim * mult )
lowerCamelCase_ : List[Any] = dim_out if dim_out is not None else dim
if activation_fn == "gelu":
lowerCamelCase_ : Optional[int] = GELU(UpperCamelCase_ , UpperCamelCase_ )
if activation_fn == "gelu-approximate":
lowerCamelCase_ : Any = GELU(UpperCamelCase_ , UpperCamelCase_ , approximate='''tanh''' )
elif activation_fn == "geglu":
lowerCamelCase_ : Tuple = GEGLU(UpperCamelCase_ , UpperCamelCase_ )
elif activation_fn == "geglu-approximate":
lowerCamelCase_ : Union[str, Any] = ApproximateGELU(UpperCamelCase_ , UpperCamelCase_ )
lowerCamelCase_ : Any = nn.ModuleList([] )
# project in
self.net.append(UpperCamelCase_ )
# project dropout
self.net.append(nn.Dropout(UpperCamelCase_ ) )
# project out
self.net.append(nn.Linear(UpperCamelCase_ , UpperCamelCase_ ) )
# FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
if final_dropout:
self.net.append(nn.Dropout(UpperCamelCase_ ) )
def __UpperCamelCase ( self : List[Any] , UpperCamelCase_ : str ) -> Dict:
"""simple docstring"""
for module in self.net:
lowerCamelCase_ : Optional[int] = module(UpperCamelCase_ )
return hidden_states
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Optional[int] , UpperCamelCase_ : int , UpperCamelCase_ : int , UpperCamelCase_ : str = "none" ) -> int:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : List[str] = nn.Linear(UpperCamelCase_ , UpperCamelCase_ )
lowerCamelCase_ : int = approximate
def __UpperCamelCase ( self : Tuple , UpperCamelCase_ : Optional[int] ) -> Optional[Any]:
"""simple docstring"""
if gate.device.type != "mps":
return F.gelu(UpperCamelCase_ , approximate=self.approximate )
# mps: gelu is not implemented for float16
return F.gelu(gate.to(dtype=torch.floataa ) , approximate=self.approximate ).to(dtype=gate.dtype )
def __UpperCamelCase ( self : Optional[Any] , UpperCamelCase_ : Any ) -> Tuple:
"""simple docstring"""
lowerCamelCase_ : List[str] = self.proj(UpperCamelCase_ )
lowerCamelCase_ : int = self.gelu(UpperCamelCase_ )
return hidden_states
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Dict , UpperCamelCase_ : int , UpperCamelCase_ : int ) -> Any:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : Optional[Any] = nn.Linear(UpperCamelCase_ , dim_out * 2 )
def __UpperCamelCase ( self : Any , UpperCamelCase_ : Optional[int] ) -> List[str]:
"""simple docstring"""
if gate.device.type != "mps":
return F.gelu(UpperCamelCase_ )
# mps: gelu is not implemented for float16
return F.gelu(gate.to(dtype=torch.floataa ) ).to(dtype=gate.dtype )
def __UpperCamelCase ( self : Dict , UpperCamelCase_ : List[Any] ) -> Any:
"""simple docstring"""
lowerCamelCase_ , lowerCamelCase_ : int = self.proj(UpperCamelCase_ ).chunk(2 , dim=-1 )
return hidden_states * self.gelu(UpperCamelCase_ )
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Dict , UpperCamelCase_ : int , UpperCamelCase_ : int ) -> List[str]:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : List[Any] = nn.Linear(UpperCamelCase_ , UpperCamelCase_ )
def __UpperCamelCase ( self : List[Any] , UpperCamelCase_ : Union[str, Any] ) -> Optional[int]:
"""simple docstring"""
lowerCamelCase_ : List[Any] = self.proj(UpperCamelCase_ )
return x * torch.sigmoid(1.702 * x )
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Union[str, Any] , UpperCamelCase_ : Optional[int] , UpperCamelCase_ : List[str] ) -> str:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : Tuple = nn.Embedding(UpperCamelCase_ , UpperCamelCase_ )
lowerCamelCase_ : Tuple = nn.SiLU()
lowerCamelCase_ : List[str] = nn.Linear(UpperCamelCase_ , embedding_dim * 2 )
lowerCamelCase_ : List[Any] = nn.LayerNorm(UpperCamelCase_ , elementwise_affine=UpperCamelCase_ )
def __UpperCamelCase ( self : Tuple , UpperCamelCase_ : Dict , UpperCamelCase_ : Union[str, Any] ) -> Optional[Any]:
"""simple docstring"""
lowerCamelCase_ : Tuple = self.linear(self.silu(self.emb(UpperCamelCase_ ) ) )
lowerCamelCase_ , lowerCamelCase_ : Optional[int] = torch.chunk(UpperCamelCase_ , 2 )
lowerCamelCase_ : List[Any] = self.norm(UpperCamelCase_ ) * (1 + scale) + shift
return x
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Tuple , UpperCamelCase_ : List[Any] , UpperCamelCase_ : Optional[Any] ) -> Optional[Any]:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : Tuple = CombinedTimestepLabelEmbeddings(UpperCamelCase_ , UpperCamelCase_ )
lowerCamelCase_ : List[Any] = nn.SiLU()
lowerCamelCase_ : str = nn.Linear(UpperCamelCase_ , 6 * embedding_dim , bias=UpperCamelCase_ )
lowerCamelCase_ : Dict = nn.LayerNorm(UpperCamelCase_ , elementwise_affine=UpperCamelCase_ , eps=1e-6 )
def __UpperCamelCase ( self : Tuple , UpperCamelCase_ : Any , UpperCamelCase_ : Optional[Any] , UpperCamelCase_ : Any , UpperCamelCase_ : int=None ) -> Any:
"""simple docstring"""
lowerCamelCase_ : Optional[Any] = self.linear(self.silu(self.emb(UpperCamelCase_ , UpperCamelCase_ , hidden_dtype=UpperCamelCase_ ) ) )
lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ : Union[str, Any] = emb.chunk(6 , dim=1 )
lowerCamelCase_ : Tuple = self.norm(UpperCamelCase_ ) * (1 + scale_msa[:, None]) + shift_msa[:, None]
return x, gate_msa, shift_mlp, scale_mlp, gate_mlp
class lowerCAmelCase__ ( nn.Module ):
def __init__( self : Optional[int] , UpperCamelCase_ : int , UpperCamelCase_ : int , UpperCamelCase_ : int , UpperCamelCase_ : Optional[str] = None , UpperCamelCase_ : float = 1e-5 ) -> Tuple:
"""simple docstring"""
super().__init__()
lowerCamelCase_ : str = num_groups
lowerCamelCase_ : List[Any] = eps
if act_fn is None:
lowerCamelCase_ : Any = None
else:
lowerCamelCase_ : List[str] = get_activation(UpperCamelCase_ )
lowerCamelCase_ : Optional[Any] = nn.Linear(UpperCamelCase_ , out_dim * 2 )
def __UpperCamelCase ( self : Optional[Any] , UpperCamelCase_ : Optional[Any] , UpperCamelCase_ : Optional[Any] ) -> Optional[int]:
"""simple docstring"""
if self.act:
lowerCamelCase_ : Optional[int] = self.act(UpperCamelCase_ )
lowerCamelCase_ : Optional[int] = self.linear(UpperCamelCase_ )
lowerCamelCase_ : List[str] = emb[:, :, None, None]
lowerCamelCase_ , lowerCamelCase_ : int = emb.chunk(2 , dim=1 )
lowerCamelCase_ : List[str] = F.group_norm(UpperCamelCase_ , self.num_groups , eps=self.eps )
lowerCamelCase_ : Optional[Any] = x * (1 + scale) + shift
return x
| 418
| 0
|
from typing import TYPE_CHECKING
from ...utils import _LazyModule
lowerCamelCase : Dict = {'''tokenization_wav2vec2_phoneme''': ['''Wav2Vec2PhonemeCTCTokenizer''']}
if TYPE_CHECKING:
from .tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizer
else:
import sys
lowerCamelCase : Optional[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 149
|
import os
from shutil import copyfile
from typing import List, Optional, Tuple
from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging
if is_sentencepiece_available():
from .tokenization_xlnet import XLNetTokenizer
else:
lowerCamelCase : str = None
lowerCamelCase : str = logging.get_logger(__name__)
lowerCamelCase : int = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''}
lowerCamelCase : Optional[Any] = {
'''vocab_file''': {
'''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''',
'''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''',
},
'''tokenizer_file''': {
'''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/tokenizer.json''',
'''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/tokenizer.json''',
},
}
lowerCamelCase : List[Any] = {
'''xlnet-base-cased''': None,
'''xlnet-large-cased''': None,
}
lowerCamelCase : Union[str, Any] = '''▁'''
# Segments (not really needed)
lowerCamelCase : Optional[Any] = 0
lowerCamelCase : Optional[Any] = 1
lowerCamelCase : List[Any] = 2
lowerCamelCase : List[Any] = 3
lowerCamelCase : Dict = 4
class lowerCAmelCase ( __a ):
'''simple docstring'''
_A : Union[str, Any] = VOCAB_FILES_NAMES
_A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP
_A : str = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_A : Any = '''left'''
_A : List[str] = XLNetTokenizer
def __init__( self : int , __a : Union[str, Any]=None , __a : Optional[int]=None , __a : List[Any]=False , __a : Tuple=True , __a : Tuple=False , __a : List[str]="<s>" , __a : int="</s>" , __a : Optional[int]="<unk>" , __a : Any="<sep>" , __a : Dict="<pad>" , __a : str="<cls>" , __a : List[str]="<mask>" , __a : Optional[int]=["<eop>", "<eod>"] , **__a : Any , ) -> Optional[int]:
"""simple docstring"""
__lowercase : Tuple = AddedToken(__a , lstrip=__a , rstrip=__a ) if isinstance(__a , __a ) else mask_token
super().__init__(
vocab_file=__a , tokenizer_file=__a , do_lower_case=__a , remove_space=__a , keep_accents=__a , bos_token=__a , eos_token=__a , unk_token=__a , sep_token=__a , pad_token=__a , cls_token=__a , mask_token=__a , additional_special_tokens=__a , **__a , )
__lowercase : str = 3
__lowercase : Optional[Any] = do_lower_case
__lowercase : Union[str, Any] = remove_space
__lowercase : List[str] = keep_accents
__lowercase : Optional[Any] = vocab_file
__lowercase : Union[str, Any] = False if not self.vocab_file else True
def lowerCAmelCase ( self : Union[str, Any] , __a : List[int] , __a : Optional[List[int]] = None ) -> List[int]:
"""simple docstring"""
__lowercase : Union[str, Any] = [self.sep_token_id]
__lowercase : Any = [self.cls_token_id]
if token_ids_a is None:
return token_ids_a + sep + cls
return token_ids_a + sep + token_ids_a + sep + cls
def lowerCAmelCase ( self : Any , __a : List[int] , __a : Optional[List[int]] = None ) -> List[int]:
"""simple docstring"""
__lowercase : Dict = [self.sep_token_id]
__lowercase : int = [2]
if token_ids_a is None:
return len(token_ids_a + sep ) * [0] + cls_segment_id
return len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] + cls_segment_id
def lowerCAmelCase ( self : Optional[int] , __a : str , __a : Optional[str] = None ) -> Tuple[str]:
"""simple docstring"""
if not self.can_save_slow_tokenizer:
raise ValueError(
"""Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
"""tokenizer.""" )
if not os.path.isdir(__a ):
logger.error(F"Vocabulary path ({save_directory}) should be a directory" )
return
__lowercase : List[Any] = os.path.join(
__a , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(__a ):
copyfile(self.vocab_file , __a )
return (out_vocab_file,)
| 149
| 1
|
'''simple docstring'''
import os
from bleurt import score # From: git+https://github.com/google-research/bleurt.git
import datasets
__SCREAMING_SNAKE_CASE : Optional[int] = datasets.logging.get_logger(__name__)
__SCREAMING_SNAKE_CASE : int = """\
@inproceedings{bleurt,
title={BLEURT: Learning Robust Metrics for Text Generation},
author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh},
booktitle={ACL},
year={2020},
url={https://arxiv.org/abs/2004.04696}
}
"""
__SCREAMING_SNAKE_CASE : List[str] = """\
BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018)
and then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune
it for your specific application (the latter is expected to perform better).
See the project's README at https://github.com/google-research/bleurt#readme for more information.
"""
__SCREAMING_SNAKE_CASE : Optional[Any] = """
BLEURT score.
Args:
`predictions` (list of str): prediction/candidate sentences
`references` (list of str): reference sentences
`checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None.
Returns:
'scores': List of scores.
Examples:
>>> predictions = [\"hello there\", \"general kenobi\"]
>>> references = [\"hello there\", \"general kenobi\"]
>>> bleurt = datasets.load_metric(\"bleurt\")
>>> results = bleurt.compute(predictions=predictions, references=references)
>>> print([round(v, 2) for v in results[\"scores\"]])
[1.03, 1.04]
"""
__SCREAMING_SNAKE_CASE : str = {
"""bleurt-tiny-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip""",
"""bleurt-tiny-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip""",
"""bleurt-base-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip""",
"""bleurt-base-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip""",
"""bleurt-large-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip""",
"""bleurt-large-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip""",
"""BLEURT-20-D3""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip""",
"""BLEURT-20-D6""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip""",
"""BLEURT-20-D12""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip""",
"""BLEURT-20""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip""",
}
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class SCREAMING_SNAKE_CASE__ ( datasets.Metric ):
def __lowerCamelCase ( self ):
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , homepage="""https://github.com/google-research/bleurt""" , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(
{
"""predictions""": datasets.Value("""string""" , id="""sequence""" ),
"""references""": datasets.Value("""string""" , id="""sequence""" ),
} ) , codebase_urls=["""https://github.com/google-research/bleurt"""] , reference_urls=["""https://github.com/google-research/bleurt""", """https://arxiv.org/abs/2004.04696"""] , )
def __lowerCamelCase ( self , __UpperCamelCase ):
'''simple docstring'''
if self.config_name == "default":
logger.warning(
"""Using default BLEURT-Base checkpoint for sequence maximum length 128. """
"""You can use a bigger model for better results with e.g.: datasets.load_metric('bleurt', 'bleurt-large-512').""" )
__a : Any = """bleurt-base-128"""
if self.config_name.lower() in CHECKPOINT_URLS:
__a : List[Any] = self.config_name.lower()
elif self.config_name.upper() in CHECKPOINT_URLS:
__a : Optional[int] = self.config_name.upper()
else:
raise KeyError(
f"""{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}""" )
# download the model checkpoint specified by self.config_name and set up the scorer
__a : Optional[int] = dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name] )
__a : List[Any] = score.BleurtScorer(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) )
def __lowerCamelCase ( self , __UpperCamelCase , __UpperCamelCase ):
'''simple docstring'''
__a : Tuple = self.scorer.score(references=_lowerCAmelCase , candidates=_lowerCAmelCase )
return {"scores": scores}
| 709
|
'''simple docstring'''
import os
from itertools import chain
from random import randrange, shuffle
import pytest
from .sola import PokerHand
__SCREAMING_SNAKE_CASE : List[str] = (
'4S 3H 2C 7S 5H',
'9D 8H 2C 6S 7H',
'2D 6D 9D TH 7D',
'TC 8C 2S JH 6C',
'JH 8S TH AH QH',
'TS KS 5S 9S AC',
'KD 6S 9D TH AD',
'KS 8D 4D 9S 4S', # pair
'8C 4S KH JS 4D', # pair
'QH 8H KD JH 8S', # pair
'KC 4H KS 2H 8D', # pair
'KD 4S KC 3H 8S', # pair
'AH 8S AS KC JH', # pair
'3H 4C 4H 3S 2H', # 2 pairs
'5S 5D 2C KH KH', # 2 pairs
'3C KH 5D 5S KH', # 2 pairs
'AS 3C KH AD KH', # 2 pairs
'7C 7S 3S 7H 5S', # 3 of a kind
'7C 7S KH 2H 7H', # 3 of a kind
'AC KH QH AH AS', # 3 of a kind
'2H 4D 3C AS 5S', # straight (low ace)
'3C 5C 4C 2C 6H', # straight
'6S 8S 7S 5H 9H', # straight
'JS QS 9H TS KH', # straight
'QC KH TS JS AH', # straight (high ace)
'8C 9C 5C 3C TC', # flush
'3S 8S 9S 5S KS', # flush
'4C 5C 9C 8C KC', # flush
'JH 8H AH KH QH', # flush
'3D 2H 3H 2C 2D', # full house
'2H 2C 3S 3H 3D', # full house
'KH KC 3S 3H 3D', # full house
'JC 6H JS JD JH', # 4 of a kind
'JC 7H JS JD JH', # 4 of a kind
'JC KH JS JD JH', # 4 of a kind
'2S AS 4S 5S 3S', # straight flush (low ace)
'2D 6D 3D 4D 5D', # straight flush
'5C 6C 3C 7C 4C', # straight flush
'JH 9H TH KH QH', # straight flush
'JH AH TH KH QH', # royal flush (high ace straight flush)
)
__SCREAMING_SNAKE_CASE : Optional[Any] = (
('2H 3H 4H 5H 6H', 'KS AS TS QS JS', 'Loss'),
('2H 3H 4H 5H 6H', 'AS AD AC AH JD', 'Win'),
('AS AH 2H AD AC', 'JS JD JC JH 3D', 'Win'),
('2S AH 2H AS AC', 'JS JD JC JH AD', 'Loss'),
('2S AH 2H AS AC', '2H 3H 5H 6H 7H', 'Win'),
('AS 3S 4S 8S 2S', '2H 3H 5H 6H 7H', 'Win'),
('2H 3H 5H 6H 7H', '2S 3H 4H 5S 6C', 'Win'),
('2S 3H 4H 5S 6C', '3D 4C 5H 6H 2S', 'Tie'),
('2S 3H 4H 5S 6C', 'AH AC 5H 6H AS', 'Win'),
('2S 2H 4H 5S 4C', 'AH AC 5H 6H AS', 'Loss'),
('2S 2H 4H 5S 4C', 'AH AC 5H 6H 7S', 'Win'),
('6S AD 7H 4S AS', 'AH AC 5H 6H 7S', 'Loss'),
('2S AH 4H 5S KC', 'AH AC 5H 6H 7S', 'Loss'),
('2S 3H 6H 7S 9C', '7H 3C TH 6H 9S', 'Loss'),
('4S 5H 6H TS AC', '3S 5H 6H TS AC', 'Win'),
('2S AH 4H 5S 6C', 'AD 4C 5H 6H 2C', 'Tie'),
('AS AH 3H AD AC', 'AS AH 2H AD AC', 'Win'),
('AH AC 5H 5C QS', 'AH AC 5H 5C KS', 'Loss'),
('AH AC 5H 5C QS', 'KH KC 5H 5C QS', 'Win'),
('7C 7S KH 2H 7H', '3C 3S AH 2H 3H', 'Win'),
('3C 3S AH 2H 3H', '7C 7S KH 2H 7H', 'Loss'),
('6H 5H 4H 3H 2H', '5H 4H 3H 2H AH', 'Win'),
('5H 4H 3H 2H AH', '5H 4H 3H 2H AH', 'Tie'),
('5H 4H 3H 2H AH', '6H 5H 4H 3H 2H', 'Loss'),
('AH AD KS KC AC', 'AH KD KH AC KC', 'Win'),
('2H 4D 3C AS 5S', '2H 4D 3C 6S 5S', 'Loss'),
('2H 3S 3C 3H 2S', '3S 3C 2S 2H 2D', 'Win'),
('4D 6D 5D 2D JH', '3S 8S 3H TC KH', 'Loss'),
('4S 6C 8S 3S 7S', 'AD KS 2D 7D 7C', 'Loss'),
('6S 4C 7H 8C 3H', '5H JC AH 9D 9C', 'Loss'),
('9D 9H JH TC QH', '3C 2S JS 5C 7H', 'Win'),
('2H TC 8S AD 9S', '4H TS 7H 2C 5C', 'Win'),
('9D 3S 2C 7S 7C', 'JC TD 3C TC 9H', 'Loss'),
)
__SCREAMING_SNAKE_CASE : Tuple = (
('2H 3H 4H 5H 6H', True),
('AS AH 2H AD AC', False),
('2H 3H 5H 6H 7H', True),
('KS AS TS QS JS', True),
('8H 9H QS JS TH', False),
('AS 3S 4S 8S 2S', True),
)
__SCREAMING_SNAKE_CASE : Dict = (
('2H 3H 4H 5H 6H', True),
('AS AH 2H AD AC', False),
('2H 3H 5H 6H 7H', False),
('KS AS TS QS JS', True),
('8H 9H QS JS TH', True),
)
__SCREAMING_SNAKE_CASE : Optional[int] = (
('2H 4D 3C AS 5S', True, [5, 4, 3, 2, 14]),
('2H 5D 3C AS 5S', False, [14, 5, 5, 3, 2]),
('JH QD KC AS TS', False, [14, 13, 12, 11, 10]),
('9D 3S 2C 7S 7C', False, [9, 7, 7, 3, 2]),
)
__SCREAMING_SNAKE_CASE : int = (
('JH AH TH KH QH', 0),
('JH 9H TH KH QH', 0),
('JC KH JS JD JH', 7),
('KH KC 3S 3H 3D', 6),
('8C 9C 5C 3C TC', 0),
('JS QS 9H TS KH', 0),
('7C 7S KH 2H 7H', 3),
('3C KH 5D 5S KH', 2),
('QH 8H KD JH 8S', 1),
('2D 6D 9D TH 7D', 0),
)
__SCREAMING_SNAKE_CASE : int = (
('JH AH TH KH QH', 23),
('JH 9H TH KH QH', 22),
('JC KH JS JD JH', 21),
('KH KC 3S 3H 3D', 20),
('8C 9C 5C 3C TC', 19),
('JS QS 9H TS KH', 18),
('7C 7S KH 2H 7H', 17),
('3C KH 5D 5S KH', 16),
('QH 8H KD JH 8S', 15),
('2D 6D 9D TH 7D', 14),
)
def _snake_case ( ) -> List[str]:
__a , __a : List[Any] = randrange(len(lowercase ) ), randrange(len(lowercase ) )
__a : int = ["""Loss""", """Tie""", """Win"""][(play >= oppo) + (play > oppo)]
__a , __a : int = SORTED_HANDS[play], SORTED_HANDS[oppo]
return hand, other, expected
def _snake_case ( lowercase = 1_0_0 ) -> Any:
return (generate_random_hand() for _ in range(lowercase ))
@pytest.mark.parametrize("""hand, expected""" , lowercase )
def _snake_case ( lowercase , lowercase ) -> int:
assert PokerHand(lowercase )._is_flush() == expected
@pytest.mark.parametrize("""hand, expected""" , lowercase )
def _snake_case ( lowercase , lowercase ) -> Any:
assert PokerHand(lowercase )._is_straight() == expected
@pytest.mark.parametrize("""hand, expected, card_values""" , lowercase )
def _snake_case ( lowercase , lowercase , lowercase ) -> List[str]:
__a : Union[str, Any] = PokerHand(lowercase )
assert player._is_five_high_straight() == expected
assert player._card_values == card_values
@pytest.mark.parametrize("""hand, expected""" , lowercase )
def _snake_case ( lowercase , lowercase ) -> Optional[int]:
assert PokerHand(lowercase )._is_same_kind() == expected
@pytest.mark.parametrize("""hand, expected""" , lowercase )
def _snake_case ( lowercase , lowercase ) -> Union[str, Any]:
assert PokerHand(lowercase )._hand_type == expected
@pytest.mark.parametrize("""hand, other, expected""" , lowercase )
def _snake_case ( lowercase , lowercase , lowercase ) -> Optional[int]:
assert PokerHand(lowercase ).compare_with(PokerHand(lowercase ) ) == expected
@pytest.mark.parametrize("""hand, other, expected""" , generate_random_hands() )
def _snake_case ( lowercase , lowercase , lowercase ) -> int:
assert PokerHand(lowercase ).compare_with(PokerHand(lowercase ) ) == expected
def _snake_case ( ) -> Union[str, Any]:
__a : Tuple = [PokerHand(lowercase ) for hand in SORTED_HANDS]
__a : Optional[int] = poker_hands.copy()
shuffle(lowercase )
__a : List[str] = chain(sorted(lowercase ) )
for index, hand in enumerate(lowercase ):
assert hand == poker_hands[index]
def _snake_case ( ) -> List[str]:
# Test that five high straights are compared correctly.
__a : Optional[int] = [PokerHand("""2D AC 3H 4H 5S""" ), PokerHand("""2S 3H 4H 5S 6C""" )]
pokerhands.sort(reverse=lowercase )
assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"
def _snake_case ( ) -> List[str]:
# Multiple calls to five_high_straight function should still return True
# and shouldn't mutate the list in every call other than the first.
__a : Dict = PokerHand("""2C 4S AS 3D 5C""" )
__a : Dict = True
__a : Optional[int] = [5, 4, 3, 2, 1_4]
for _ in range(1_0 ):
assert pokerhand._is_five_high_straight() == expected
assert pokerhand._card_values == expected_card_values
def _snake_case ( ) -> Dict:
# Problem number 54 from Project Euler
# Testing from poker_hands.txt file
__a : Tuple = 0
__a : int = os.path.abspath(os.path.dirname(lowercase ) )
__a : Union[str, Any] = os.path.join(lowercase , """poker_hands.txt""" )
with open(lowercase ) as file_hand:
for line in file_hand:
__a : Union[str, Any] = line[:1_4].strip()
__a : Optional[Any] = line[1_5:].strip()
__a , __a : List[str] = PokerHand(lowercase ), PokerHand(lowercase )
__a : str = player.compare_with(lowercase )
if output == "Win":
answer += 1
assert answer == 3_7_6
| 697
| 0
|
"""simple docstring"""
import importlib.metadata
import operator
import re
import sys
from typing import Optional
from packaging import version
A = {
"""<""": operator.lt,
"""<=""": operator.le,
"""==""": operator.eq,
"""!=""": operator.ne,
""">=""": operator.ge,
""">""": operator.gt,
}
def _UpperCamelCase ( UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ) -> int:
"""simple docstring"""
if got_ver is None or want_ver is None:
raise ValueError(
f"Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"
f" reinstalling {pkg}." )
if not ops[op](version.parse(__a ) , version.parse(__a ) ):
raise ImportError(
f"{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}" )
def _UpperCamelCase ( UpperCamelCase , UpperCamelCase = None ) -> None:
"""simple docstring"""
__UpperCAmelCase : Optional[int] = f"\n{hint}" if hint is not None else ""
# non-versioned check
if re.match(R"^[\w_\-\d]+$" , __a ):
__UpperCAmelCase : Dict = requirement, None, None
else:
__UpperCAmelCase : Any = re.findall(R"^([^!=<>\s]+)([\s!=<>]{1,2}.+)" , __a )
if not match:
raise ValueError(
"requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but"
f" got {requirement}" )
__UpperCAmelCase : Optional[Any] = match[0]
__UpperCAmelCase : str = want_full.split("," ) # there could be multiple requirements
__UpperCAmelCase : Tuple = {}
for w in want_range:
__UpperCAmelCase : List[Any] = re.findall(R"^([\s!=<>]{1,2})(.+)" , __a )
if not match:
raise ValueError(
"requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,"
f" but got {requirement}" )
__UpperCAmelCase : Tuple = match[0]
__UpperCAmelCase : Optional[int] = want_ver
if op not in ops:
raise ValueError(f"{requirement}: need one of {list(ops.keys() )}, but got {op}" )
# special case
if pkg == "python":
__UpperCAmelCase : Union[str, Any] = ".".join([str(__a ) for x in sys.version_info[:3]] )
for op, want_ver in wanted.items():
_compare_versions(__a , __a , __a , __a , __a , __a )
return
# check if any version is installed
try:
__UpperCAmelCase : Optional[int] = importlib.metadata.version(__a )
except importlib.metadata.PackageNotFoundError:
raise importlib.metadata.PackageNotFoundError(
f"The \'{requirement}\' distribution was not found and is required by this application. {hint}" )
# check that the right version is installed if version number or a range was provided
if want_ver is not None:
for op, want_ver in wanted.items():
_compare_versions(__a , __a , __a , __a , __a , __a )
def _UpperCamelCase ( UpperCamelCase ) -> str:
"""simple docstring"""
__UpperCAmelCase : Dict = "Try: pip install transformers -U or pip install -e '.[dev]' if you're working with git main"
return require_version(__a , __a )
| 77
|
import inspect
import unittest
from datasets import load_dataset
from packaging import version
from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from torch import nn
from transformers import (
MODEL_MAPPING,
BeitForImageClassification,
BeitForMaskedImageModeling,
BeitForSemanticSegmentation,
BeitModel,
)
from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
import PIL
from PIL import Image
from transformers import BeitImageProcessor
class A__ :
"""simple docstring"""
def __init__( self : Optional[int] , lowerCamelCase__ : List[Any] , lowerCamelCase__ : Optional[int]=100 , lowerCamelCase__ : str=13 , lowerCamelCase__ : Optional[int]=30 , lowerCamelCase__ : Union[str, Any]=2 , lowerCamelCase__ : Tuple=3 , lowerCamelCase__ : List[Any]=True , lowerCamelCase__ : Tuple=True , lowerCamelCase__ : int=32 , lowerCamelCase__ : Union[str, Any]=4 , lowerCamelCase__ : Dict=4 , lowerCamelCase__ : Union[str, Any]=37 , lowerCamelCase__ : List[Any]="gelu" , lowerCamelCase__ : List[Any]=0.1 , lowerCamelCase__ : int=0.1 , lowerCamelCase__ : Union[str, Any]=10 , lowerCamelCase__ : str=0.02 , lowerCamelCase__ : Tuple=3 , lowerCamelCase__ : Dict=None , lowerCamelCase__ : List[str]=[0, 1, 2, 3] , ):
a__ : Dict = parent
a__ : Dict = 100
a__ : Optional[int] = batch_size
a__ : Union[str, Any] = image_size
a__ : Any = patch_size
a__ : Optional[Any] = num_channels
a__ : int = is_training
a__ : List[str] = use_labels
a__ : Optional[Any] = hidden_size
a__ : List[Any] = num_hidden_layers
a__ : str = num_attention_heads
a__ : str = intermediate_size
a__ : int = hidden_act
a__ : List[Any] = hidden_dropout_prob
a__ : Dict = attention_probs_dropout_prob
a__ : Union[str, Any] = type_sequence_label_size
a__ : Optional[Any] = initializer_range
a__ : List[str] = scope
a__ : int = out_indices
a__ : List[str] = num_labels
# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
a__ : Optional[int] = (image_size // patch_size) ** 2
a__ : Union[str, Any] = num_patches + 1
def _UpperCamelCase( self : int ):
a__ : Optional[int] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
a__ : Optional[Any] = None
a__ : Tuple = None
if self.use_labels:
a__ : str = ids_tensor([self.batch_size] , self.type_sequence_label_size )
a__ : Dict = ids_tensor([self.batch_size, self.image_size, self.image_size] , self.num_labels )
a__ : Optional[int] = self.get_config()
return config, pixel_values, labels, pixel_labels
def _UpperCamelCase( self : Tuple ):
return BeitConfig(
vocab_size=self.vocab_size , image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=lowerCamelCase__ , initializer_range=self.initializer_range , out_indices=self.out_indices , )
def _UpperCamelCase( self : Dict , lowerCamelCase__ : int , lowerCamelCase__ : Union[str, Any] , lowerCamelCase__ : int , lowerCamelCase__ : Any ):
a__ : str = BeitModel(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
a__ : List[str] = model(lowerCamelCase__ )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def _UpperCamelCase( self : Tuple , lowerCamelCase__ : List[str] , lowerCamelCase__ : Any , lowerCamelCase__ : List[str] , lowerCamelCase__ : Tuple ):
a__ : int = BeitForMaskedImageModeling(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
a__ : List[Any] = model(lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length - 1, self.vocab_size) )
def _UpperCamelCase( self : str , lowerCamelCase__ : Any , lowerCamelCase__ : str , lowerCamelCase__ : Optional[int] , lowerCamelCase__ : Any ):
a__ : List[str] = self.type_sequence_label_size
a__ : Optional[Any] = BeitForImageClassification(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
a__ : str = model(lowerCamelCase__ , labels=lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) )
# test greyscale images
a__ : Optional[Any] = 1
a__ : List[str] = BeitForImageClassification(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
a__ : List[str] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
a__ : Union[str, Any] = model(lowerCamelCase__ , labels=lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) )
def _UpperCamelCase( self : Any , lowerCamelCase__ : str , lowerCamelCase__ : List[Any] , lowerCamelCase__ : Any , lowerCamelCase__ : Dict ):
a__ : int = self.num_labels
a__ : List[str] = BeitForSemanticSegmentation(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
a__ : Tuple = model(lowerCamelCase__ )
self.parent.assertEqual(
result.logits.shape , (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )
a__ : str = model(lowerCamelCase__ , labels=lowerCamelCase__ )
self.parent.assertEqual(
result.logits.shape , (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )
def _UpperCamelCase( self : Optional[int] ):
a__ : Any = self.prepare_config_and_inputs()
a__, a__, a__, a__ : Union[str, Any] = config_and_inputs
a__ : Dict = {"pixel_values": pixel_values}
return config, inputs_dict
@require_torch
class A__ ( A__ , A__ , unittest.TestCase ):
"""simple docstring"""
_lowercase = (
(BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
if is_torch_available()
else ()
)
_lowercase = (
{
'feature-extraction': BeitModel,
'image-classification': BeitForImageClassification,
'image-segmentation': BeitForSemanticSegmentation,
}
if is_torch_available()
else {}
)
_lowercase = False
_lowercase = False
_lowercase = False
def _UpperCamelCase( self : Any ):
a__ : int = BeitModelTester(self )
a__ : Optional[Any] = ConfigTester(self , config_class=lowerCamelCase__ , has_text_modality=lowerCamelCase__ , hidden_size=37 )
def _UpperCamelCase( self : List[Any] ):
self.config_tester.run_common_tests()
@unittest.skip(reason="BEiT does not use inputs_embeds" )
def _UpperCamelCase( self : str ):
pass
@require_torch_multi_gpu
@unittest.skip(reason="BEiT has some layers using `add_module` which doesn't work well with `nn.DataParallel`" )
def _UpperCamelCase( self : Dict ):
pass
def _UpperCamelCase( self : Optional[Any] ):
a__, a__ : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
a__ : List[str] = model_class(lowerCamelCase__ )
self.assertIsInstance(model.get_input_embeddings() , (nn.Module) )
a__ : Optional[int] = model.get_output_embeddings()
self.assertTrue(x is None or isinstance(lowerCamelCase__ , nn.Linear ) )
def _UpperCamelCase( self : str ):
a__, a__ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
a__ : int = model_class(lowerCamelCase__ )
a__ : str = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
a__ : Optional[int] = [*signature.parameters.keys()]
a__ : Any = ["pixel_values"]
self.assertListEqual(arg_names[:1] , lowerCamelCase__ )
def _UpperCamelCase( self : List[Any] ):
a__ : Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowerCamelCase__ )
def _UpperCamelCase( self : int ):
a__ : int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__ )
def _UpperCamelCase( self : List[Any] ):
a__ : Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__ )
def _UpperCamelCase( self : Optional[int] ):
a__ : Union[str, Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase__ )
def _UpperCamelCase( self : Optional[Any] ):
if not self.model_tester.is_training:
return
a__, a__ : Tuple = self.model_tester.prepare_config_and_inputs_for_common()
a__ : str = True
for model_class in self.all_model_classes:
# we don't test BeitForMaskedImageModeling
if model_class in [*get_values(lowerCamelCase__ ), BeitForMaskedImageModeling]:
continue
a__ : List[str] = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.train()
a__ : Any = self._prepare_for_class(lowerCamelCase__ , lowerCamelCase__ , return_labels=lowerCamelCase__ )
a__ : Tuple = model(**lowerCamelCase__ ).loss
loss.backward()
def _UpperCamelCase( self : Tuple ):
a__, a__ : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common()
if not self.model_tester.is_training:
return
a__ : List[Any] = False
a__ : List[str] = True
for model_class in self.all_model_classes:
# we don't test BeitForMaskedImageModeling
if (
model_class in [*get_values(lowerCamelCase__ ), BeitForMaskedImageModeling]
or not model_class.supports_gradient_checkpointing
):
continue
a__ : Optional[Any] = model_class(lowerCamelCase__ )
model.gradient_checkpointing_enable()
model.to(lowerCamelCase__ )
model.train()
a__ : Union[str, Any] = self._prepare_for_class(lowerCamelCase__ , lowerCamelCase__ , return_labels=lowerCamelCase__ )
a__ : int = model(**lowerCamelCase__ ).loss
loss.backward()
def _UpperCamelCase( self : List[str] ):
a__, a__ : Tuple = self.model_tester.prepare_config_and_inputs_for_common()
a__ : Dict = _config_zero_init(lowerCamelCase__ )
for model_class in self.all_model_classes:
a__ : str = model_class(config=lowerCamelCase__ )
for name, param in model.named_parameters():
# we skip lambda parameters as these require special initial values
# determined by config.layer_scale_init_value
if "lambda" in name:
continue
if param.requires_grad:
self.assertIn(
((param.data.mean() * 1E9).round() / 1E9).item() , [0.0, 1.0] , msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' , )
@slow
def _UpperCamelCase( self : Optional[int] ):
for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
a__ : Tuple = BeitModel.from_pretrained(lowerCamelCase__ )
self.assertIsNotNone(lowerCamelCase__ )
def UpperCamelCase_ ( ) -> Any:
a__ : List[Any] = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
return image
@require_torch
@require_vision
class A__ ( unittest.TestCase ):
"""simple docstring"""
@cached_property
def _UpperCamelCase( self : Optional[int] ):
return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224" ) if is_vision_available() else None
@slow
def _UpperCamelCase( self : str ):
a__ : int = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k" ).to(lowerCamelCase__ )
a__ : Optional[Any] = self.default_image_processor
a__ : Dict = prepare_img()
a__ : Optional[int] = image_processor(images=lowerCamelCase__ , return_tensors="pt" ).pixel_values.to(lowerCamelCase__ )
# prepare bool_masked_pos
a__ : Optional[Any] = torch.ones((1, 196) , dtype=torch.bool ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
a__ : Any = model(pixel_values=lowerCamelCase__ , bool_masked_pos=lowerCamelCase__ )
a__ : Tuple = outputs.logits
# verify the logits
a__ : List[str] = torch.Size((1, 196, 8_192) )
self.assertEqual(logits.shape , lowerCamelCase__ )
a__ : Optional[int] = torch.tensor(
[[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3] , lowerCamelCase__ , atol=1E-2 ) )
@slow
def _UpperCamelCase( self : Dict ):
a__ : str = BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224" ).to(lowerCamelCase__ )
a__ : int = self.default_image_processor
a__ : List[Any] = prepare_img()
a__ : Tuple = image_processor(images=lowerCamelCase__ , return_tensors="pt" ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
a__ : Union[str, Any] = model(**lowerCamelCase__ )
a__ : List[str] = outputs.logits
# verify the logits
a__ : Union[str, Any] = torch.Size((1, 1_000) )
self.assertEqual(logits.shape , lowerCamelCase__ )
a__ : int = torch.tensor([-1.2385, -1.0987, -1.0108] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(logits[0, :3] , lowerCamelCase__ , atol=1E-4 ) )
a__ : Tuple = 281
self.assertEqual(logits.argmax(-1 ).item() , lowerCamelCase__ )
@slow
def _UpperCamelCase( self : Any ):
a__ : Dict = BeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k" ).to(
lowerCamelCase__ )
a__ : str = self.default_image_processor
a__ : List[str] = prepare_img()
a__ : Tuple = image_processor(images=lowerCamelCase__ , return_tensors="pt" ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
a__ : Dict = model(**lowerCamelCase__ )
a__ : List[str] = outputs.logits
# verify the logits
a__ : Optional[int] = torch.Size((1, 21_841) )
self.assertEqual(logits.shape , lowerCamelCase__ )
a__ : Optional[Any] = torch.tensor([1.6881, -0.2787, 0.5901] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(logits[0, :3] , lowerCamelCase__ , atol=1E-4 ) )
a__ : Optional[Any] = 2_396
self.assertEqual(logits.argmax(-1 ).item() , lowerCamelCase__ )
@slow
def _UpperCamelCase( self : int ):
a__ : Optional[Any] = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640" )
a__ : Tuple = model.to(lowerCamelCase__ )
a__ : List[Any] = BeitImageProcessor(do_resize=lowerCamelCase__ , size=640 , do_center_crop=lowerCamelCase__ )
a__ : Tuple = load_dataset("hf-internal-testing/fixtures_ade20k" , split="test" )
a__ : Union[str, Any] = Image.open(ds[0]["file"] )
a__ : List[Any] = image_processor(images=lowerCamelCase__ , return_tensors="pt" ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
a__ : Optional[Any] = model(**lowerCamelCase__ )
a__ : List[str] = outputs.logits
# verify the logits
a__ : Tuple = torch.Size((1, 150, 160, 160) )
self.assertEqual(logits.shape , lowerCamelCase__ )
a__ : int = version.parse(PIL.__version__ ) < version.parse("9.0.0" )
if is_pillow_less_than_a:
a__ : Dict = torch.tensor(
[
[[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
[[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
[[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
] , device=lowerCamelCase__ , )
else:
a__ : Dict = torch.tensor(
[
[[-4.8960, -2.3688, -3.0355], [-2.8478, -0.9836, -1.7418], [-2.9449, -1.3332, -2.1456]],
[[-5.8081, -3.4124, -4.1006], [-3.8561, -2.2081, -3.0323], [-3.8365, -2.4601, -3.3669]],
[[-0.0309, 3.9868, 4.0540], [2.9640, 4.6877, 4.9976], [3.2081, 4.7690, 4.9942]],
] , device=lowerCamelCase__ , )
self.assertTrue(torch.allclose(logits[0, :3, :3, :3] , lowerCamelCase__ , atol=1E-4 ) )
@slow
def _UpperCamelCase( self : Tuple ):
a__ : str = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640" )
a__ : List[Any] = model.to(lowerCamelCase__ )
a__ : int = BeitImageProcessor(do_resize=lowerCamelCase__ , size=640 , do_center_crop=lowerCamelCase__ )
a__ : Optional[int] = load_dataset("hf-internal-testing/fixtures_ade20k" , split="test" )
a__ : str = Image.open(ds[0]["file"] )
a__ : str = image_processor(images=lowerCamelCase__ , return_tensors="pt" ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
a__ : List[Any] = model(**lowerCamelCase__ )
a__ : Any = outputs.logits.detach().cpu()
a__ : List[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase__ , target_sizes=[(500, 300)] )
a__ : Optional[int] = torch.Size((500, 300) )
self.assertEqual(segmentation[0].shape , lowerCamelCase__ )
a__ : List[str] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase__ )
a__ : Any = torch.Size((160, 160) )
self.assertEqual(segmentation[0].shape , lowerCamelCase__ )
| 37
| 0
|
from __future__ import annotations
from collections.abc import Sequence
from typing import Literal
def A__ ( lowerCamelCase , lowerCamelCase ) -> str | Literal[False]:
UpperCamelCase_: Dict = list(lowerCamelCase )
UpperCamelCase_: int = list(lowerCamelCase )
UpperCamelCase_: Union[str, Any] = 0
for i in range(len(lowerCamelCase ) ):
if lista[i] != lista[i]:
count += 1
UpperCamelCase_: Optional[int] = """_"""
if count > 1:
return False
else:
return "".join(lowerCamelCase )
def A__ ( lowerCamelCase ) -> list[str]:
UpperCamelCase_: List[str] = []
while True:
UpperCamelCase_: Any = ["""$"""] * len(lowerCamelCase )
UpperCamelCase_: Dict = []
for i in range(len(lowerCamelCase ) ):
for j in range(i + 1 , len(lowerCamelCase ) ):
UpperCamelCase_: int = compare_string(binary[i] , binary[j] )
if k is False:
UpperCamelCase_: List[str] = """*"""
UpperCamelCase_: Any = """*"""
temp.append("""X""" )
for i in range(len(lowerCamelCase ) ):
if checka[i] == "$":
pi.append(binary[i] )
if len(lowerCamelCase ) == 0:
return pi
UpperCamelCase_: List[Any] = list(set(lowerCamelCase ) )
def A__ ( lowerCamelCase , lowerCamelCase ) -> list[str]:
UpperCamelCase_: List[str] = []
for minterm in minterms:
UpperCamelCase_: Dict = """"""
for _ in range(lowerCamelCase ):
UpperCamelCase_: List[Any] = str(minterm % 2 ) + string
minterm //= 2
temp.append(lowerCamelCase )
return temp
def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> bool:
UpperCamelCase_: Dict = list(lowerCamelCase )
UpperCamelCase_: Dict = list(lowerCamelCase )
UpperCamelCase_: Dict = 0
for i in range(len(lowerCamelCase ) ):
if lista[i] != lista[i]:
count_n += 1
return count_n == count
def A__ ( lowerCamelCase , lowerCamelCase ) -> list[str]:
UpperCamelCase_: Tuple = []
UpperCamelCase_: int = [0] * len(lowerCamelCase )
for i in range(len(chart[0] ) ):
UpperCamelCase_: Union[str, Any] = 0
UpperCamelCase_: Dict = -1
for j in range(len(lowerCamelCase ) ):
if chart[j][i] == 1:
count += 1
UpperCamelCase_: List[Any] = j
if count == 1:
UpperCamelCase_: Optional[int] = 1
for i in range(len(lowerCamelCase ) ):
if select[i] == 1:
for j in range(len(chart[0] ) ):
if chart[i][j] == 1:
for k in range(len(lowerCamelCase ) ):
UpperCamelCase_: Union[str, Any] = 0
temp.append(prime_implicants[i] )
while True:
UpperCamelCase_: Dict = 0
UpperCamelCase_: str = -1
UpperCamelCase_: Union[str, Any] = 0
for i in range(len(lowerCamelCase ) ):
UpperCamelCase_: Optional[int] = chart[i].count(1 )
if count_n > max_n:
UpperCamelCase_: List[str] = count_n
UpperCamelCase_: Tuple = i
if max_n == 0:
return temp
temp.append(prime_implicants[rem] )
for i in range(len(chart[0] ) ):
if chart[rem][i] == 1:
for j in range(len(lowerCamelCase ) ):
UpperCamelCase_: Any = 0
def A__ ( lowerCamelCase , lowerCamelCase ) -> list[list[int]]:
UpperCamelCase_: Optional[int] = [[0 for x in range(len(lowerCamelCase ) )] for x in range(len(lowerCamelCase ) )]
for i in range(len(lowerCamelCase ) ):
UpperCamelCase_: List[str] = prime_implicants[i].count("""_""" )
for j in range(len(lowerCamelCase ) ):
if is_for_table(prime_implicants[i] , binary[j] , lowerCamelCase ):
UpperCamelCase_: Tuple = 1
return chart
def A__ ( ) -> None:
UpperCamelCase_: Any = int(input("""Enter the no. of variables\n""" ) )
UpperCamelCase_: int = [
float(lowerCamelCase )
for x in input(
"""Enter the decimal representation of Minterms 'Spaces Separated'\n""" ).split()
]
UpperCamelCase_: Union[str, Any] = decimal_to_binary(lowerCamelCase , lowerCamelCase )
UpperCamelCase_: Any = check(lowerCamelCase )
print("""Prime Implicants are:""" )
print(lowerCamelCase )
UpperCamelCase_: Union[str, Any] = prime_implicant_chart(lowerCamelCase , lowerCamelCase )
UpperCamelCase_: Any = selection(lowerCamelCase , lowerCamelCase )
print("""Essential Prime Implicants are:""" )
print(lowerCamelCase )
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 670
|
import logging
import os
import sys
from dataclasses import dataclass, field
from itertools import chain
from typing import Optional, Union
import datasets
import numpy as np
import torch
from datasets import load_dataset
import transformers
from transformers import (
AutoConfig,
AutoModelForMultipleChoice,
AutoTokenizer,
HfArgumentParser,
Trainer,
TrainingArguments,
default_data_collator,
set_seed,
)
from transformers.tokenization_utils_base import PreTrainedTokenizerBase
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import PaddingStrategy, check_min_version, send_example_telemetry
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("""4.31.0""")
lowerCamelCase_ : List[str] = logging.getLogger(__name__)
@dataclass
class _UpperCamelCase :
'''simple docstring'''
__UpperCamelCase : str = field(
metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""} )
__UpperCamelCase : Optional[str] = field(
default=_A , metadata={"""help""": """Pretrained config name or path if not the same as model_name"""} )
__UpperCamelCase : Optional[str] = field(
default=_A , metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""} )
__UpperCamelCase : Optional[str] = field(
default=_A , metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""} , )
__UpperCamelCase : bool = field(
default=_A , metadata={"""help""": """Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."""} , )
__UpperCamelCase : str = field(
default="""main""" , metadata={"""help""": """The specific model version to use (can be a branch name, tag name or commit id)."""} , )
__UpperCamelCase : bool = field(
default=_A , metadata={
"""help""": (
"""Will use the token generated when running `huggingface-cli login` (necessary to use this script """
"""with private models)."""
)
} , )
@dataclass
class _UpperCamelCase :
'''simple docstring'''
__UpperCamelCase : Optional[str] = field(default=_A , metadata={"""help""": """The input training data file (a text file)."""} )
__UpperCamelCase : Optional[str] = field(
default=_A , metadata={"""help""": """An optional input evaluation data file to evaluate the perplexity on (a text file)."""} , )
__UpperCamelCase : bool = field(
default=_A , metadata={"""help""": """Overwrite the cached training and evaluation sets"""} )
__UpperCamelCase : Optional[int] = field(
default=_A , metadata={"""help""": """The number of processes to use for the preprocessing."""} , )
__UpperCamelCase : Optional[int] = field(
default=_A , metadata={
"""help""": (
"""The maximum total input sequence length after tokenization. If passed, sequences longer """
"""than this will be truncated, sequences shorter will be padded."""
)
} , )
__UpperCamelCase : bool = field(
default=_A , metadata={
"""help""": (
"""Whether to pad all samples to the maximum sentence length. """
"""If False, will pad the samples dynamically when batching to the maximum length in the batch. More """
"""efficient on GPU but very bad for TPU."""
)
} , )
__UpperCamelCase : Optional[int] = field(
default=_A , metadata={
"""help""": (
"""For debugging purposes or quicker training, truncate the number of training examples to this """
"""value if set."""
)
} , )
__UpperCamelCase : Optional[int] = field(
default=_A , metadata={
"""help""": (
"""For debugging purposes or quicker training, truncate the number of evaluation examples to this """
"""value if set."""
)
} , )
def lowerCAmelCase__ ( self : Dict ):
if self.train_file is not None:
UpperCamelCase_: Union[str, Any] = self.train_file.split(""".""" )[-1]
assert extension in ["csv", "json"], "`train_file` should be a csv or a json file."
if self.validation_file is not None:
UpperCamelCase_: Dict = self.validation_file.split(""".""" )[-1]
assert extension in ["csv", "json"], "`validation_file` should be a csv or a json file."
@dataclass
class _UpperCamelCase :
'''simple docstring'''
__UpperCamelCase : PreTrainedTokenizerBase
__UpperCamelCase : Union[bool, str, PaddingStrategy] = True
__UpperCamelCase : Optional[int] = None
__UpperCamelCase : Optional[int] = None
def __call__( self : Optional[int] , snake_case_ : Dict ):
UpperCamelCase_: Dict = """label""" if """label""" in features[0].keys() else """labels"""
UpperCamelCase_: int = [feature.pop(snake_case_ ) for feature in features]
UpperCamelCase_: Optional[Any] = len(snake_case_ )
UpperCamelCase_: List[str] = len(features[0]["""input_ids"""] )
UpperCamelCase_: Tuple = [
[{k: v[i] for k, v in feature.items()} for i in range(snake_case_ )] for feature in features
]
UpperCamelCase_: Any = list(chain(*snake_case_ ) )
UpperCamelCase_: List[Any] = self.tokenizer.pad(
snake_case_ , padding=self.padding , max_length=self.max_length , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors="""pt""" , )
# Un-flatten
UpperCamelCase_: Tuple = {k: v.view(snake_case_ , snake_case_ , -1 ) for k, v in batch.items()}
# Add back labels
UpperCamelCase_: Optional[int] = torch.tensor(snake_case_ , dtype=torch.intaa )
return batch
def A__ ( ) -> Tuple:
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
UpperCamelCase_: str = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) )
if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
UpperCamelCase_, UpperCamelCase_, UpperCamelCase_: int = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) )
else:
UpperCamelCase_, UpperCamelCase_, UpperCamelCase_: List[str] = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry("""run_swag""" , lowerCamelCase , lowerCamelCase )
# Setup logging
logging.basicConfig(
format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , )
if training_args.should_log:
# The default of training_args.log_level is passive, so we set log level at info here to have that default.
transformers.utils.logging.set_verbosity_info()
UpperCamelCase_: Dict = training_args.get_process_log_level()
logger.setLevel(lowerCamelCase )
datasets.utils.logging.set_verbosity(lowerCamelCase )
transformers.utils.logging.set_verbosity(lowerCamelCase )
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
# Log on each process the small summary:
logger.warning(
F'''Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'''
+ F'''distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}''' )
logger.info(F'''Training/evaluation parameters {training_args}''' )
# Detecting last checkpoint.
UpperCamelCase_: List[str] = None
if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir:
UpperCamelCase_: List[str] = get_last_checkpoint(training_args.output_dir )
if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0:
raise ValueError(
F'''Output directory ({training_args.output_dir}) already exists and is not empty. '''
"""Use --overwrite_output_dir to overcome.""" )
elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
logger.info(
F'''Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '''
"""the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" )
# Set seed before initializing model.
set_seed(training_args.seed )
# Get the datasets: you can either provide your own CSV/JSON/TXT training and evaluation files (see below)
# or just provide the name of one of the public datasets available on the hub at https://huggingface.co/datasets/
# (the dataset will be downloaded automatically from the datasets Hub).
# For CSV/JSON files, this script will use the column called 'text' or the first column if no column called
# 'text' is found. You can easily tweak this behavior (see below).
# In distributed training, the load_dataset function guarantee that only one local process can concurrently
# download the dataset.
if data_args.train_file is not None or data_args.validation_file is not None:
UpperCamelCase_: List[str] = {}
if data_args.train_file is not None:
UpperCamelCase_: List[Any] = data_args.train_file
if data_args.validation_file is not None:
UpperCamelCase_: Optional[int] = data_args.validation_file
UpperCamelCase_: Any = data_args.train_file.split(""".""" )[-1]
UpperCamelCase_: Tuple = load_dataset(
lowerCamelCase , data_files=lowerCamelCase , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , )
else:
# Downloading and loading the swag dataset from the hub.
UpperCamelCase_: int = load_dataset(
"""swag""" , """regular""" , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , )
# See more about loading any type of standard or custom dataset (from files, python dict, pandas DataFrame, etc) at
# https://huggingface.co/docs/datasets/loading_datasets.html.
# Load pretrained model and tokenizer
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
# download model & vocab.
UpperCamelCase_: Optional[int] = AutoConfig.from_pretrained(
model_args.config_name if model_args.config_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , )
UpperCamelCase_: Union[str, Any] = AutoTokenizer.from_pretrained(
model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , )
UpperCamelCase_: List[str] = AutoModelForMultipleChoice.from_pretrained(
model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=lowerCamelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , )
# When using your own dataset or a different dataset from swag, you will probably need to change this.
UpperCamelCase_: Union[str, Any] = [F'''ending{i}''' for i in range(4 )]
UpperCamelCase_: str = """sent1"""
UpperCamelCase_: List[str] = """sent2"""
if data_args.max_seq_length is None:
UpperCamelCase_: int = tokenizer.model_max_length
if max_seq_length > 10_24:
logger.warning(
"""The chosen tokenizer supports a `model_max_length` that is longer than the default `block_size` value"""
""" of 1024. If you would like to use a longer `block_size` up to `tokenizer.model_max_length` you can"""
""" override this default with `--block_size xxx`.""" )
UpperCamelCase_: Optional[Any] = 10_24
else:
if data_args.max_seq_length > tokenizer.model_max_length:
logger.warning(
F'''The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the'''
F'''model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}.''' )
UpperCamelCase_: Union[str, Any] = min(data_args.max_seq_length , tokenizer.model_max_length )
# Preprocessing the datasets.
def preprocess_function(lowerCamelCase ):
UpperCamelCase_: Optional[Any] = [[context] * 4 for context in examples[context_name]]
UpperCamelCase_: Dict = examples[question_header_name]
UpperCamelCase_: List[str] = [
[F'''{header} {examples[end][i]}''' for end in ending_names] for i, header in enumerate(lowerCamelCase )
]
# Flatten out
UpperCamelCase_: str = list(chain(*lowerCamelCase ) )
UpperCamelCase_: Any = list(chain(*lowerCamelCase ) )
# Tokenize
UpperCamelCase_: Any = tokenizer(
lowerCamelCase , lowerCamelCase , truncation=lowerCamelCase , max_length=lowerCamelCase , padding="""max_length""" if data_args.pad_to_max_length else False , )
# Un-flatten
return {k: [v[i : i + 4] for i in range(0 , len(lowerCamelCase ) , 4 )] for k, v in tokenized_examples.items()}
if training_args.do_train:
if "train" not in raw_datasets:
raise ValueError("""--do_train requires a train dataset""" )
UpperCamelCase_: str = raw_datasets["""train"""]
if data_args.max_train_samples is not None:
UpperCamelCase_: Union[str, Any] = min(len(lowerCamelCase ) , data_args.max_train_samples )
UpperCamelCase_: Optional[int] = train_dataset.select(range(lowerCamelCase ) )
with training_args.main_process_first(desc="""train dataset map pre-processing""" ):
UpperCamelCase_: str = train_dataset.map(
lowerCamelCase , batched=lowerCamelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , )
if training_args.do_eval:
if "validation" not in raw_datasets:
raise ValueError("""--do_eval requires a validation dataset""" )
UpperCamelCase_: Dict = raw_datasets["""validation"""]
if data_args.max_eval_samples is not None:
UpperCamelCase_: str = min(len(lowerCamelCase ) , data_args.max_eval_samples )
UpperCamelCase_: Tuple = eval_dataset.select(range(lowerCamelCase ) )
with training_args.main_process_first(desc="""validation dataset map pre-processing""" ):
UpperCamelCase_: str = eval_dataset.map(
lowerCamelCase , batched=lowerCamelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , )
# Data collator
UpperCamelCase_: str = (
default_data_collator
if data_args.pad_to_max_length
else DataCollatorForMultipleChoice(tokenizer=lowerCamelCase , pad_to_multiple_of=8 if training_args.fpaa else None )
)
# Metric
def compute_metrics(lowerCamelCase ):
UpperCamelCase_, UpperCamelCase_: List[str] = eval_predictions
UpperCamelCase_: Optional[Any] = np.argmax(lowerCamelCase , axis=1 )
return {"accuracy": (preds == label_ids).astype(np.floataa ).mean().item()}
# Initialize our Trainer
UpperCamelCase_: Union[str, Any] = Trainer(
model=lowerCamelCase , args=lowerCamelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , tokenizer=lowerCamelCase , data_collator=lowerCamelCase , compute_metrics=lowerCamelCase , )
# Training
if training_args.do_train:
UpperCamelCase_: List[Any] = None
if training_args.resume_from_checkpoint is not None:
UpperCamelCase_: int = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
UpperCamelCase_: str = last_checkpoint
UpperCamelCase_: Optional[Any] = trainer.train(resume_from_checkpoint=lowerCamelCase )
trainer.save_model() # Saves the tokenizer too for easy upload
UpperCamelCase_: Tuple = train_result.metrics
UpperCamelCase_: Tuple = (
data_args.max_train_samples if data_args.max_train_samples is not None else len(lowerCamelCase )
)
UpperCamelCase_: Optional[Any] = min(lowerCamelCase , len(lowerCamelCase ) )
trainer.log_metrics("""train""" , lowerCamelCase )
trainer.save_metrics("""train""" , lowerCamelCase )
trainer.save_state()
# Evaluation
if training_args.do_eval:
logger.info("""*** Evaluate ***""" )
UpperCamelCase_: Optional[Any] = trainer.evaluate()
UpperCamelCase_: Tuple = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(lowerCamelCase )
UpperCamelCase_: Optional[Any] = min(lowerCamelCase , len(lowerCamelCase ) )
trainer.log_metrics("""eval""" , lowerCamelCase )
trainer.save_metrics("""eval""" , lowerCamelCase )
UpperCamelCase_: Optional[int] = {
"""finetuned_from""": model_args.model_name_or_path,
"""tasks""": """multiple-choice""",
"""dataset_tags""": """swag""",
"""dataset_args""": """regular""",
"""dataset""": """SWAG""",
"""language""": """en""",
}
if training_args.push_to_hub:
trainer.push_to_hub(**lowerCamelCase )
else:
trainer.create_model_card(**lowerCamelCase )
def A__ ( lowerCamelCase ) -> Tuple:
# For xla_spawn (TPUs)
main()
if __name__ == "__main__":
main()
| 670
| 1
|
'''simple docstring'''
def A (__lowerCamelCase :Tuple , __lowerCamelCase :Tuple ):
_lowerCAmelCase = [1]
for i in range(2 , _lowerCAmelCase ):
factorials.append(factorials[-1] * i )
assert 0 <= k < factorials[-1] * n, "k out of bounds"
_lowerCAmelCase = []
_lowerCAmelCase = list(range(_lowerCAmelCase ) )
# Find permutation
while factorials:
_lowerCAmelCase = factorials.pop()
_lowerCAmelCase = divmod(_lowerCAmelCase , _lowerCAmelCase )
permutation.append(elements[number] )
elements.remove(elements[number] )
permutation.append(elements[0] )
return permutation
if __name__ == "__main__":
import doctest
doctest.testmod()
| 5
|
import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn
from transformers import (
HfArgumentParser,
Trainer,
TrainingArguments,
WavaVecaConfig,
WavaVecaFeatureExtractor,
WavaVecaForPreTraining,
is_apex_available,
trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices
if is_apex_available():
from apex import amp
if version.parse(version.parse(torch.__version__).base_version) >= version.parse('''1.6'''):
_lowerCAmelCase : Optional[Any] = True
from torch.cuda.amp import autocast
_lowerCAmelCase : Dict = logging.getLogger(__name__)
@dataclass
class __magic_name__ :
"""simple docstring"""
__UpperCamelCase = field(
metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''Whether to freeze the feature extractor layers of the model.'''} )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''Whether to log verbose messages or not.'''} , )
__UpperCamelCase = field(
default=2.0 , metadata={'''help''': '''Maximum temperature for gumbel softmax.'''} )
__UpperCamelCase = field(
default=0.5 , metadata={'''help''': '''Minimum temperature for gumbel softmax.'''} )
__UpperCamelCase = field(
default=0.99_9995 , metadata={'''help''': '''Decay of gumbel temperature during training.'''} )
def __snake_case ( _lowerCAmelCase : ModelArguments , _lowerCAmelCase : TrainingArguments ) -> str:
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s" , datefmt="%m/%d/%Y %H:%M:%S" , handlers=[logging.StreamHandler(sys.stdout )] , )
A_ : Optional[int] = logging.WARNING
if model_args.verbose_logging:
A_ : Dict = logging.DEBUG
elif trainer_utils.is_main_process(training_args.local_rank ):
A_ : int = logging.INFO
logger.setLevel(_lowerCAmelCase )
@dataclass
class __magic_name__ :
"""simple docstring"""
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} )
__UpperCamelCase = field(
default='''train''' , metadata={
'''help''': '''The name of the training data set split to use (via the datasets library). Defaults to \'train\''''
} , )
__UpperCamelCase = field(
default='''validation''' , metadata={
'''help''': (
'''The name of the validation data set split to use (via the datasets library). Defaults to \'validation\''''
)
} , )
__UpperCamelCase = field(
default='''file''' , metadata={'''help''': '''Column in the dataset that contains speech file path. Defaults to \'file\''''} , )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} )
__UpperCamelCase = field(
default=1 , metadata={
'''help''': '''The percentage of the train set used as validation set in case there\'s no validation split'''
} , )
__UpperCamelCase = field(
default=lowerCamelCase__ , metadata={'''help''': '''The number of processes to use for the preprocessing.'''} , )
__UpperCamelCase = field(
default=20.0 , metadata={'''help''': '''Filter audio files that are longer than `max_duration_in_seconds` seconds'''} )
@dataclass
class __magic_name__ :
"""simple docstring"""
__UpperCamelCase = 42
__UpperCamelCase = 42
__UpperCamelCase = "longest"
__UpperCamelCase = None
__UpperCamelCase = None
def __call__( self :Optional[Any] , snake_case :List[Dict[str, Union[List[int], torch.Tensor]]] ):
'''simple docstring'''
A_ : Optional[Any] = self.feature_extractor.pad(
snake_case , max_length=self.max_length , padding=self.padding , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors="pt" , )
A_ : int = self.model._get_feat_extract_output_lengths(batch["input_values"].shape[-1] )
A_ : List[str] = batch["input_values"].shape[0]
# make sure that no loss is computed on padded inputs
if batch["attention_mask"] is not None:
# compute real output lengths according to convolution formula
A_ : List[str] = self.model._get_feat_extract_output_lengths(batch["attention_mask"].sum(-1 ) ).to(
torch.long )
A_ : Union[str, Any] = torch.zeros(
(batch_size, mask_indices_seq_length) , dtype=torch.long , device=batch["input_values"].device )
# these two operations makes sure that all values
# before the output lengths indices are attended to
A_ : str = 1
A_ : Union[str, Any] = attention_mask.flip([-1] ).cumsum(-1 ).flip([-1] ).bool()
# sample randomly masked indices
A_ : Optional[int] = _compute_mask_indices(
(batch_size, mask_indices_seq_length) , self.model.config.mask_time_prob , self.model.config.mask_time_length , attention_mask=snake_case , min_masks=2 , )
return batch
class __magic_name__ ( lowerCamelCase__ ):
"""simple docstring"""
def __init__( self :int , *snake_case :Any , snake_case :Any=1 , snake_case :Dict=0 , snake_case :Dict=1.0 , **snake_case :Any ):
'''simple docstring'''
super().__init__(*snake_case , **snake_case )
A_ : Union[str, Any] = 0
A_ : Dict = max_gumbel_temp
A_ : Optional[int] = min_gumbel_temp
A_ : List[Any] = gumbel_temp_decay
def SCREAMING_SNAKE_CASE ( self :Optional[int] , snake_case :nn.Module , snake_case :Dict[str, Union[torch.Tensor, Any]] ):
'''simple docstring'''
model.train()
A_ : List[str] = self._prepare_inputs(snake_case )
if self.use_amp:
with autocast():
A_ : List[str] = self.compute_loss(snake_case , snake_case )
else:
A_ : str = self.compute_loss(snake_case , snake_case )
if self.args.n_gpu > 1 or self.deepspeed:
if model.module.config.ctc_loss_reduction == "mean":
A_ : Any = loss.mean()
elif model.module.config.ctc_loss_reduction == "sum":
A_ : Optional[Any] = loss.sum() / (inputs["mask_time_indices"]).sum()
else:
raise ValueError(f"{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']" )
if self.args.gradient_accumulation_steps > 1:
A_ : Any = loss / self.args.gradient_accumulation_steps
if self.use_amp:
self.scaler.scale(snake_case ).backward()
elif self.use_apex:
with amp.scale_loss(snake_case , self.optimizer ) as scaled_loss:
scaled_loss.backward()
elif self.deepspeed:
self.deepspeed.backward(snake_case )
else:
loss.backward()
self.num_update_step += 1
# make sure gumbel softmax temperature is decayed
if self.args.n_gpu > 1 or self.deepspeed:
model.module.set_gumbel_temperature(
max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) )
else:
model.set_gumbel_temperature(
max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) )
return loss.detach()
def __snake_case ( ) -> Tuple:
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
A_ : List[str] = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) )
A_ , A_ , A_ : Dict = parser.parse_args_into_dataclasses()
configure_logger(_lowerCAmelCase , _lowerCAmelCase )
# Downloading and loading a dataset from the hub.
A_ : Optional[Any] = load_dataset(data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir )
if "validation" not in datasets.keys():
# make sure only "validation" and "train" keys remain"
A_ : Tuple = DatasetDict()
A_ : Any = load_dataset(
data_args.dataset_name , data_args.dataset_config_name , split=f"{data_args.train_split_name}[:{data_args.validation_split_percentage}%]" , cache_dir=model_args.cache_dir , )
A_ : Union[str, Any] = load_dataset(
data_args.dataset_name , data_args.dataset_config_name , split=f"{data_args.train_split_name}[{data_args.validation_split_percentage}%:]" , cache_dir=model_args.cache_dir , )
else:
# make sure only "validation" and "train" keys remain"
A_ : Any = DatasetDict()
A_ : Optional[Any] = load_dataset(
data_args.dataset_name , data_args.dataset_config_name , split="validation" , cache_dir=model_args.cache_dir , )
A_ : List[str] = load_dataset(
data_args.dataset_name , data_args.dataset_config_name , split=f"{data_args.train_split_name}" , cache_dir=model_args.cache_dir , )
# only normalized-inputs-training is supported
A_ : Union[str, Any] = WavaVecaFeatureExtractor.from_pretrained(
model_args.model_name_or_path , cache_dir=model_args.cache_dir , do_normalize=_lowerCAmelCase )
def prepare_dataset(_lowerCAmelCase : str ):
# check that all files have the correct sampling rate
A_ , A_ : Tuple = librosa.load(batch[data_args.speech_file_column] , sr=feature_extractor.sampling_rate )
return batch
# load audio files into numpy arrays
A_ : List[Any] = datasets.map(
_lowerCAmelCase , num_proc=data_args.preprocessing_num_workers , remove_columns=datasets["train"].column_names )
# filter audio files that are too long
A_ : str = vectorized_datasets.filter(
lambda _lowerCAmelCase : len(data["speech"] ) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate ) )
def normalize(_lowerCAmelCase : List[str] ):
return feature_extractor(batch["speech"] , sampling_rate=feature_extractor.sampling_rate )
# normalize and transform to `BatchFeatures`
A_ : Any = vectorized_datasets.map(
_lowerCAmelCase , batched=_lowerCAmelCase , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , remove_columns=vectorized_datasets["train"].column_names , )
# pretraining is only supported for "newer" stable layer norm architecture
# apply_spec_augment has to be True, mask_feature_prob has to be 0.0
A_ : Any = WavaVecaConfig.from_pretrained(
model_args.model_name_or_path , cache_dir=model_args.cache_dir , gradient_checkpointing=training_args.gradient_checkpointing , )
if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
raise ValueError(
"PreTraining is only supported for ``config.do_stable_layer_norm=True`` and"
" ``config.feat_extract_norm='layer'" )
A_ : int = WavaVecaForPreTraining(_lowerCAmelCase )
A_ : str = DataCollatorForWavaVecaPretraining(model=_lowerCAmelCase , feature_extractor=_lowerCAmelCase )
A_ : List[Any] = WavaVecaPreTrainer(
model=_lowerCAmelCase , data_collator=_lowerCAmelCase , args=_lowerCAmelCase , train_dataset=vectorized_datasets["train"] , eval_dataset=vectorized_datasets["validation"] , tokenizer=_lowerCAmelCase , max_gumbel_temp=model_args.max_gumbel_temperature , min_gumbel_temp=model_args.min_gumbel_temperature , gumbel_temp_decay=model_args.gumbel_temperature_decay , )
trainer.train()
if __name__ == "__main__":
main()
| 454
| 0
|
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
_snake_case : Optional[Any] = {
'configuration_chinese_clip': [
'CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
'ChineseCLIPConfig',
'ChineseCLIPOnnxConfig',
'ChineseCLIPTextConfig',
'ChineseCLIPVisionConfig',
],
'processing_chinese_clip': ['ChineseCLIPProcessor'],
}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_snake_case : List[str] = ['ChineseCLIPFeatureExtractor']
_snake_case : Any = ['ChineseCLIPImageProcessor']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_snake_case : Optional[int] = [
'CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
'ChineseCLIPModel',
'ChineseCLIPPreTrainedModel',
'ChineseCLIPTextModel',
'ChineseCLIPVisionModel',
]
if TYPE_CHECKING:
from .configuration_chinese_clip import (
CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
ChineseCLIPConfig,
ChineseCLIPOnnxConfig,
ChineseCLIPTextConfig,
ChineseCLIPVisionConfig,
)
from .processing_chinese_clip import ChineseCLIPProcessor
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_chinese_clip import (
CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
ChineseCLIPModel,
ChineseCLIPPreTrainedModel,
ChineseCLIPTextModel,
ChineseCLIPVisionModel,
)
else:
import sys
_snake_case : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 719
|
"""simple docstring"""
from typing import Dict, List
from nltk.translate import gleu_score
import datasets
from datasets import MetricInfo
_snake_case : int = '\\n@misc{wu2016googles,\n title={Google\'s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},\n author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey\n and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin\n Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto\n Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and\n Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes\n and Jeffrey Dean},\n year={2016},\n eprint={1609.08144},\n archivePrefix={arXiv},\n primaryClass={cs.CL}\n}\n'
_snake_case : Union[str, Any] = '\\nThe BLEU score has some undesirable properties when used for single\nsentences, as it was designed to be a corpus measure. We therefore\nuse a slightly different score for our RL experiments which we call\nthe \'GLEU score\'. For the GLEU score, we record all sub-sequences of\n1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then\ncompute a recall, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the target (ground truth) sequence,\nand a precision, which is the ratio of the number of matching n-grams\nto the number of total n-grams in the generated output sequence. Then\nGLEU score is simply the minimum of recall and precision. This GLEU\nscore\'s range is always between 0 (no matches) and 1 (all match) and\nit is symmetrical when switching output and target. According to\nour experiments, GLEU score correlates quite well with the BLEU\nmetric on a corpus level but does not have its drawbacks for our per\nsentence reward objective.\n'
_snake_case : Dict = '\\nComputes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.\nInstead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching\ntokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.\n\nArgs:\n predictions (list of str): list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references (list of list of str): list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.\n max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.\n\nReturns:\n \'google_bleu\': google_bleu score\n\nExamples:\n Example 1:\n >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n\n >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n ... \'interested\', \'in\', \'world\', \'history\']\n >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n ... \'because\', \'he\', \'read\', \'the\', \'book\']\n\n >>> list_of_references = [[ref1a], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric("google_bleu")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results["google_bleu"], 2))\n 0.44\n\n Example 2:\n >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n ... \'heed\', \'the\', \'cat\', \'commands\']\n >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n ... \'of\', \'the\', \'cat\']\n\n >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n ... \'interested\', \'in\', \'world\', \'history\']\n >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n ... \'because\', \'he\', \'read\', \'the\', \'book\']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric("google_bleu")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)\n >>> print(round(results["google_bleu"], 2))\n 0.61\n\n Example 3:\n >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n ... \'heed\', \'the\', \'cat\', \'commands\']\n >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n ... \'of\', \'the\', \'cat\']\n\n >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n ... \'interested\', \'in\', \'world\', \'history\']\n >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n ... \'because\', \'he\', \'read\', \'the\', \'book\']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric("google_bleu")\n >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)\n >>> print(round(results["google_bleu"], 2))\n 0.53\n\n Example 4:\n >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\',\n ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\']\n >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\',\n ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\',\n ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\']\n >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\',\n ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\',\n ... \'heed\', \'the\', \'cat\', \'commands\']\n >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\',\n ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\',\n ... \'of\', \'the\', \'cat\']\n\n >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\',\n ... \'interested\', \'in\', \'world\', \'history\']\n >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\',\n ... \'because\', \'he\', \'read\', \'the\', \'book\']\n\n >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]\n >>> hypotheses = [hyp1, hyp2]\n >>> google_bleu = datasets.load_metric("google_bleu")\n >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)\n >>> print(round(results["google_bleu"], 2))\n 0.4\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class _UpperCAmelCase ( datasets.Metric ):
def lowerCamelCase ( self :int ):
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(
{
"predictions": datasets.Sequence(datasets.Value("string" , id="token" ) , id="sequence" ),
"references": datasets.Sequence(
datasets.Sequence(datasets.Value("string" , id="token" ) , id="sequence" ) , id="references" ),
} ) , )
def lowerCamelCase ( self :str , __UpperCamelCase :List[List[List[str]]] , __UpperCamelCase :List[List[str]] , __UpperCamelCase :int = 1 , __UpperCamelCase :int = 4 , ):
return {
"google_bleu": gleu_score.corpus_gleu(
list_of_references=__UpperCamelCase , hypotheses=__UpperCamelCase , min_len=__UpperCamelCase , max_len=__UpperCamelCase )
}
| 524
| 0
|
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
snake_case_ : str = logging.get_logger(__name__)
snake_case_ : List[Any] = {
'''hustvl/yolos-small''': '''https://huggingface.co/hustvl/yolos-small/resolve/main/config.json''',
# See all YOLOS models at https://huggingface.co/models?filter=yolos
}
class A__ ( a_ ):
UpperCAmelCase = "yolos"
def __init__( self : str , _a : Dict=768 , _a : str=12 , _a : Union[str, Any]=12 , _a : str=3072 , _a : Dict="gelu" , _a : Union[str, Any]=0.0 , _a : Optional[Any]=0.0 , _a : int=0.02 , _a : str=1E-12 , _a : List[str]=[512, 864] , _a : Optional[Any]=16 , _a : Tuple=3 , _a : int=True , _a : int=100 , _a : str=True , _a : str=False , _a : List[Any]=1 , _a : Any=5 , _a : int=2 , _a : Optional[int]=5 , _a : Optional[Any]=2 , _a : Any=0.1 , **_a : Union[str, Any] , ) -> List[Any]:
"""simple docstring"""
super().__init__(**lowercase_ )
_SCREAMING_SNAKE_CASE =hidden_size
_SCREAMING_SNAKE_CASE =num_hidden_layers
_SCREAMING_SNAKE_CASE =num_attention_heads
_SCREAMING_SNAKE_CASE =intermediate_size
_SCREAMING_SNAKE_CASE =hidden_act
_SCREAMING_SNAKE_CASE =hidden_dropout_prob
_SCREAMING_SNAKE_CASE =attention_probs_dropout_prob
_SCREAMING_SNAKE_CASE =initializer_range
_SCREAMING_SNAKE_CASE =layer_norm_eps
_SCREAMING_SNAKE_CASE =image_size
_SCREAMING_SNAKE_CASE =patch_size
_SCREAMING_SNAKE_CASE =num_channels
_SCREAMING_SNAKE_CASE =qkv_bias
_SCREAMING_SNAKE_CASE =num_detection_tokens
_SCREAMING_SNAKE_CASE =use_mid_position_embeddings
_SCREAMING_SNAKE_CASE =auxiliary_loss
# Hungarian matcher
_SCREAMING_SNAKE_CASE =class_cost
_SCREAMING_SNAKE_CASE =bbox_cost
_SCREAMING_SNAKE_CASE =giou_cost
# Loss coefficients
_SCREAMING_SNAKE_CASE =bbox_loss_coefficient
_SCREAMING_SNAKE_CASE =giou_loss_coefficient
_SCREAMING_SNAKE_CASE =eos_coefficient
class A__ ( a_ ):
UpperCAmelCase = version.parse("1.11" )
@property
def __UpperCamelCase ( self : Optional[Any] ) -> Dict:
"""simple docstring"""
return OrderedDict(
[
('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
] )
@property
def __UpperCamelCase ( self : Dict ) -> Any:
"""simple docstring"""
return 1E-4
@property
def __UpperCamelCase ( self : Union[str, Any] ) -> List[str]:
"""simple docstring"""
return 12
| 691
|
"""simple docstring"""
import unittest
import numpy as np
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
from transformers import LevitImageProcessor
class SCREAMING_SNAKE_CASE ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : Any ,lowercase_ : Dict ,lowercase_ : List[str]=7 ,lowercase_ : Tuple=3 ,lowercase_ : List[str]=1_8 ,lowercase_ : Optional[Any]=3_0 ,lowercase_ : List[Any]=4_0_0 ,lowercase_ : List[Any]=True ,lowercase_ : Any=None ,lowercase_ : Optional[Any]=True ,lowercase_ : str=None ,lowercase_ : List[Any]=True ,lowercase_ : Dict=[0.5, 0.5, 0.5] ,lowercase_ : Dict=[0.5, 0.5, 0.5] ,):
lowerCAmelCase__ : Any = size if size is not None else {'''shortest_edge''': 1_8}
lowerCAmelCase__ : Union[str, Any] = crop_size if crop_size is not None else {'''height''': 1_8, '''width''': 1_8}
lowerCAmelCase__ : Dict = parent
lowerCAmelCase__ : Dict = batch_size
lowerCAmelCase__ : List[str] = num_channels
lowerCAmelCase__ : Any = image_size
lowerCAmelCase__ : Union[str, Any] = min_resolution
lowerCAmelCase__ : Dict = max_resolution
lowerCAmelCase__ : List[str] = do_resize
lowerCAmelCase__ : Optional[Any] = size
lowerCAmelCase__ : Tuple = do_center_crop
lowerCAmelCase__ : Optional[int] = crop_size
lowerCAmelCase__ : List[str] = do_normalize
lowerCAmelCase__ : Tuple = image_mean
lowerCAmelCase__ : int = image_std
def __lowerCAmelCase ( self : List[str] ):
return {
"image_mean": self.image_mean,
"image_std": self.image_std,
"do_normalize": self.do_normalize,
"do_resize": self.do_resize,
"do_center_crop": self.do_center_crop,
"size": self.size,
"crop_size": self.crop_size,
}
@require_torch
@require_vision
class SCREAMING_SNAKE_CASE ( a_ , unittest.TestCase ):
"""simple docstring"""
lowercase__ = LevitImageProcessor if is_vision_available() else None
def __lowerCAmelCase ( self : List[str] ):
lowerCAmelCase__ : Optional[Any] = LevitImageProcessingTester(self )
@property
def __lowerCAmelCase ( self : Any ):
return self.image_processor_tester.prepare_image_processor_dict()
def __lowerCAmelCase ( self : str ):
lowerCAmelCase__ : Optional[int] = self.image_processing_class(**self.image_processor_dict )
self.assertTrue(hasattr(lowercase_ ,'''image_mean''' ) )
self.assertTrue(hasattr(lowercase_ ,'''image_std''' ) )
self.assertTrue(hasattr(lowercase_ ,'''do_normalize''' ) )
self.assertTrue(hasattr(lowercase_ ,'''do_resize''' ) )
self.assertTrue(hasattr(lowercase_ ,'''do_center_crop''' ) )
self.assertTrue(hasattr(lowercase_ ,'''size''' ) )
def __lowerCAmelCase ( self : Any ):
lowerCAmelCase__ : int = self.image_processing_class.from_dict(self.image_processor_dict )
self.assertEqual(image_processor.size ,{'''shortest_edge''': 1_8} )
self.assertEqual(image_processor.crop_size ,{'''height''': 1_8, '''width''': 1_8} )
lowerCAmelCase__ : List[str] = self.image_processing_class.from_dict(self.image_processor_dict ,size=4_2 ,crop_size=8_4 )
self.assertEqual(image_processor.size ,{'''shortest_edge''': 4_2} )
self.assertEqual(image_processor.crop_size ,{'''height''': 8_4, '''width''': 8_4} )
def __lowerCAmelCase ( self : Union[str, Any] ):
pass
def __lowerCAmelCase ( self : Optional[int] ):
# Initialize image_processing
lowerCAmelCase__ : List[str] = self.image_processing_class(**self.image_processor_dict )
# create random PIL images
lowerCAmelCase__ : Union[str, Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowercase_ )
for image in image_inputs:
self.assertIsInstance(lowercase_ ,Image.Image )
# Test not batched input
lowerCAmelCase__ : 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
lowerCAmelCase__ : Optional[int] = image_processing(lowercase_ ,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 __lowerCAmelCase ( self : Union[str, Any] ):
# Initialize image_processing
lowerCAmelCase__ : str = self.image_processing_class(**self.image_processor_dict )
# create random numpy tensors
lowerCAmelCase__ : Optional[Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowercase_ ,numpify=lowercase_ )
for image in image_inputs:
self.assertIsInstance(lowercase_ ,np.ndarray )
# Test not batched input
lowerCAmelCase__ : Tuple = 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
lowerCAmelCase__ : Union[str, Any] = image_processing(lowercase_ ,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 __lowerCAmelCase ( self : int ):
# Initialize image_processing
lowerCAmelCase__ : Tuple = self.image_processing_class(**self.image_processor_dict )
# create random PyTorch tensors
lowerCAmelCase__ : Dict = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowercase_ ,torchify=lowercase_ )
for image in image_inputs:
self.assertIsInstance(lowercase_ ,torch.Tensor )
# Test not batched input
lowerCAmelCase__ : 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
lowerCAmelCase__ : Optional[int] = image_processing(lowercase_ ,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'''],
) ,)
| 450
| 0
|
from __future__ import annotations
def __A ( a_ : float ,a_ : float ,a_ : float ,):
if (stress, tangential_force, area).count(0 ) != 1:
raise ValueError("You cannot supply more or less than 2 values" )
elif stress < 0:
raise ValueError("Stress cannot be negative" )
elif tangential_force < 0:
raise ValueError("Tangential Force cannot be negative" )
elif area < 0:
raise ValueError("Area cannot be negative" )
elif stress == 0:
return (
"stress",
tangential_force / area,
)
elif tangential_force == 0:
return (
"tangential_force",
stress * area,
)
else:
return (
"area",
tangential_force / stress,
)
if __name__ == "__main__":
import doctest
doctest.testmod()
| 715
|
'''simple docstring'''
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging
lowerCAmelCase = logging.get_logger(__name__)
lowerCAmelCase = """▁"""
lowerCAmelCase = {"""vocab_file""": """sentencepiece.bpe.model"""}
lowerCAmelCase = {
"""vocab_file""": {
"""xlm-roberta-base""": """https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model""",
"""xlm-roberta-large""": """https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model""",
"""xlm-roberta-large-finetuned-conll02-dutch""": (
"""https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model"""
),
"""xlm-roberta-large-finetuned-conll02-spanish""": (
"""https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model"""
),
"""xlm-roberta-large-finetuned-conll03-english""": (
"""https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model"""
),
"""xlm-roberta-large-finetuned-conll03-german""": (
"""https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model"""
),
}
}
lowerCAmelCase = {
"""xlm-roberta-base""": 5_12,
"""xlm-roberta-large""": 5_12,
"""xlm-roberta-large-finetuned-conll02-dutch""": 5_12,
"""xlm-roberta-large-finetuned-conll02-spanish""": 5_12,
"""xlm-roberta-large-finetuned-conll03-english""": 5_12,
"""xlm-roberta-large-finetuned-conll03-german""": 5_12,
}
class lowerCamelCase ( _A ):
snake_case_ = VOCAB_FILES_NAMES
snake_case_ = PRETRAINED_VOCAB_FILES_MAP
snake_case_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
snake_case_ = ["input_ids", "attention_mask"]
def __init__( self , a_ , a_="<s>" , a_="</s>" , a_="</s>" , a_="<s>" , a_="<unk>" , a_="<pad>" , a_="<mask>" , a_ = None , **a_ , ):
# Mask token behave like a normal word, i.e. include the space before it
lowerCAmelCase : str = AddedToken(a_ , lstrip=a_ , rstrip=a_ ) if isinstance(a_ , a_ ) else mask_token
lowerCAmelCase : Tuple = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=a_ , eos_token=a_ , unk_token=a_ , sep_token=a_ , cls_token=a_ , pad_token=a_ , mask_token=a_ , sp_model_kwargs=self.sp_model_kwargs , **a_ , )
lowerCAmelCase : Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(str(a_ ) )
lowerCAmelCase : int = vocab_file
# Original fairseq vocab and spm vocab must be "aligned":
# Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
# fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-'
# spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a'
# Mimic fairseq token-to-id alignment for the first 4 token
lowerCAmelCase : Any = {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}
# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
lowerCAmelCase : Dict = 1
lowerCAmelCase : Optional[Any] = len(self.sp_model ) + self.fairseq_offset
lowerCAmelCase : List[Any] = {v: k for k, v in self.fairseq_tokens_to_ids.items()}
def __getstate__( self ):
lowerCAmelCase : Any = self.__dict__.copy()
lowerCAmelCase : Optional[int] = None
lowerCAmelCase : List[str] = self.sp_model.serialized_model_proto()
return state
def __setstate__( self , a_ ):
lowerCAmelCase : Any = d
# for backward compatibility
if not hasattr(self , "sp_model_kwargs" ):
lowerCAmelCase : Any = {}
lowerCAmelCase : Optional[Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.LoadFromSerializedProto(self.sp_model_proto )
def _lowerCamelCase ( self , a_ , a_ = None ):
if token_ids_a is None:
return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
lowerCAmelCase : Optional[Any] = [self.cls_token_id]
lowerCAmelCase : List[Any] = [self.sep_token_id]
return cls + token_ids_a + sep + sep + token_ids_a + sep
def _lowerCamelCase ( self , a_ , a_ = None , a_ = False ):
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=a_ , token_ids_a=a_ , already_has_special_tokens=a_ )
if token_ids_a is None:
return [1] + ([0] * len(a_ )) + [1]
return [1] + ([0] * len(a_ )) + [1, 1] + ([0] * len(a_ )) + [1]
def _lowerCamelCase ( self , a_ , a_ = None ):
lowerCAmelCase : Dict = [self.sep_token_id]
lowerCAmelCase : List[Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
@property
def _lowerCamelCase ( self ):
return len(self.sp_model ) + self.fairseq_offset + 1 # Add the <mask> token
def _lowerCamelCase ( self ):
lowerCAmelCase : Dict = {self.convert_ids_to_tokens(a_ ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def _lowerCamelCase ( self , a_ ):
return self.sp_model.encode(a_ , out_type=a_ )
def _lowerCamelCase ( self , a_ ):
if token in self.fairseq_tokens_to_ids:
return self.fairseq_tokens_to_ids[token]
lowerCAmelCase : int = self.sp_model.PieceToId(a_ )
# Need to return unknown token if the SP model returned 0
return spm_id + self.fairseq_offset if spm_id else self.unk_token_id
def _lowerCamelCase ( self , a_ ):
if index in self.fairseq_ids_to_tokens:
return self.fairseq_ids_to_tokens[index]
return self.sp_model.IdToPiece(index - self.fairseq_offset )
def _lowerCamelCase ( self , a_ ):
lowerCAmelCase : Dict = "".join(a_ ).replace(a_ , " " ).strip()
return out_string
def _lowerCamelCase ( self , a_ , a_ = None ):
if not os.path.isdir(a_ ):
logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' )
return
lowerCAmelCase : int = os.path.join(
a_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(a_ ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , a_ )
elif not os.path.isfile(self.vocab_file ):
with open(a_ , "wb" ) as fi:
lowerCAmelCase : Dict = self.sp_model.serialized_model_proto()
fi.write(a_ )
return (out_vocab_file,)
| 551
| 0
|
'''simple docstring'''
import gc
import tempfile
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionTextToImagePipeline
from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device
a = False
class __a ( unittest.TestCase ):
pass
@nightly
@require_torch_gpu
class __a ( unittest.TestCase ):
def UpperCAmelCase__ ( self : Optional[int] ):
'''simple docstring'''
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def UpperCAmelCase__ ( self : Optional[Any] ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = VersatileDiffusionTextToImagePipeline.from_pretrained("""shi-labs/versatile-diffusion""" )
# remove text_unet
pipe.remove_unused_weights()
pipe.to(lowerCamelCase )
pipe.set_progress_bar_config(disable=lowerCamelCase )
__SCREAMING_SNAKE_CASE = """A painting of a squirrel eating a burger """
__SCREAMING_SNAKE_CASE = torch.manual_seed(0 )
__SCREAMING_SNAKE_CASE = pipe(
prompt=lowerCamelCase ,generator=lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type="""numpy""" ).images
with tempfile.TemporaryDirectory() as tmpdirname:
pipe.save_pretrained(lowerCamelCase )
__SCREAMING_SNAKE_CASE = VersatileDiffusionTextToImagePipeline.from_pretrained(lowerCamelCase )
pipe.to(lowerCamelCase )
pipe.set_progress_bar_config(disable=lowerCamelCase )
__SCREAMING_SNAKE_CASE = generator.manual_seed(0 )
__SCREAMING_SNAKE_CASE = pipe(
prompt=lowerCamelCase ,generator=lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type="""numpy""" ).images
assert np.abs(image - new_image ).sum() < 1E-5, "Models don't have the same forward pass"
def UpperCAmelCase__ ( self : str ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = VersatileDiffusionTextToImagePipeline.from_pretrained(
"""shi-labs/versatile-diffusion""" ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase )
pipe.set_progress_bar_config(disable=lowerCamelCase )
__SCREAMING_SNAKE_CASE = """A painting of a squirrel eating a burger """
__SCREAMING_SNAKE_CASE = torch.manual_seed(0 )
__SCREAMING_SNAKE_CASE = pipe(
prompt=lowerCamelCase ,generator=lowerCamelCase ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type="""numpy""" ).images
__SCREAMING_SNAKE_CASE = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
__SCREAMING_SNAKE_CASE = np.array([0.3_367, 0.3_169, 0.2_656, 0.3_870, 0.4_790, 0.3_796, 0.4_009, 0.4_878, 0.4_778] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
| 109
|
import unittest
import numpy as np
import torch
from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device
enable_full_determinism()
class lowerCamelCase_ ( unittest.TestCase ):
'''simple docstring'''
@property
def UpperCamelCase__ ( self) -> Optional[Any]:
torch.manual_seed(0)
__UpperCamelCase :List[Any] = UNetaDModel(
block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''') , up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''') , )
return model
def UpperCamelCase__ ( self) -> Optional[int]:
__UpperCamelCase :Any = self.dummy_uncond_unet
__UpperCamelCase :Any = ScoreSdeVeScheduler()
__UpperCamelCase :List[Any] = ScoreSdeVePipeline(unet=__lowercase , scheduler=__lowercase)
sde_ve.to(__lowercase)
sde_ve.set_progress_bar_config(disable=__lowercase)
__UpperCamelCase :Dict = torch.manual_seed(0)
__UpperCamelCase :Union[str, Any] = sde_ve(num_inference_steps=2 , output_type='''numpy''' , generator=__lowercase).images
__UpperCamelCase :str = torch.manual_seed(0)
__UpperCamelCase :Tuple = sde_ve(num_inference_steps=2 , output_type='''numpy''' , generator=__lowercase , return_dict=__lowercase)[
0
]
__UpperCamelCase :Any = image[0, -3:, -3:, -1]
__UpperCamelCase :List[Any] = image_from_tuple[0, -3:, -3:, -1]
assert image.shape == (1, 32, 32, 3)
__UpperCamelCase :Any = np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0])
assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2
@slow
@require_torch
class lowerCamelCase_ ( unittest.TestCase ):
'''simple docstring'''
def UpperCamelCase__ ( self) -> int:
__UpperCamelCase :Union[str, Any] = '''google/ncsnpp-church-256'''
__UpperCamelCase :Optional[int] = UNetaDModel.from_pretrained(__lowercase)
__UpperCamelCase :Optional[int] = ScoreSdeVeScheduler.from_pretrained(__lowercase)
__UpperCamelCase :int = ScoreSdeVePipeline(unet=__lowercase , scheduler=__lowercase)
sde_ve.to(__lowercase)
sde_ve.set_progress_bar_config(disable=__lowercase)
__UpperCamelCase :List[Any] = torch.manual_seed(0)
__UpperCamelCase :Union[str, Any] = sde_ve(num_inference_steps=10 , output_type='''numpy''' , generator=__lowercase).images
__UpperCamelCase :str = image[0, -3:, -3:, -1]
assert image.shape == (1, 256, 256, 3)
__UpperCamelCase :Dict = np.array([0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0])
assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
| 167
| 0
|
import re
import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey
from ..utils import logging
UpperCamelCase_ = logging.get_logger(__name__)
def _UpperCAmelCase ( A ):
'''simple docstring'''
UpperCAmelCase__ =R"\w+[.]\d+"
UpperCAmelCase__ =re.findall(A , A )
for pat in pats:
UpperCAmelCase__ =key.replace(A , "_".join(pat.split("." ) ) )
return key
def _UpperCAmelCase ( A , A , A ):
'''simple docstring'''
UpperCAmelCase__ =pt_tuple_key[:-1] + ("scale",)
if (
any("norm" in str_ for str_ in pt_tuple_key )
and (pt_tuple_key[-1] == "bias")
and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
):
UpperCAmelCase__ =pt_tuple_key[:-1] + ("scale",)
return renamed_pt_tuple_key, pt_tensor
elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
UpperCAmelCase__ =pt_tuple_key[:-1] + ("scale",)
return renamed_pt_tuple_key, pt_tensor
# embedding
if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
UpperCAmelCase__ =pt_tuple_key[:-1] + ("embedding",)
return renamed_pt_tuple_key, pt_tensor
# conv layer
UpperCAmelCase__ =pt_tuple_key[:-1] + ("kernel",)
if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4:
UpperCAmelCase__ =pt_tensor.transpose(2 , 3 , 1 , 0 )
return renamed_pt_tuple_key, pt_tensor
# linear layer
UpperCAmelCase__ =pt_tuple_key[:-1] + ("kernel",)
if pt_tuple_key[-1] == "weight":
UpperCAmelCase__ =pt_tensor.T
return renamed_pt_tuple_key, pt_tensor
# old PyTorch layer norm weight
UpperCAmelCase__ =pt_tuple_key[:-1] + ("weight",)
if pt_tuple_key[-1] == "gamma":
return renamed_pt_tuple_key, pt_tensor
# old PyTorch layer norm bias
UpperCAmelCase__ =pt_tuple_key[:-1] + ("bias",)
if pt_tuple_key[-1] == "beta":
return renamed_pt_tuple_key, pt_tensor
return pt_tuple_key, pt_tensor
def _UpperCAmelCase ( A , A , A=42 ):
'''simple docstring'''
UpperCAmelCase__ ={k: v.numpy() for k, v in pt_state_dict.items()}
# Step 2: Since the model is stateless, get random Flax params
UpperCAmelCase__ =flax_model.init_weights(PRNGKey(A ) )
UpperCAmelCase__ =flatten_dict(A )
UpperCAmelCase__ ={}
# Need to change some parameters name to match Flax names
for pt_key, pt_tensor in pt_state_dict.items():
UpperCAmelCase__ =rename_key(A )
UpperCAmelCase__ =tuple(renamed_pt_key.split("." ) )
# Correctly rename weight parameters
UpperCAmelCase__ , UpperCAmelCase__ =rename_key_and_reshape_tensor(A , A , A )
if flax_key in random_flax_state_dict:
if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
raise ValueError(
F"""PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape """
F"""{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.""" )
# also add unexpected weight so that warning is thrown
UpperCAmelCase__ =jnp.asarray(A )
return unflatten_dict(A )
| 510
|
from __future__ import annotations
from collections import deque
class snake_case_ :
'''simple docstring'''
def __init__( self, A_ ) -> str:
UpperCAmelCase__ =[]
self.adlist.append(
{"value": "", "next_states": [], "fail_state": 0, "output": []} )
for keyword in keywords:
self.add_keyword(A_ )
self.set_fail_transitions()
def __UpperCAmelCase ( self, A_, A_ ) -> int | None:
for state in self.adlist[current_state]["next_states"]:
if char == self.adlist[state]["value"]:
return state
return None
def __UpperCAmelCase ( self, A_ ) -> None:
UpperCAmelCase__ =0
for character in keyword:
UpperCAmelCase__ =self.find_next_state(A_, A_ )
if next_state is None:
self.adlist.append(
{
"value": character,
"next_states": [],
"fail_state": 0,
"output": [],
} )
self.adlist[current_state]["next_states"].append(len(self.adlist ) - 1 )
UpperCAmelCase__ =len(self.adlist ) - 1
else:
UpperCAmelCase__ =next_state
self.adlist[current_state]["output"].append(A_ )
def __UpperCAmelCase ( self ) -> None:
UpperCAmelCase__ =deque()
for node in self.adlist[0]["next_states"]:
q.append(A_ )
UpperCAmelCase__ =0
while q:
UpperCAmelCase__ =q.popleft()
for child in self.adlist[r]["next_states"]:
q.append(A_ )
UpperCAmelCase__ =self.adlist[r]["fail_state"]
while (
self.find_next_state(A_, self.adlist[child]["value"] ) is None
and state != 0
):
UpperCAmelCase__ =self.adlist[state]["fail_state"]
UpperCAmelCase__ =self.find_next_state(
A_, self.adlist[child]["value"] )
if self.adlist[child]["fail_state"] is None:
UpperCAmelCase__ =0
UpperCAmelCase__ =(
self.adlist[child]["output"]
+ self.adlist[self.adlist[child]["fail_state"]]["output"]
)
def __UpperCAmelCase ( self, A_ ) -> dict[str, list[int]]:
UpperCAmelCase__ ={} # returns a dict with keywords and list of its occurrences
UpperCAmelCase__ =0
for i in range(len(A_ ) ):
while (
self.find_next_state(A_, string[i] ) is None
and current_state != 0
):
UpperCAmelCase__ =self.adlist[current_state]["fail_state"]
UpperCAmelCase__ =self.find_next_state(A_, string[i] )
if next_state is None:
UpperCAmelCase__ =0
else:
UpperCAmelCase__ =next_state
for key in self.adlist[current_state]["output"]:
if key not in result:
UpperCAmelCase__ =[]
result[key].append(i - len(A_ ) + 1 )
return result
if __name__ == "__main__":
import doctest
doctest.testmod()
| 510
| 1
|
from __future__ import annotations
import bisect
def A__ ( _a : list[int] , _a : int , _a : int = 0 , _a : int = -1 ):
'''simple docstring'''
if hi < 0:
snake_case__ : List[Any] =len(_a )
while lo < hi:
snake_case__ : Any =lo + (hi - lo) // 2
if sorted_collection[mid] < item:
snake_case__ : Union[str, Any] =mid + 1
else:
snake_case__ : Tuple =mid
return lo
def A__ ( _a : list[int] , _a : int , _a : int = 0 , _a : int = -1 ):
'''simple docstring'''
if hi < 0:
snake_case__ : Any =len(_a )
while lo < hi:
snake_case__ : Optional[Any] =lo + (hi - lo) // 2
if sorted_collection[mid] <= item:
snake_case__ : List[str] =mid + 1
else:
snake_case__ : Dict =mid
return lo
def A__ ( _a : list[int] , _a : int , _a : int = 0 , _a : int = -1 ):
'''simple docstring'''
sorted_collection.insert(bisect_left(_a , _a , _a , _a ) , _a )
def A__ ( _a : list[int] , _a : int , _a : int = 0 , _a : int = -1 ):
'''simple docstring'''
sorted_collection.insert(bisect_right(_a , _a , _a , _a ) , _a )
def A__ ( _a : list[int] , _a : int ):
'''simple docstring'''
snake_case__ : Union[str, Any] =0
snake_case__ : Any =len(_a ) - 1
while left <= right:
snake_case__ : Optional[int] =left + (right - left) // 2
snake_case__ : List[str] =sorted_collection[midpoint]
if current_item == item:
return midpoint
elif item < current_item:
snake_case__ : Optional[Any] =midpoint - 1
else:
snake_case__ : Tuple =midpoint + 1
return None
def A__ ( _a : list[int] , _a : int ):
'''simple docstring'''
snake_case__ : List[Any] =bisect.bisect_left(_a , _a )
if index != len(_a ) and sorted_collection[index] == item:
return index
return None
def A__ ( _a : list[int] , _a : int , _a : int , _a : int ):
'''simple docstring'''
if right < left:
return None
snake_case__ : int =left + (right - left) // 2
if sorted_collection[midpoint] == item:
return midpoint
elif sorted_collection[midpoint] > item:
return binary_search_by_recursion(_a , _a , _a , midpoint - 1 )
else:
return binary_search_by_recursion(_a , _a , midpoint + 1 , _a )
if __name__ == "__main__":
__lowerCamelCase : Dict = input("""Enter numbers separated by comma:\n""").strip()
__lowerCamelCase : List[Any] = sorted(int(item) for item in user_input.split(""","""))
__lowerCamelCase : Tuple = int(input("""Enter a single number to be found in the list:\n"""))
__lowerCamelCase : int = binary_search(collection, target)
if result is None:
print(F"{target} was not found in {collection}.")
else:
print(F"{target} was found at position {result} in {collection}.")
| 385
|
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tensorflow_text_available, is_torch_available
__lowerCamelCase : Optional[Any] = {
"""configuration_ernie""": ["""ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ErnieConfig""", """ErnieOnnxConfig"""],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
__lowerCamelCase : List[Any] = [
"""ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""ErnieForCausalLM""",
"""ErnieForMaskedLM""",
"""ErnieForMultipleChoice""",
"""ErnieForNextSentencePrediction""",
"""ErnieForPreTraining""",
"""ErnieForQuestionAnswering""",
"""ErnieForSequenceClassification""",
"""ErnieForTokenClassification""",
"""ErnieModel""",
"""ErniePreTrainedModel""",
]
if TYPE_CHECKING:
from .configuration_ernie import ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieConfig, ErnieOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_ernie import (
ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST,
ErnieForCausalLM,
ErnieForMaskedLM,
ErnieForMultipleChoice,
ErnieForNextSentencePrediction,
ErnieForPreTraining,
ErnieForQuestionAnswering,
ErnieForSequenceClassification,
ErnieForTokenClassification,
ErnieModel,
ErniePreTrainedModel,
)
else:
import sys
__lowerCamelCase : Tuple = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 385
| 1
|
import math
def __SCREAMING_SNAKE_CASE ( UpperCamelCase : int ) -> bool:
"""simple docstring"""
return math.sqrt(UpperCamelCase ) * math.sqrt(UpperCamelCase ) == num
def __SCREAMING_SNAKE_CASE ( UpperCamelCase : int ) -> bool:
"""simple docstring"""
a_ = 0
a_ = n
while left <= right:
a_ = (left + right) // 2
if mid**2 == n:
return True
elif mid**2 > n:
a_ = mid - 1
else:
a_ = mid + 1
return False
if __name__ == "__main__":
import doctest
doctest.testmod()
| 707
|
from dataclasses import dataclass
from typing import Dict, Optional, Tuple, Union
import torch
import torch.nn as nn
from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, apply_forward_hook
from .attention_processor import AttentionProcessor, AttnProcessor
from .modeling_utils import ModelMixin
from .vae import Decoder, DecoderOutput, DiagonalGaussianDistribution, Encoder
@dataclass
class lowerCamelCase_ ( _SCREAMING_SNAKE_CASE ):
_lowerCamelCase : "DiagonalGaussianDistribution"
class lowerCamelCase_ ( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
_lowerCamelCase : Union[str, Any] = True
@register_to_config
def __init__( self , _SCREAMING_SNAKE_CASE = 3 , _SCREAMING_SNAKE_CASE = 3 , _SCREAMING_SNAKE_CASE = ("DownEncoderBlock2D",) , _SCREAMING_SNAKE_CASE = ("UpDecoderBlock2D",) , _SCREAMING_SNAKE_CASE = (64,) , _SCREAMING_SNAKE_CASE = 1 , _SCREAMING_SNAKE_CASE = "silu" , _SCREAMING_SNAKE_CASE = 4 , _SCREAMING_SNAKE_CASE = 32 , _SCREAMING_SNAKE_CASE = 32 , _SCREAMING_SNAKE_CASE = 0.1_8_2_1_5 , ):
super().__init__()
# pass init params to Encoder
a_ = Encoder(
in_channels=_SCREAMING_SNAKE_CASE , out_channels=_SCREAMING_SNAKE_CASE , down_block_types=_SCREAMING_SNAKE_CASE , block_out_channels=_SCREAMING_SNAKE_CASE , layers_per_block=_SCREAMING_SNAKE_CASE , act_fn=_SCREAMING_SNAKE_CASE , norm_num_groups=_SCREAMING_SNAKE_CASE , double_z=_SCREAMING_SNAKE_CASE , )
# pass init params to Decoder
a_ = Decoder(
in_channels=_SCREAMING_SNAKE_CASE , out_channels=_SCREAMING_SNAKE_CASE , up_block_types=_SCREAMING_SNAKE_CASE , block_out_channels=_SCREAMING_SNAKE_CASE , layers_per_block=_SCREAMING_SNAKE_CASE , norm_num_groups=_SCREAMING_SNAKE_CASE , act_fn=_SCREAMING_SNAKE_CASE , )
a_ = nn.Convad(2 * latent_channels , 2 * latent_channels , 1 )
a_ = nn.Convad(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , 1 )
a_ = False
a_ = False
# only relevant if vae tiling is enabled
a_ = self.config.sample_size
a_ = (
self.config.sample_size[0]
if isinstance(self.config.sample_size , (list, tuple) )
else self.config.sample_size
)
a_ = int(sample_size / (2 ** (len(self.config.block_out_channels ) - 1)) )
a_ = 0.2_5
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE=False ):
if isinstance(_SCREAMING_SNAKE_CASE , (Encoder, Decoder) ):
a_ = value
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE = True ):
a_ = use_tiling
def __magic_name__ ( self ):
self.enable_tiling(_SCREAMING_SNAKE_CASE )
def __magic_name__ ( self ):
a_ = True
def __magic_name__ ( self ):
a_ = False
@property
# Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
def __magic_name__ ( self ):
a_ = {}
def fn_recursive_add_processors(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
if hasattr(_SCREAMING_SNAKE_CASE , """set_processor""" ):
a_ = module.processor
for sub_name, child in module.named_children():
fn_recursive_add_processors(f"""{name}.{sub_name}""" , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
return processors
for name, module in self.named_children():
fn_recursive_add_processors(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
return processors
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE ):
a_ = len(self.attn_processors.keys() )
if isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) and len(_SCREAMING_SNAKE_CASE ) != count:
raise ValueError(
f"""A dict of processors was passed, but the number of processors {len(_SCREAMING_SNAKE_CASE )} does not match the"""
f""" number of attention layers: {count}. Please make sure to pass {count} processor classes.""" )
def fn_recursive_attn_processor(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
if hasattr(_SCREAMING_SNAKE_CASE , """set_processor""" ):
if not isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
module.set_processor(_SCREAMING_SNAKE_CASE )
else:
module.set_processor(processor.pop(f"""{name}.processor""" ) )
for sub_name, child in module.named_children():
fn_recursive_attn_processor(f"""{name}.{sub_name}""" , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
for name, module in self.named_children():
fn_recursive_attn_processor(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
def __magic_name__ ( self ):
self.set_attn_processor(AttnProcessor() )
@apply_forward_hook
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = True ):
if self.use_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size):
return self.tiled_encode(_SCREAMING_SNAKE_CASE , return_dict=_SCREAMING_SNAKE_CASE )
if self.use_slicing and x.shape[0] > 1:
a_ = [self.encoder(_SCREAMING_SNAKE_CASE ) for x_slice in x.split(1 )]
a_ = torch.cat(_SCREAMING_SNAKE_CASE )
else:
a_ = self.encoder(_SCREAMING_SNAKE_CASE )
a_ = self.quant_conv(_SCREAMING_SNAKE_CASE )
a_ = DiagonalGaussianDistribution(_SCREAMING_SNAKE_CASE )
if not return_dict:
return (posterior,)
return AutoencoderKLOutput(latent_dist=_SCREAMING_SNAKE_CASE )
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = True ):
if self.use_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size):
return self.tiled_decode(_SCREAMING_SNAKE_CASE , return_dict=_SCREAMING_SNAKE_CASE )
a_ = self.post_quant_conv(_SCREAMING_SNAKE_CASE )
a_ = self.decoder(_SCREAMING_SNAKE_CASE )
if not return_dict:
return (dec,)
return DecoderOutput(sample=_SCREAMING_SNAKE_CASE )
@apply_forward_hook
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = True ):
if self.use_slicing and z.shape[0] > 1:
a_ = [self._decode(_SCREAMING_SNAKE_CASE ).sample for z_slice in z.split(1 )]
a_ = torch.cat(_SCREAMING_SNAKE_CASE )
else:
a_ = self._decode(_SCREAMING_SNAKE_CASE ).sample
if not return_dict:
return (decoded,)
return DecoderOutput(sample=_SCREAMING_SNAKE_CASE )
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
a_ = min(a.shape[2] , b.shape[2] , _SCREAMING_SNAKE_CASE )
for y in range(_SCREAMING_SNAKE_CASE ):
a_ = a[:, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, y, :] * (y / blend_extent)
return b
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ):
a_ = min(a.shape[3] , b.shape[3] , _SCREAMING_SNAKE_CASE )
for x in range(_SCREAMING_SNAKE_CASE ):
a_ = a[:, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, x] * (x / blend_extent)
return b
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = True ):
a_ = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor) )
a_ = int(self.tile_latent_min_size * self.tile_overlap_factor )
a_ = self.tile_latent_min_size - blend_extent
# Split the image into 512x512 tiles and encode them separately.
a_ = []
for i in range(0 , x.shape[2] , _SCREAMING_SNAKE_CASE ):
a_ = []
for j in range(0 , x.shape[3] , _SCREAMING_SNAKE_CASE ):
a_ = x[:, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size]
a_ = self.encoder(_SCREAMING_SNAKE_CASE )
a_ = self.quant_conv(_SCREAMING_SNAKE_CASE )
row.append(_SCREAMING_SNAKE_CASE )
rows.append(_SCREAMING_SNAKE_CASE )
a_ = []
for i, row in enumerate(_SCREAMING_SNAKE_CASE ):
a_ = []
for j, tile in enumerate(_SCREAMING_SNAKE_CASE ):
# blend the above tile and the left tile
# to the current tile and add the current tile to the result row
if i > 0:
a_ = self.blend_v(rows[i - 1][j] , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
if j > 0:
a_ = self.blend_h(row[j - 1] , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
result_row.append(tile[:, :, :row_limit, :row_limit] )
result_rows.append(torch.cat(_SCREAMING_SNAKE_CASE , dim=3 ) )
a_ = torch.cat(_SCREAMING_SNAKE_CASE , dim=2 )
a_ = DiagonalGaussianDistribution(_SCREAMING_SNAKE_CASE )
if not return_dict:
return (posterior,)
return AutoencoderKLOutput(latent_dist=_SCREAMING_SNAKE_CASE )
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = True ):
a_ = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor) )
a_ = int(self.tile_sample_min_size * self.tile_overlap_factor )
a_ = self.tile_sample_min_size - blend_extent
# Split z into overlapping 64x64 tiles and decode them separately.
# The tiles have an overlap to avoid seams between tiles.
a_ = []
for i in range(0 , z.shape[2] , _SCREAMING_SNAKE_CASE ):
a_ = []
for j in range(0 , z.shape[3] , _SCREAMING_SNAKE_CASE ):
a_ = z[:, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size]
a_ = self.post_quant_conv(_SCREAMING_SNAKE_CASE )
a_ = self.decoder(_SCREAMING_SNAKE_CASE )
row.append(_SCREAMING_SNAKE_CASE )
rows.append(_SCREAMING_SNAKE_CASE )
a_ = []
for i, row in enumerate(_SCREAMING_SNAKE_CASE ):
a_ = []
for j, tile in enumerate(_SCREAMING_SNAKE_CASE ):
# blend the above tile and the left tile
# to the current tile and add the current tile to the result row
if i > 0:
a_ = self.blend_v(rows[i - 1][j] , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
if j > 0:
a_ = self.blend_h(row[j - 1] , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )
result_row.append(tile[:, :, :row_limit, :row_limit] )
result_rows.append(torch.cat(_SCREAMING_SNAKE_CASE , dim=3 ) )
a_ = torch.cat(_SCREAMING_SNAKE_CASE , dim=2 )
if not return_dict:
return (dec,)
return DecoderOutput(sample=_SCREAMING_SNAKE_CASE )
def __magic_name__ ( self , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = False , _SCREAMING_SNAKE_CASE = True , _SCREAMING_SNAKE_CASE = None , ):
a_ = sample
a_ = self.encode(_SCREAMING_SNAKE_CASE ).latent_dist
if sample_posterior:
a_ = posterior.sample(generator=_SCREAMING_SNAKE_CASE )
else:
a_ = posterior.mode()
a_ = self.decode(_SCREAMING_SNAKE_CASE ).sample
if not return_dict:
return (dec,)
return DecoderOutput(sample=_SCREAMING_SNAKE_CASE )
| 403
| 0
|
'''simple docstring'''
import json
import sys
import tempfile
import unittest
from pathlib import Path
import transformers
from transformers import (
CONFIG_MAPPING,
IMAGE_PROCESSOR_MAPPING,
AutoConfig,
AutoImageProcessor,
CLIPConfig,
CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER
sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))
from test_module.custom_configuration import CustomConfig # noqa E402
from test_module.custom_image_processing import CustomImageProcessor # noqa E402
class A ( unittest.TestCase ):
def __lowerCAmelCase ( self ) -> Optional[int]:
_a = 0
def __lowerCAmelCase ( self ) -> Dict:
_a = AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32" )
self.assertIsInstance(snake_case_ , snake_case_ )
def __lowerCAmelCase ( self ) -> List[Any]:
with tempfile.TemporaryDirectory() as tmpdirname:
_a = Path(snake_case_ ) / "preprocessor_config.json"
_a = Path(snake_case_ ) / "config.json"
json.dump(
{"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} , open(snake_case_ , "w" ) , )
json.dump({"model_type": "clip"} , open(snake_case_ , "w" ) )
_a = AutoImageProcessor.from_pretrained(snake_case_ )
self.assertIsInstance(snake_case_ , snake_case_ )
def __lowerCAmelCase ( self ) -> Tuple:
with tempfile.TemporaryDirectory() as tmpdirname:
_a = Path(snake_case_ ) / "preprocessor_config.json"
_a = Path(snake_case_ ) / "config.json"
json.dump(
{"feature_extractor_type": "CLIPFeatureExtractor", "processor_class": "CLIPProcessor"} , open(snake_case_ , "w" ) , )
json.dump({"model_type": "clip"} , open(snake_case_ , "w" ) )
_a = AutoImageProcessor.from_pretrained(snake_case_ )
self.assertIsInstance(snake_case_ , snake_case_ )
def __lowerCAmelCase ( self ) -> Tuple:
with tempfile.TemporaryDirectory() as tmpdirname:
_a = CLIPConfig()
# Create a dummy config file with image_proceesor_type
_a = Path(snake_case_ ) / "preprocessor_config.json"
_a = Path(snake_case_ ) / "config.json"
json.dump(
{"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} , open(snake_case_ , "w" ) , )
json.dump({"model_type": "clip"} , open(snake_case_ , "w" ) )
# remove image_processor_type to make sure config.json alone is enough to load image processor locally
_a = AutoImageProcessor.from_pretrained(snake_case_ ).to_dict()
config_dict.pop("image_processor_type" )
_a = CLIPImageProcessor(**snake_case_ )
# save in new folder
model_config.save_pretrained(snake_case_ )
config.save_pretrained(snake_case_ )
_a = AutoImageProcessor.from_pretrained(snake_case_ )
# make sure private variable is not incorrectly saved
_a = json.loads(config.to_json_string() )
self.assertTrue("_processor_class" not in dict_as_saved )
self.assertIsInstance(snake_case_ , snake_case_ )
def __lowerCAmelCase ( self ) -> Optional[int]:
with tempfile.TemporaryDirectory() as tmpdirname:
_a = Path(snake_case_ ) / "preprocessor_config.json"
json.dump(
{"image_processor_type": "CLIPImageProcessor", "processor_class": "CLIPProcessor"} , open(snake_case_ , "w" ) , )
_a = AutoImageProcessor.from_pretrained(snake_case_ )
self.assertIsInstance(snake_case_ , snake_case_ )
def __lowerCAmelCase ( self ) -> Optional[int]:
with self.assertRaisesRegex(
snake_case_ , "clip-base is not a local folder and is not a valid model identifier" ):
_a = AutoImageProcessor.from_pretrained("clip-base" )
def __lowerCAmelCase ( self ) -> List[str]:
with self.assertRaisesRegex(
snake_case_ , R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)" ):
_a = AutoImageProcessor.from_pretrained(snake_case_ , revision="aaaaaa" )
def __lowerCAmelCase ( self ) -> Any:
with self.assertRaisesRegex(
snake_case_ , "hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json." , ):
_a = AutoImageProcessor.from_pretrained("hf-internal-testing/config-no-model" )
def __lowerCAmelCase ( self ) -> Any:
with self.assertRaises(snake_case_ ):
_a = AutoImageProcessor.from_pretrained("hf-internal-testing/test_dynamic_image_processor" )
# If remote code is disabled, we can't load this config.
with self.assertRaises(snake_case_ ):
_a = AutoImageProcessor.from_pretrained(
"hf-internal-testing/test_dynamic_image_processor" , trust_remote_code=snake_case_ )
_a = AutoImageProcessor.from_pretrained(
"hf-internal-testing/test_dynamic_image_processor" , trust_remote_code=snake_case_ )
self.assertEqual(image_processor.__class__.__name__ , "NewImageProcessor" )
# Test image processor can be reloaded.
with tempfile.TemporaryDirectory() as tmp_dir:
image_processor.save_pretrained(snake_case_ )
_a = AutoImageProcessor.from_pretrained(snake_case_ , trust_remote_code=snake_case_ )
self.assertEqual(reloaded_image_processor.__class__.__name__ , "NewImageProcessor" )
def __lowerCAmelCase ( self ) -> int:
try:
AutoConfig.register("custom" , snake_case_ )
AutoImageProcessor.register(snake_case_ , snake_case_ )
# Trying to register something existing in the Transformers library will raise an error
with self.assertRaises(snake_case_ ):
AutoImageProcessor.register(snake_case_ , snake_case_ )
with tempfile.TemporaryDirectory() as tmpdirname:
_a = Path(snake_case_ ) / "preprocessor_config.json"
_a = Path(snake_case_ ) / "config.json"
json.dump(
{"feature_extractor_type": "CLIPFeatureExtractor", "processor_class": "CLIPProcessor"} , open(snake_case_ , "w" ) , )
json.dump({"model_type": "clip"} , open(snake_case_ , "w" ) )
_a = CustomImageProcessor.from_pretrained(snake_case_ )
# Now that the config is registered, it can be used as any other config with the auto-API
with tempfile.TemporaryDirectory() as tmp_dir:
image_processor.save_pretrained(snake_case_ )
_a = AutoImageProcessor.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 IMAGE_PROCESSOR_MAPPING._extra_content:
del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]
def __lowerCAmelCase ( self ) -> Optional[Any]:
class A ( _snake_case ):
__UpperCAmelCase : int = True
try:
AutoConfig.register("custom" , snake_case_ )
AutoImageProcessor.register(snake_case_ , snake_case_ )
# If remote code is not set, the default is to use local
_a = AutoImageProcessor.from_pretrained("hf-internal-testing/test_dynamic_image_processor" )
self.assertEqual(image_processor.__class__.__name__ , "NewImageProcessor" )
self.assertTrue(image_processor.is_local )
# If remote code is disabled, we load the local one.
_a = AutoImageProcessor.from_pretrained(
"hf-internal-testing/test_dynamic_image_processor" , trust_remote_code=snake_case_ )
self.assertEqual(image_processor.__class__.__name__ , "NewImageProcessor" )
self.assertTrue(image_processor.is_local )
# If remote is enabled, we load from the Hub
_a = AutoImageProcessor.from_pretrained(
"hf-internal-testing/test_dynamic_image_processor" , trust_remote_code=snake_case_ )
self.assertEqual(image_processor.__class__.__name__ , "NewImageProcessor" )
self.assertTrue(not hasattr(snake_case_ , "is_local" ) )
finally:
if "custom" in CONFIG_MAPPING._extra_content:
del CONFIG_MAPPING._extra_content["custom"]
if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]
| 131
|
'''simple docstring'''
from __future__ import annotations
class __a :
def __init__( self : Optional[int] ,lowerCamelCase : list[list[int]] ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = TypeError(
"""Matrices must be formed from a list of zero or more lists containing at """
"""least one and the same number of values, each of which must be of type """
"""int or float.""" )
if len(lowerCamelCase ) != 0:
__SCREAMING_SNAKE_CASE = len(rows[0] )
if cols == 0:
raise error
for row in rows:
if len(lowerCamelCase ) != cols:
raise error
for value in row:
if not isinstance(lowerCamelCase ,(int, float) ):
raise error
__SCREAMING_SNAKE_CASE = rows
else:
__SCREAMING_SNAKE_CASE = []
def UpperCAmelCase__ ( self : Optional[Any] ):
'''simple docstring'''
return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]
@property
def UpperCAmelCase__ ( self : Any ):
'''simple docstring'''
return len(self.rows )
@property
def UpperCAmelCase__ ( self : Union[str, Any] ):
'''simple docstring'''
return len(self.rows[0] )
@property
def UpperCAmelCase__ ( self : Dict ):
'''simple docstring'''
return (self.num_rows, self.num_columns)
@property
def UpperCAmelCase__ ( self : int ):
'''simple docstring'''
return self.order[0] == self.order[1]
def UpperCAmelCase__ ( self : List[str] ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = [
[0 if column_num != row_num else 1 for column_num in range(self.num_rows )]
for row_num in range(self.num_rows )
]
return Matrix(lowerCamelCase )
def UpperCAmelCase__ ( self : str ):
'''simple docstring'''
if not self.is_square:
return 0
if self.order == (0, 0):
return 1
if self.order == (1, 1):
return int(self.rows[0][0] )
if self.order == (2, 2):
return int(
(self.rows[0][0] * self.rows[1][1])
- (self.rows[0][1] * self.rows[1][0]) )
else:
return sum(
self.rows[0][column] * self.cofactors().rows[0][column]
for column in range(self.num_columns ) )
def UpperCAmelCase__ ( self : Any ):
'''simple docstring'''
return bool(self.determinant() )
def UpperCAmelCase__ ( self : Union[str, Any] ,lowerCamelCase : int ,lowerCamelCase : int ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = [
[
self.rows[other_row][other_column]
for other_column in range(self.num_columns )
if other_column != column
]
for other_row in range(self.num_rows )
if other_row != row
]
return Matrix(lowerCamelCase ).determinant()
def UpperCAmelCase__ ( self : str ,lowerCamelCase : int ,lowerCamelCase : int ):
'''simple docstring'''
if (row + column) % 2 == 0:
return self.get_minor(lowerCamelCase ,lowerCamelCase )
return -1 * self.get_minor(lowerCamelCase ,lowerCamelCase )
def UpperCAmelCase__ ( self : List[Any] ):
'''simple docstring'''
return Matrix(
[
[self.get_minor(lowerCamelCase ,lowerCamelCase ) for column in range(self.num_columns )]
for row in range(self.num_rows )
] )
def UpperCAmelCase__ ( self : int ):
'''simple docstring'''
return Matrix(
[
[
self.minors().rows[row][column]
if (row + column) % 2 == 0
else self.minors().rows[row][column] * -1
for column in range(self.minors().num_columns )
]
for row in range(self.minors().num_rows )
] )
def UpperCAmelCase__ ( self : int ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = [
[self.cofactors().rows[column][row] for column in range(self.num_columns )]
for row in range(self.num_rows )
]
return Matrix(lowerCamelCase )
def UpperCAmelCase__ ( self : Optional[int] ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = self.determinant()
if not determinant:
raise TypeError("""Only matrices with a non-zero determinant have an inverse""" )
return self.adjugate() * (1 / determinant)
def __repr__( self : List[Any] ):
'''simple docstring'''
return str(self.rows )
def __str__( self : List[str] ):
'''simple docstring'''
if self.num_rows == 0:
return "[]"
if self.num_rows == 1:
return "[[" + ". ".join(str(self.rows[0] ) ) + "]]"
return (
"["
+ "\n ".join(
[
"""[""" + """. """.join([str(lowerCamelCase ) for value in row] ) + """.]"""
for row in self.rows
] )
+ "]"
)
def UpperCAmelCase__ ( self : Dict ,lowerCamelCase : list[int] ,lowerCamelCase : int | None = None ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = TypeError("""Row must be a list containing all ints and/or floats""" )
if not isinstance(lowerCamelCase ,lowerCamelCase ):
raise type_error
for value in row:
if not isinstance(lowerCamelCase ,(int, float) ):
raise type_error
if len(lowerCamelCase ) != self.num_columns:
raise ValueError(
"""Row must be equal in length to the other rows in the matrix""" )
if position is None:
self.rows.append(lowerCamelCase )
else:
__SCREAMING_SNAKE_CASE = self.rows[0:position] + [row] + self.rows[position:]
def UpperCAmelCase__ ( self : Tuple ,lowerCamelCase : list[int] ,lowerCamelCase : int | None = None ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE = TypeError(
"""Column must be a list containing all ints and/or floats""" )
if not isinstance(lowerCamelCase ,lowerCamelCase ):
raise type_error
for value in column:
if not isinstance(lowerCamelCase ,(int, float) ):
raise type_error
if len(lowerCamelCase ) != self.num_rows:
raise ValueError(
"""Column must be equal in length to the other columns in the matrix""" )
if position is None:
__SCREAMING_SNAKE_CASE = [self.rows[i] + [column[i]] for i in range(self.num_rows )]
else:
__SCREAMING_SNAKE_CASE = [
self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
for i in range(self.num_rows )
]
def __eq__( self : int ,lowerCamelCase : object ):
'''simple docstring'''
if not isinstance(lowerCamelCase ,lowerCamelCase ):
return NotImplemented
return self.rows == other.rows
def __ne__( self : Any ,lowerCamelCase : object ):
'''simple docstring'''
return not self == other
def __neg__( self : Any ):
'''simple docstring'''
return self * -1
def __add__( self : List[Any] ,lowerCamelCase : Matrix ):
'''simple docstring'''
if self.order != other.order:
raise ValueError("""Addition requires matrices of the same order""" )
return Matrix(
[
[self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns )]
for i in range(self.num_rows )
] )
def __sub__( self : Any ,lowerCamelCase : Matrix ):
'''simple docstring'''
if self.order != other.order:
raise ValueError("""Subtraction requires matrices of the same order""" )
return Matrix(
[
[self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns )]
for i in range(self.num_rows )
] )
def __mul__( self : Any ,lowerCamelCase : Matrix | int | float ):
'''simple docstring'''
if isinstance(lowerCamelCase ,(int, float) ):
return Matrix(
[[int(element * other ) for element in row] for row in self.rows] )
elif isinstance(lowerCamelCase ,lowerCamelCase ):
if self.num_columns != other.num_rows:
raise ValueError(
"""The number of columns in the first matrix must """
"""be equal to the number of rows in the second""" )
return Matrix(
[
[Matrix.dot_product(lowerCamelCase ,lowerCamelCase ) for column in other.columns()]
for row in self.rows
] )
else:
raise TypeError(
"""A Matrix can only be multiplied by an int, float, or another matrix""" )
def __pow__( self : Optional[int] ,lowerCamelCase : int ):
'''simple docstring'''
if not isinstance(lowerCamelCase ,lowerCamelCase ):
raise TypeError("""A Matrix can only be raised to the power of an int""" )
if not self.is_square:
raise ValueError("""Only square matrices can be raised to a power""" )
if other == 0:
return self.identity()
if other < 0:
if self.is_invertable():
return self.inverse() ** (-other)
raise ValueError(
"""Only invertable matrices can be raised to a negative power""" )
__SCREAMING_SNAKE_CASE = self
for _ in range(other - 1 ):
result *= self
return result
@classmethod
def UpperCAmelCase__ ( cls : str ,lowerCamelCase : list[int] ,lowerCamelCase : list[int] ):
'''simple docstring'''
return sum(row[i] * column[i] for i in range(len(lowerCamelCase ) ) )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 109
| 0
|
"""simple docstring"""
from datetime import datetime
import requests
from bsa import BeautifulSoup
if __name__ == "__main__":
lowerCAmelCase_ = input('''Enter image url: ''').strip()
print(F'''Downloading image from {url} ...''')
lowerCAmelCase_ = BeautifulSoup(requests.get(url).content, '''html.parser''')
# The image URL is in the content field of the first meta tag with property og:image
lowerCAmelCase_ = soup.find('''meta''', {'''property''': '''og:image'''})['''content''']
lowerCAmelCase_ = requests.get(image_url).content
lowerCAmelCase_ = F'''{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg'''
with open(file_name, '''wb''') as fp:
fp.write(image_data)
print(F'''Done. Image saved to disk as {file_name}.''')
| 709
|
"""simple docstring"""
from itertools import product
def __lowerCamelCase ( SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE ) -> list[int]:
"""simple docstring"""
_UpperCAmelCase = sides_number
_UpperCAmelCase = max_face_number * dice_number
_UpperCAmelCase = [0] * (max_total + 1)
_UpperCAmelCase = 1
_UpperCAmelCase = range(SCREAMING_SNAKE_CASE,max_face_number + 1 )
for dice_numbers in product(SCREAMING_SNAKE_CASE,repeat=SCREAMING_SNAKE_CASE ):
_UpperCAmelCase = sum(SCREAMING_SNAKE_CASE )
totals_frequencies[total] += 1
return totals_frequencies
def __lowerCamelCase ( ) -> float:
"""simple docstring"""
_UpperCAmelCase = total_frequency_distribution(
sides_number=4,dice_number=9 )
_UpperCAmelCase = total_frequency_distribution(
sides_number=6,dice_number=6 )
_UpperCAmelCase = 0
_UpperCAmelCase = 9
_UpperCAmelCase = 4 * 9
_UpperCAmelCase = 6
for peter_total in range(SCREAMING_SNAKE_CASE,max_peter_total + 1 ):
peter_wins_count += peter_totals_frequencies[peter_total] * sum(
colin_totals_frequencies[min_colin_total:peter_total] )
_UpperCAmelCase = (4**9) * (6**6)
_UpperCAmelCase = peter_wins_count / total_games_number
_UpperCAmelCase = round(SCREAMING_SNAKE_CASE,ndigits=7 )
return rounded_peter_win_probability
if __name__ == "__main__":
print(F'''{solution() = }''')
| 494
| 0
|
import argparse
import json
import os
from pathlib import Path
import requests
import torch
from transformers import JukeboxConfig, JukeboxModel
from transformers.utils import logging
logging.set_verbosity_info()
A__ = logging.get_logger(__name__)
A__ = '''https://openaipublic.azureedge.net/jukebox/models/'''
A__ = {
'''jukebox-1b-lyrics''': [
'''5b/vqvae.pth.tar''',
'''5b/prior_level_0.pth.tar''',
'''5b/prior_level_1.pth.tar''',
'''1b_lyrics/prior_level_2.pth.tar''',
],
'''jukebox-5b-lyrics''': [
'''5b/vqvae.pth.tar''',
'''5b/prior_level_0.pth.tar''',
'''5b/prior_level_1.pth.tar''',
'''5b_lyrics/prior_level_2.pth.tar''',
],
}
def _lowerCAmelCase ( __lowerCAmelCase ) -> Optional[int]:
"""simple docstring"""
if key.endswith('''.model.1.bias''' ) and len(key.split('''.''' ) ) > 10:
snake_case__ : Union[str, Any] = key.replace('''.model.1.bias''' , '''.conv1d_1.bias''' )
elif key.endswith('''.model.1.weight''' ) and len(key.split('''.''' ) ) > 10:
snake_case__ : Union[str, Any] = key.replace('''.model.1.weight''' , '''.conv1d_1.weight''' )
elif key.endswith('''.model.3.bias''' ) and len(key.split('''.''' ) ) > 10:
snake_case__ : str = key.replace('''.model.3.bias''' , '''.conv1d_2.bias''' )
elif key.endswith('''.model.3.weight''' ) and len(key.split('''.''' ) ) > 10:
snake_case__ : Tuple = key.replace('''.model.3.weight''' , '''.conv1d_2.weight''' )
if "conditioner_blocks.0." in key:
snake_case__ : List[Any] = key.replace('''conditioner_blocks.0''' , '''conditioner_blocks''' )
if "prime_prior" in key:
snake_case__ : List[str] = key.replace('''prime_prior''' , '''encoder''' )
if ".emb." in key and "total" not in key and "absolute" not in key and "relative" not in key:
snake_case__ : Union[str, Any] = key.replace('''.emb.''' , '''.''' )
if key.endswith('''k''' ): # replace vqvae.X.k with vqvae.X.codebook
return key.replace('''.k''' , '''.codebook''' )
if "y_emb." in key:
return key.replace('''y_emb.''' , '''metadata_embedding.''' )
if "x_emb.emb." in key:
snake_case__ : Any = key.replace('''0.x_emb.emb''' , '''embed_tokens''' )
if "prime_state_ln" in key:
return key.replace('''prime_state_ln''' , '''encoder.final_layer_norm''' )
if ".ln" in key:
return key.replace('''.ln''' , '''.layer_norm''' )
if "_ln" in key:
return key.replace('''_ln''' , '''_layer_norm''' )
if "prime_state_proj" in key:
return key.replace('''prime_state_proj''' , '''encoder.proj_in''' )
if "prime_x_out" in key:
return key.replace('''prime_x_out''' , '''encoder.lm_head''' )
if "prior.x_out" in key:
return key.replace('''x_out''' , '''fc_proj_out''' )
if "x_emb" in key:
return key.replace('''x_emb''' , '''embed_tokens''' )
return key
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) -> Optional[Any]:
"""simple docstring"""
snake_case__ : List[Any] = {}
import re
snake_case__ : Union[str, Any] = re.compile(r'''encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)''' )
snake_case__ : Optional[Any] = re.compile(
r'''encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)''' )
snake_case__ : Optional[Any] = re.compile(r'''encoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)''' )
snake_case__ : Dict = re.compile(r'''decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)''' )
snake_case__ : Tuple = re.compile(
r'''decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)''' )
snake_case__ : List[str] = re.compile(r'''decoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)''' )
snake_case__ : Dict = re.compile(r'''conditioner_blocks.(\d*).cond.model.(\d*).(\d).(bias|weight)''' )
snake_case__ : Optional[Any] = re.compile(
r'''conditioner_blocks.(\d*).cond.model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)''' )
snake_case__ : Dict = re.compile(r'''conditioner_blocks.(\d*).cond.model.(\d*).(bias|weight)''' )
for original_key, value in state_dict.items():
# rename vqvae.encoder keys
if re_encoder_block_conv_in.fullmatch(UpperCamelCase__ ):
snake_case__ : int = re_encoder_block_conv_in.match(UpperCamelCase__ )
snake_case__ : Optional[Any] = regex_match.groups()
snake_case__ : Tuple = int(groups[2] ) * 2 + int(groups[3] )
snake_case__ : Optional[Any] = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.{groups[-1]}"""
snake_case__ : Any = re_encoder_block_conv_in.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_encoder_block_resnet.fullmatch(UpperCamelCase__ ):
snake_case__ : List[Any] = re_encoder_block_resnet.match(UpperCamelCase__ )
snake_case__ : List[str] = regex_match.groups()
snake_case__ : Tuple = int(groups[2] ) * 2 + int(groups[3] )
snake_case__ : Any = {'''1''': 1, '''3''': 2}[groups[-2]]
snake_case__ : Any = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}."""
snake_case__ : Optional[int] = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
snake_case__ : Union[str, Any] = prefix + resnet_block
snake_case__ : List[Any] = re_encoder_block_resnet.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_encoder_block_proj_out.fullmatch(UpperCamelCase__ ):
snake_case__ : Any = re_encoder_block_proj_out.match(UpperCamelCase__ )
snake_case__ : List[Any] = regex_match.groups()
snake_case__ : Dict = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.proj_out.{groups[-1]}"""
snake_case__ : Optional[Any] = re_encoder_block_proj_out.sub(UpperCamelCase__ , UpperCamelCase__ )
# rename vqvae.decoder keys
elif re_decoder_block_conv_out.fullmatch(UpperCamelCase__ ):
snake_case__ : Union[str, Any] = re_decoder_block_conv_out.match(UpperCamelCase__ )
snake_case__ : Optional[Any] = regex_match.groups()
snake_case__ : Tuple = int(groups[2] ) * 2 + int(groups[3] ) - 2
snake_case__ : Optional[Any] = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.{groups[-1]}"""
snake_case__ : Optional[Any] = re_decoder_block_conv_out.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_decoder_block_resnet.fullmatch(UpperCamelCase__ ):
snake_case__ : Union[str, Any] = re_decoder_block_resnet.match(UpperCamelCase__ )
snake_case__ : Any = regex_match.groups()
snake_case__ : int = int(groups[2] ) * 2 + int(groups[3] ) - 2
snake_case__ : Tuple = {'''1''': 1, '''3''': 2}[groups[-2]]
snake_case__ : Optional[int] = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}."""
snake_case__ : int = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
snake_case__ : int = prefix + resnet_block
snake_case__ : Dict = re_decoder_block_resnet.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_decoder_block_proj_in.fullmatch(UpperCamelCase__ ):
snake_case__ : Any = re_decoder_block_proj_in.match(UpperCamelCase__ )
snake_case__ : int = regex_match.groups()
snake_case__ : int = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.proj_in.{groups[-1]}"""
snake_case__ : Optional[Any] = re_decoder_block_proj_in.sub(UpperCamelCase__ , UpperCamelCase__ )
# rename prior cond.model to upsampler.upsample_block and resnet
elif re_prior_cond_conv_out.fullmatch(UpperCamelCase__ ):
snake_case__ : Union[str, Any] = re_prior_cond_conv_out.match(UpperCamelCase__ )
snake_case__ : Tuple = regex_match.groups()
snake_case__ : Tuple = int(groups[1] ) * 2 + int(groups[2] ) - 2
snake_case__ : Tuple = f"""conditioner_blocks.upsampler.upsample_block.{block_index}.{groups[-1]}"""
snake_case__ : List[str] = re_prior_cond_conv_out.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_prior_cond_resnet.fullmatch(UpperCamelCase__ ):
snake_case__ : Optional[Any] = re_prior_cond_resnet.match(UpperCamelCase__ )
snake_case__ : str = regex_match.groups()
snake_case__ : Union[str, Any] = int(groups[1] ) * 2 + int(groups[2] ) - 2
snake_case__ : int = {'''1''': 1, '''3''': 2}[groups[-2]]
snake_case__ : Optional[Any] = f"""conditioner_blocks.upsampler.upsample_block.{block_index}."""
snake_case__ : Dict = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}"""
snake_case__ : Tuple = prefix + resnet_block
snake_case__ : int = re_prior_cond_resnet.sub(UpperCamelCase__ , UpperCamelCase__ )
elif re_prior_cond_proj_in.fullmatch(UpperCamelCase__ ):
snake_case__ : List[Any] = re_prior_cond_proj_in.match(UpperCamelCase__ )
snake_case__ : str = regex_match.groups()
snake_case__ : int = f"""conditioner_blocks.upsampler.proj_in.{groups[-1]}"""
snake_case__ : Any = re_prior_cond_proj_in.sub(UpperCamelCase__ , UpperCamelCase__ )
# keep original key
else:
snake_case__ : Tuple = original_key
snake_case__ : Optional[Any] = replace_key(UpperCamelCase__ )
if f"""{key_prefix}.{key}""" not in model_state_dict or key is None:
print(f"""failed converting {original_key} to {key}, does not match""" )
# handle missmatched shape
elif value.shape != model_state_dict[f"""{key_prefix}.{key}"""].shape:
snake_case__ : Optional[int] = model_state_dict[f"""{key_prefix}.{key}"""]
print(f"""{original_key}-> {key} : \nshape {val.shape} and { value.shape}, do not match""" )
snake_case__ : Union[str, Any] = original_key
snake_case__ : Any = original_key
snake_case__ : List[str] = value
return new_dict
@torch.no_grad()
def _lowerCAmelCase ( __lowerCAmelCase=None , __lowerCAmelCase=None ) -> Any:
"""simple docstring"""
for file in MODEL_MAPPING[model_name]:
if not os.path.isfile(f"""{pytorch_dump_folder_path}/{file.split('/' )[-1]}""" ):
snake_case__ : int = requests.get(f"""{PREFIX}{file}""" , allow_redirects=UpperCamelCase__ )
os.makedirs(f"""{pytorch_dump_folder_path}/""" , exist_ok=UpperCamelCase__ )
open(f"""{pytorch_dump_folder_path}/{file.split('/' )[-1]}""" , '''wb''' ).write(r.content )
snake_case__ : Any = MODEL_MAPPING[model_name.split('''/''' )[-1]]
snake_case__ : int = JukeboxConfig.from_pretrained(UpperCamelCase__ )
snake_case__ : List[str] = JukeboxModel(UpperCamelCase__ )
snake_case__ : Any = []
snake_case__ : Dict = {}
for i, dict_name in enumerate(UpperCamelCase__ ):
snake_case__ : Tuple = torch.load(f"""{pytorch_dump_folder_path}/{dict_name.split('/' )[-1]}""" )['''model''']
snake_case__ : List[str] = {}
for k in old_dic.keys():
if k.endswith('''.b''' ):
snake_case__ : Optional[Any] = old_dic[k]
elif k.endswith('''.w''' ):
snake_case__ : int = old_dic[k]
elif "level_2" not in dict_name and "cond.model." in k:
snake_case__ : Optional[Any] = old_dic[k]
else:
snake_case__ : str = old_dic[k]
snake_case__ : Tuple = '''vqvae''' if i == 0 else f"""priors.{3 - i}"""
snake_case__ : Tuple = fix_jukebox_keys(UpperCamelCase__ , model.state_dict() , UpperCamelCase__ , UpperCamelCase__ )
weight_dict.append(UpperCamelCase__ )
snake_case__ : Dict = weight_dict.pop(0 )
model.vqvae.load_state_dict(UpperCamelCase__ )
for i in range(len(UpperCamelCase__ ) ):
model.priors[i].load_state_dict(weight_dict[2 - i] )
Path(UpperCamelCase__ ).mkdir(exist_ok=UpperCamelCase__ )
with open(f"""{pytorch_dump_folder_path}/mapping.json""" , '''w''' ) as txtfile:
json.dump(UpperCamelCase__ , UpperCamelCase__ )
print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" )
model.save_pretrained(UpperCamelCase__ )
return weight_dict
if __name__ == "__main__":
A__ = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--model_name''',
default='''jukebox-5b-lyrics''',
type=str,
help='''Name of the model you\'d like to convert.''',
)
parser.add_argument(
'''--pytorch_dump_folder_path''',
default='''jukebox-5b-lyrics-converted''',
type=str,
help='''Path to the output PyTorch model directory.''',
)
A__ = parser.parse_args()
convert_openai_checkpoint(args.model_name, args.pytorch_dump_folder_path)
| 252
|
'''simple docstring'''
def __lowerCAmelCase ( UpperCamelCase__ , UpperCamelCase__ ) -> float:
return base * power(UpperCamelCase__ , (exponent - 1) ) if exponent else 1
if __name__ == "__main__":
print("Raise base to the power of exponent using recursion...")
__UpperCAmelCase =int(input("Enter the base: ").strip())
__UpperCAmelCase =int(input("Enter the exponent: ").strip())
__UpperCAmelCase =power(base, abs(exponent))
if exponent < 0: # power() does not properly deal w/ negative exponents
__UpperCAmelCase =1 / result
print(f'{base} to the power of {exponent} is {result}')
| 546
| 0
|
from torch import nn
def __snake_case ( _UpperCAmelCase ):
if act_fn in ["swish", "silu"]:
return nn.SiLU()
elif act_fn == "mish":
return nn.Mish()
elif act_fn == "gelu":
return nn.GELU()
else:
raise ValueError(f'Unsupported activation function: {act_fn}' )
| 60
|
def __snake_case ( _UpperCAmelCase , _UpperCAmelCase = False ):
if not isinstance(_UpperCAmelCase , _UpperCAmelCase ):
__a = f'Expected string as input, found {type(_UpperCAmelCase )}'
raise ValueError(_UpperCAmelCase )
if not isinstance(_UpperCAmelCase , _UpperCAmelCase ):
__a = f'Expected boolean as use_pascal parameter, found {type(_UpperCAmelCase )}'
raise ValueError(_UpperCAmelCase )
__a = input_str.split('''_''' )
__a = 0 if use_pascal else 1
__a = words[start_index:]
__a = [word[0].upper() + word[1:] for word in words_to_capitalize]
__a = '''''' if use_pascal else words[0]
return "".join([initial_word, *capitalized_words] )
if __name__ == "__main__":
from doctest import testmod
testmod()
| 60
| 1
|
def __A ( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) -> int:
if len(__lowerCamelCase ) != len(__lowerCamelCase ):
raise ValueError("""The length of profit and weight must be same.""" )
if max_weight <= 0:
raise ValueError("""max_weight must greater than zero.""" )
if any(p < 0 for p in profit ):
raise ValueError("""Profit can not be negative.""" )
if any(w < 0 for w in weight ):
raise ValueError("""Weight can not be negative.""" )
# List created to store profit gained for the 1kg in case of each weight
# respectively. Calculate and append profit/weight for each element.
a = [p / w for p, w in zip(__lowerCamelCase , __lowerCamelCase )]
# Creating a copy of the list and sorting profit/weight in ascending order
a = sorted(__lowerCamelCase )
# declaring useful variables
a = len(__lowerCamelCase )
a = 0
a = 0
a = 0
# loop till the total weight do not reach max limit e.g. 15 kg and till i<length
while limit <= max_weight and i < length:
# flag value for encountered greatest element in sorted_profit_by_weight
a = sorted_profit_by_weight[length - i - 1]
a = profit_by_weight.index(__lowerCamelCase )
a = -1
# check if the weight encountered is less than the total weight
# encountered before.
if max_weight - limit >= weight[index]:
limit += weight[index]
# Adding profit gained for the given weight 1 ===
# weight[index]/weight[index]
gain += 1 * profit[index]
else:
# Since the weight encountered is greater than limit, therefore take the
# required number of remaining kgs and calculate profit for it.
# weight remaining / weight[index]
gain += (max_weight - limit) / weight[index] * profit[index]
break
i += 1
return gain
if __name__ == "__main__":
print(
"Input profits, weights, and then max_weight (all positive ints) separated by "
"spaces."
)
__UpperCamelCase : Dict = [int(x) for x in input("Input profits separated by spaces: ").split()]
__UpperCamelCase : str = [int(x) for x in input("Input weights separated by spaces: ").split()]
__UpperCamelCase : Tuple = int(input("Max weight allowed: "))
# Function Call
calc_profit(profit, weight, max_weight)
| 468
|
import os
def __A ( ) -> Dict:
with open(os.path.dirname(__lowerCamelCase ) + """/p022_names.txt""" ) as file:
a = str(file.readlines()[0] )
a = names.replace("""\"""" , """""" ).split(""",""" )
names.sort()
a = 0
a = 0
for i, name in enumerate(__lowerCamelCase ):
for letter in name:
name_score += ord(__lowerCamelCase ) - 64
total_score += (i + 1) * name_score
a = 0
return total_score
if __name__ == "__main__":
print(solution())
| 468
| 1
|
'''simple docstring'''
from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments
def _SCREAMING_SNAKE_CASE ( ):
_lowercase = HfArgumentParser(snake_case_ )
_lowercase = parser.parse_args_into_dataclasses()[0]
_lowercase = TensorFlowBenchmark(args=snake_case_ )
try:
_lowercase = parser.parse_args_into_dataclasses()[0]
except ValueError as e:
_lowercase = """Arg --no_{0} is no longer used, please use --no-{0} instead."""
_lowercase = """ """.join(str(snake_case_ ).split(""" """ )[:-1] )
_lowercase = """"""
_lowercase = eval(str(snake_case_ ).split(""" """ )[-1] )
_lowercase = []
for arg in depreciated_args:
# arg[2:] removes '--'
if arg[2:] in TensorFlowBenchmark.deprecated_args:
# arg[5:] removes '--no_'
full_error_msg += arg_error_msg.format(arg[5:] )
else:
wrong_args.append(snake_case_ )
if len(snake_case_ ) > 0:
_lowercase = full_error_msg + begin_error_msg + str(snake_case_ )
raise ValueError(snake_case_ )
benchmark.run()
if __name__ == "__main__":
main()
| 713
|
'''simple docstring'''
def _SCREAMING_SNAKE_CASE ( snake_case_ ):
if n_term == "":
return []
_lowercase = []
for temp in range(int(snake_case_ ) ):
series.append(F"""1/{temp + 1}""" if series else """1""" )
return series
if __name__ == "__main__":
_lowerCamelCase = input('Enter the last number (nth term) of the Harmonic Series')
print('Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n')
print(harmonic_series(nth_term))
| 572
| 0
|
"""simple docstring"""
import inspect
from typing import Callable, List, Optional, Union
import torch
from transformers import (
CLIPImageProcessor,
CLIPTextModel,
CLIPTokenizer,
WhisperForConditionalGeneration,
WhisperProcessor,
)
from diffusers import (
AutoencoderKL,
DDIMScheduler,
DiffusionPipeline,
LMSDiscreteScheduler,
PNDMScheduler,
UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import logging
UpperCAmelCase = logging.get_logger(__name__) # pylint: disable=invalid-name
class lowercase__ ( A_ ):
def __init__( self , 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]:
super().__init__()
if safety_checker is None:
logger.warning(
F'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure'
""" that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"""
""" results in services or applications open to the public. Both the diffusers team and Hugging Face"""
""" strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"""
""" it only for use-cases that involve analyzing network behavior or auditing its results. For more"""
""" information, please have a look at https://github.com/huggingface/diffusers/pull/254 .""")
self.register_modules(
speech_model=SCREAMING_SNAKE_CASE , speech_processor=SCREAMING_SNAKE_CASE , vae=SCREAMING_SNAKE_CASE , text_encoder=SCREAMING_SNAKE_CASE , tokenizer=SCREAMING_SNAKE_CASE , unet=SCREAMING_SNAKE_CASE , scheduler=SCREAMING_SNAKE_CASE , feature_extractor=SCREAMING_SNAKE_CASE , )
def UpperCamelCase_ ( self , SCREAMING_SNAKE_CASE = "auto") -> Dict:
if slice_size == "auto":
_lowerCamelCase : int = self.unet.config.attention_head_dim // 2
self.unet.set_attention_slice(SCREAMING_SNAKE_CASE)
def UpperCamelCase_ ( self) -> Any:
self.enable_attention_slicing(SCREAMING_SNAKE_CASE)
@torch.no_grad()
def __call__( self , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE=1_6000 , SCREAMING_SNAKE_CASE = 512 , SCREAMING_SNAKE_CASE = 512 , SCREAMING_SNAKE_CASE = 50 , SCREAMING_SNAKE_CASE = 7.5 , SCREAMING_SNAKE_CASE = None , SCREAMING_SNAKE_CASE = 1 , SCREAMING_SNAKE_CASE = 0.0 , SCREAMING_SNAKE_CASE = None , SCREAMING_SNAKE_CASE = None , SCREAMING_SNAKE_CASE = "pil" , SCREAMING_SNAKE_CASE = True , SCREAMING_SNAKE_CASE = None , SCREAMING_SNAKE_CASE = 1 , **SCREAMING_SNAKE_CASE , ) -> Dict:
_lowerCamelCase : Dict = self.speech_processor.feature_extractor(
SCREAMING_SNAKE_CASE , return_tensors="""pt""" , sampling_rate=SCREAMING_SNAKE_CASE).input_features.to(self.device)
_lowerCamelCase : Union[str, Any] = self.speech_model.generate(SCREAMING_SNAKE_CASE , max_length=48_0000)
_lowerCamelCase : Optional[int] = self.speech_processor.tokenizer.batch_decode(SCREAMING_SNAKE_CASE , skip_special_tokens=SCREAMING_SNAKE_CASE , normalize=SCREAMING_SNAKE_CASE)[
0
]
if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE):
_lowerCamelCase : Tuple = 1
elif isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE):
_lowerCamelCase : Union[str, Any] = len(SCREAMING_SNAKE_CASE)
else:
raise ValueError(F'`prompt` has to be of type `str` or `list` but is {type(SCREAMING_SNAKE_CASE)}')
if height % 8 != 0 or width % 8 != 0:
raise ValueError(F'`height` and `width` have to be divisible by 8 but are {height} and {width}.')
if (callback_steps is None) or (
callback_steps is not None and (not isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE) or callback_steps <= 0)
):
raise ValueError(
F'`callback_steps` has to be a positive integer but is {callback_steps} of type'
F' {type(SCREAMING_SNAKE_CASE)}.')
# get prompt text embeddings
_lowerCamelCase : Tuple = self.tokenizer(
SCREAMING_SNAKE_CASE , padding="""max_length""" , max_length=self.tokenizer.model_max_length , return_tensors="""pt""" , )
_lowerCamelCase : Any = text_inputs.input_ids
if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
_lowerCamelCase : Union[str, Any] = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :])
logger.warning(
"""The following part of your input was truncated because CLIP can only handle sequences up to"""
F' {self.tokenizer.model_max_length} tokens: {removed_text}')
_lowerCamelCase : int = text_input_ids[:, : self.tokenizer.model_max_length]
_lowerCamelCase : Union[str, Any] = self.text_encoder(text_input_ids.to(self.device))[0]
# duplicate text embeddings for each generation per prompt, using mps friendly method
_lowerCamelCase , _lowerCamelCase , _lowerCamelCase : int = text_embeddings.shape
_lowerCamelCase : Optional[int] = text_embeddings.repeat(1 , SCREAMING_SNAKE_CASE , 1)
_lowerCamelCase : Optional[int] = text_embeddings.view(bs_embed * num_images_per_prompt , SCREAMING_SNAKE_CASE , -1)
# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
# corresponds to doing no classifier free guidance.
_lowerCamelCase : Optional[int] = guidance_scale > 1.0
# get unconditional embeddings for classifier free guidance
if do_classifier_free_guidance:
_lowerCamelCase : List[str]
if negative_prompt is None:
_lowerCamelCase : List[Any] = [""""""] * batch_size
elif type(SCREAMING_SNAKE_CASE) is not type(SCREAMING_SNAKE_CASE):
raise TypeError(
F'`negative_prompt` should be the same type to `prompt`, but got {type(SCREAMING_SNAKE_CASE)} !='
F' {type(SCREAMING_SNAKE_CASE)}.')
elif isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE):
_lowerCamelCase : Optional[Any] = [negative_prompt]
elif batch_size != len(SCREAMING_SNAKE_CASE):
raise ValueError(
F'`negative_prompt`: {negative_prompt} has batch size {len(SCREAMING_SNAKE_CASE)}, but `prompt`:'
F' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
""" the batch size of `prompt`.""")
else:
_lowerCamelCase : Any = negative_prompt
_lowerCamelCase : int = text_input_ids.shape[-1]
_lowerCamelCase : str = self.tokenizer(
SCREAMING_SNAKE_CASE , padding="""max_length""" , max_length=SCREAMING_SNAKE_CASE , truncation=SCREAMING_SNAKE_CASE , return_tensors="""pt""" , )
_lowerCamelCase : List[Any] = self.text_encoder(uncond_input.input_ids.to(self.device))[0]
# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
_lowerCamelCase : List[Any] = uncond_embeddings.shape[1]
_lowerCamelCase : Optional[int] = uncond_embeddings.repeat(1 , SCREAMING_SNAKE_CASE , 1)
_lowerCamelCase : List[Any] = uncond_embeddings.view(batch_size * num_images_per_prompt , SCREAMING_SNAKE_CASE , -1)
# For classifier free guidance, we need to do two forward passes.
# Here we concatenate the unconditional and text embeddings into a single batch
# to avoid doing two forward passes
_lowerCamelCase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings])
# get the initial random noise unless the user supplied it
# Unlike in other pipelines, latents need to be generated in the target device
# for 1-to-1 results reproducibility with the CompVis implementation.
# However this currently doesn't work in `mps`.
_lowerCamelCase : Optional[int] = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
_lowerCamelCase : Any = text_embeddings.dtype
if latents is None:
if self.device.type == "mps":
# randn does not exist on mps
_lowerCamelCase : str = torch.randn(SCREAMING_SNAKE_CASE , generator=SCREAMING_SNAKE_CASE , device="""cpu""" , dtype=SCREAMING_SNAKE_CASE).to(
self.device)
else:
_lowerCamelCase : List[str] = torch.randn(SCREAMING_SNAKE_CASE , generator=SCREAMING_SNAKE_CASE , device=self.device , dtype=SCREAMING_SNAKE_CASE)
else:
if latents.shape != latents_shape:
raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {latents_shape}')
_lowerCamelCase : str = latents.to(self.device)
# set timesteps
self.scheduler.set_timesteps(SCREAMING_SNAKE_CASE)
# Some schedulers like PNDM have timesteps as arrays
# It's more optimized to move all timesteps to correct device beforehand
_lowerCamelCase : Union[str, Any] = self.scheduler.timesteps.to(self.device)
# scale the initial noise by the standard deviation required by the scheduler
_lowerCamelCase : Any = latents * self.scheduler.init_noise_sigma
# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
# and should be between [0, 1]
_lowerCamelCase : str = """eta""" in set(inspect.signature(self.scheduler.step).parameters.keys())
_lowerCamelCase : Dict = {}
if accepts_eta:
_lowerCamelCase : Any = eta
for i, t in enumerate(self.progress_bar(SCREAMING_SNAKE_CASE)):
# expand the latents if we are doing classifier free guidance
_lowerCamelCase : Optional[int] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
_lowerCamelCase : str = self.scheduler.scale_model_input(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE)
# predict the noise residual
_lowerCamelCase : str = self.unet(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , encoder_hidden_states=SCREAMING_SNAKE_CASE).sample
# perform guidance
if do_classifier_free_guidance:
_lowerCamelCase , _lowerCamelCase : Dict = noise_pred.chunk(2)
_lowerCamelCase : int = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
# compute the previous noisy sample x_t -> x_t-1
_lowerCamelCase : Tuple = self.scheduler.step(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , **SCREAMING_SNAKE_CASE).prev_sample
# call the callback, if provided
if callback is not None and i % callback_steps == 0:
callback(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE)
_lowerCamelCase : Dict = 1 / 0.1_82_15 * latents
_lowerCamelCase : Tuple = self.vae.decode(SCREAMING_SNAKE_CASE).sample
_lowerCamelCase : int = (image / 2 + 0.5).clamp(0 , 1)
# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
_lowerCamelCase : Optional[Any] = image.cpu().permute(0 , 2 , 3 , 1).float().numpy()
if output_type == "pil":
_lowerCamelCase : Optional[Any] = self.numpy_to_pil(SCREAMING_SNAKE_CASE)
if not return_dict:
return image
return StableDiffusionPipelineOutput(images=SCREAMING_SNAKE_CASE , nsfw_content_detected=SCREAMING_SNAKE_CASE)
| 88
|
"""simple docstring"""
import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional
import torch
from datasets import load_dataset
from torchvision.transforms import Compose, Lambda, Normalize, RandomHorizontalFlip, RandomResizedCrop, ToTensor
from torchvision.transforms.functional import InterpolationMode
import transformers
from transformers import (
HfArgumentParser,
Trainer,
TrainingArguments,
ViTImageProcessor,
ViTMAEConfig,
ViTMAEForPreTraining,
)
from transformers.trainer_utils import get_last_checkpoint
from transformers.utils import check_min_version, send_example_telemetry
from transformers.utils.versions import require_version
UpperCAmelCase = logging.getLogger(__name__)
# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
check_min_version("""4.31.0""")
require_version("""datasets>=1.8.0""", """To fix: pip install -r examples/pytorch/image-pretraining/requirements.txt""")
@dataclass
class lowercase__ :
__UpperCAmelCase = field(
default='''cifar10''' ,metadata={'''help''': '''Name of a dataset from the datasets package'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={'''help''': '''The column name of the images in the files.'''} )
__UpperCAmelCase = field(default=A_ ,metadata={'''help''': '''A folder containing the training data.'''} )
__UpperCAmelCase = field(default=A_ ,metadata={'''help''': '''A folder containing the validation data.'''} )
__UpperCAmelCase = field(
default=0.1_5 ,metadata={'''help''': '''Percent to split off of train for validation.'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={
'''help''': (
'''For debugging purposes or quicker training, truncate the number of training examples to this '''
'''value if set.'''
)
} ,)
__UpperCAmelCase = field(
default=A_ ,metadata={
'''help''': (
'''For debugging purposes or quicker training, truncate the number of evaluation examples to this '''
'''value if set.'''
)
} ,)
def UpperCamelCase_ ( self) -> Any:
_lowerCamelCase : Any = {}
if self.train_dir is not None:
_lowerCamelCase : int = self.train_dir
if self.validation_dir is not None:
_lowerCamelCase : Tuple = self.validation_dir
_lowerCamelCase : Optional[int] = data_files if data_files else None
@dataclass
class lowercase__ :
__UpperCAmelCase = field(
default=A_ ,metadata={
'''help''': (
'''The model checkpoint for weights initialization.Don\'t set if you want to train a model from scratch.'''
)
} ,)
__UpperCAmelCase = field(
default=A_ ,metadata={'''help''': '''Pretrained config name or path if not the same as model_name_or_path'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={
'''help''': (
'''Override some existing default config settings when a model is trained from scratch. Example: '''
'''n_embd=10,resid_pdrop=0.2,scale_attn_weights=false,summary_type=cls_index'''
)
} ,)
__UpperCAmelCase = field(
default=A_ ,metadata={'''help''': '''Where do you want to store the pretrained models downloaded from s3'''} )
__UpperCAmelCase = field(
default='''main''' ,metadata={'''help''': '''The specific model version to use (can be a branch name, tag name or commit id).'''} ,)
__UpperCAmelCase = field(default=A_ ,metadata={'''help''': '''Name or path of preprocessor config.'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={
'''help''': (
'''Will use the token generated when running `huggingface-cli login` (necessary to use this script '''
'''with private models).'''
)
} ,)
__UpperCAmelCase = field(
default=0.7_5 ,metadata={'''help''': '''The ratio of the number of masked tokens in the input sequence.'''} )
__UpperCAmelCase = field(
default=A_ ,metadata={'''help''': '''Whether or not to train with normalized pixel values as target.'''} )
@dataclass
class lowercase__ ( A_ ):
__UpperCAmelCase = field(
default=1e-3 ,metadata={'''help''': '''Base learning rate: absolute_lr = base_lr * total_batch_size / 256.'''} )
def _snake_case ( __snake_case : Optional[Any] ):
"""simple docstring"""
_lowerCamelCase : int = torch.stack([example["""pixel_values"""] for example in examples] )
return {"pixel_values": pixel_values}
def _snake_case ( ):
"""simple docstring"""
_lowerCamelCase : Tuple = HfArgumentParser((ModelArguments, DataTrainingArguments, CustomTrainingArguments) )
if len(sys.argv ) == 2 and sys.argv[1].endswith(""".json""" ):
# If we pass only one argument to the script and it's the path to a json file,
# let's parse it to get our arguments.
_lowerCamelCase , _lowerCamelCase , _lowerCamelCase : Union[str, Any] = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) )
else:
_lowerCamelCase , _lowerCamelCase , _lowerCamelCase : Dict = parser.parse_args_into_dataclasses()
# Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
# information sent is the one passed as arguments along with your Python/PyTorch versions.
send_example_telemetry("""run_mae""" , __snake_case , __snake_case )
# Setup logging
logging.basicConfig(
format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , handlers=[logging.StreamHandler(sys.stdout )] , )
if training_args.should_log:
# The default of training_args.log_level is passive, so we set log level at info here to have that default.
transformers.utils.logging.set_verbosity_info()
_lowerCamelCase : Union[str, Any] = training_args.get_process_log_level()
logger.setLevel(__snake_case )
transformers.utils.logging.set_verbosity(__snake_case )
transformers.utils.logging.enable_default_handler()
transformers.utils.logging.enable_explicit_format()
# Log on each process the small summary:
logger.warning(
F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}'
+ F'distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}' )
logger.info(F'Training/evaluation parameters {training_args}' )
# Detecting last checkpoint.
_lowerCamelCase : List[Any] = None
if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir:
_lowerCamelCase : Optional[int] = get_last_checkpoint(training_args.output_dir )
if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0:
raise ValueError(
F'Output directory ({training_args.output_dir}) already exists and is not empty. '
"""Use --overwrite_output_dir to overcome.""" )
elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
logger.info(
F'Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change '
"""the `--output_dir` or add `--overwrite_output_dir` to train from scratch.""" )
# Initialize our dataset.
_lowerCamelCase : Optional[Any] = load_dataset(
data_args.dataset_name , data_args.dataset_config_name , data_files=data_args.data_files , cache_dir=model_args.cache_dir , use_auth_token=True if model_args.use_auth_token else None , )
# If we don't have a validation split, split off a percentage of train as validation.
_lowerCamelCase : Tuple = None if """validation""" in ds.keys() else data_args.train_val_split
if isinstance(data_args.train_val_split , __snake_case ) and data_args.train_val_split > 0.0:
_lowerCamelCase : List[str] = ds["""train"""].train_test_split(data_args.train_val_split )
_lowerCamelCase : Union[str, Any] = split["""train"""]
_lowerCamelCase : Optional[int] = split["""test"""]
# Load pretrained model and image processor
#
# Distributed training:
# The .from_pretrained methods guarantee that only one local process can concurrently
# download model & vocab.
_lowerCamelCase : str = {
"""cache_dir""": model_args.cache_dir,
"""revision""": model_args.model_revision,
"""use_auth_token""": True if model_args.use_auth_token else None,
}
if model_args.config_name:
_lowerCamelCase : Dict = ViTMAEConfig.from_pretrained(model_args.config_name , **__snake_case )
elif model_args.model_name_or_path:
_lowerCamelCase : Union[str, Any] = ViTMAEConfig.from_pretrained(model_args.model_name_or_path , **__snake_case )
else:
_lowerCamelCase : Optional[Any] = ViTMAEConfig()
logger.warning("""You are instantiating a new config instance from scratch.""" )
if model_args.config_overrides is not None:
logger.info(F'Overriding config: {model_args.config_overrides}' )
config.update_from_string(model_args.config_overrides )
logger.info(F'New config: {config}' )
# adapt config
config.update(
{
"""mask_ratio""": model_args.mask_ratio,
"""norm_pix_loss""": model_args.norm_pix_loss,
} )
# create image processor
if model_args.image_processor_name:
_lowerCamelCase : str = ViTImageProcessor.from_pretrained(model_args.image_processor_name , **__snake_case )
elif model_args.model_name_or_path:
_lowerCamelCase : Dict = ViTImageProcessor.from_pretrained(model_args.model_name_or_path , **__snake_case )
else:
_lowerCamelCase : Union[str, Any] = ViTImageProcessor()
# create model
if model_args.model_name_or_path:
_lowerCamelCase : List[Any] = ViTMAEForPreTraining.from_pretrained(
model_args.model_name_or_path , from_tf=bool(""".ckpt""" in model_args.model_name_or_path ) , config=__snake_case , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , )
else:
logger.info("""Training new model from scratch""" )
_lowerCamelCase : Union[str, Any] = ViTMAEForPreTraining(__snake_case )
if training_args.do_train:
_lowerCamelCase : List[Any] = ds["""train"""].column_names
else:
_lowerCamelCase : Union[str, Any] = ds["""validation"""].column_names
if data_args.image_column_name is not None:
_lowerCamelCase : str = data_args.image_column_name
elif "image" in column_names:
_lowerCamelCase : Optional[Any] = """image"""
elif "img" in column_names:
_lowerCamelCase : List[Any] = """img"""
else:
_lowerCamelCase : str = column_names[0]
# transformations as done in original MAE paper
# source: https://github.com/facebookresearch/mae/blob/main/main_pretrain.py
if "shortest_edge" in image_processor.size:
_lowerCamelCase : Dict = image_processor.size["""shortest_edge"""]
else:
_lowerCamelCase : List[Any] = (image_processor.size["""height"""], image_processor.size["""width"""])
_lowerCamelCase : Tuple = Compose(
[
Lambda(lambda __snake_case : img.convert("""RGB""" ) if img.mode != "RGB" else img ),
RandomResizedCrop(__snake_case , scale=(0.2, 1.0) , interpolation=InterpolationMode.BICUBIC ),
RandomHorizontalFlip(),
ToTensor(),
Normalize(mean=image_processor.image_mean , std=image_processor.image_std ),
] )
def preprocess_images(__snake_case : Optional[Any] ):
_lowerCamelCase : Dict = [transforms(__snake_case ) for image in examples[image_column_name]]
return examples
if training_args.do_train:
if "train" not in ds:
raise ValueError("""--do_train requires a train dataset""" )
if data_args.max_train_samples is not None:
_lowerCamelCase : int = ds["""train"""].shuffle(seed=training_args.seed ).select(range(data_args.max_train_samples ) )
# Set the training transforms
ds["train"].set_transform(__snake_case )
if training_args.do_eval:
if "validation" not in ds:
raise ValueError("""--do_eval requires a validation dataset""" )
if data_args.max_eval_samples is not None:
_lowerCamelCase : Union[str, Any] = (
ds["""validation"""].shuffle(seed=training_args.seed ).select(range(data_args.max_eval_samples ) )
)
# Set the validation transforms
ds["validation"].set_transform(__snake_case )
# Compute absolute learning rate
_lowerCamelCase : Optional[Any] = (
training_args.train_batch_size * training_args.gradient_accumulation_steps * training_args.world_size
)
if training_args.base_learning_rate is not None:
_lowerCamelCase : Tuple = training_args.base_learning_rate * total_train_batch_size / 256
# Initialize our trainer
_lowerCamelCase : Optional[Any] = Trainer(
model=__snake_case , args=__snake_case , train_dataset=ds["""train"""] if training_args.do_train else None , eval_dataset=ds["""validation"""] if training_args.do_eval else None , tokenizer=__snake_case , data_collator=__snake_case , )
# Training
if training_args.do_train:
_lowerCamelCase : Any = None
if training_args.resume_from_checkpoint is not None:
_lowerCamelCase : List[Any] = training_args.resume_from_checkpoint
elif last_checkpoint is not None:
_lowerCamelCase : Union[str, Any] = last_checkpoint
_lowerCamelCase : Optional[Any] = trainer.train(resume_from_checkpoint=__snake_case )
trainer.save_model()
trainer.log_metrics("""train""" , train_result.metrics )
trainer.save_metrics("""train""" , train_result.metrics )
trainer.save_state()
# Evaluation
if training_args.do_eval:
_lowerCamelCase : int = trainer.evaluate()
trainer.log_metrics("""eval""" , __snake_case )
trainer.save_metrics("""eval""" , __snake_case )
# Write model card and (optionally) push to hub
_lowerCamelCase : Optional[Any] = {
"""tasks""": """masked-auto-encoding""",
"""dataset""": data_args.dataset_name,
"""tags""": ["""masked-auto-encoding"""],
}
if training_args.push_to_hub:
trainer.push_to_hub(**__snake_case )
else:
trainer.create_model_card(**__snake_case )
def _snake_case ( __snake_case : Dict ):
"""simple docstring"""
main()
if __name__ == "__main__":
main()
| 88
| 1
|
'''simple docstring'''
import os
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import torch
from torch import nn
from ...models.controlnet import ControlNetModel, ControlNetOutput
from ...models.modeling_utils import ModelMixin
from ...utils import logging
_lowerCAmelCase : Dict = logging.get_logger(__name__)
class snake_case ( __lowerCamelCase ):
"""simple docstring"""
def __init__( self , lowerCamelCase ) -> Tuple:
"""simple docstring"""
super().__init__()
snake_case__ : str = nn.ModuleList(lowerCamelCase )
def lowercase__ ( self , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = False , lowerCamelCase = True , ) -> Union[ControlNetOutput, Tuple]:
"""simple docstring"""
for i, (image, scale, controlnet) in enumerate(zip(lowerCamelCase , lowerCamelCase , self.nets ) ):
snake_case__ ,snake_case__ : Optional[int] = controlnet(
lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , )
# merge samples
if i == 0:
snake_case__ ,snake_case__ : Tuple = down_samples, mid_sample
else:
snake_case__ : Optional[Any] = [
samples_prev + samples_curr
for samples_prev, samples_curr in zip(lowerCamelCase , lowerCamelCase )
]
mid_block_res_sample += mid_sample
return down_block_res_samples, mid_block_res_sample
def lowercase__ ( self , lowerCamelCase , lowerCamelCase = True , lowerCamelCase = None , lowerCamelCase = False , lowerCamelCase = None , ) -> Optional[int]:
"""simple docstring"""
snake_case__ : List[Any] = 0
snake_case__ : Optional[Any] = save_directory
for controlnet in self.nets:
controlnet.save_pretrained(
lowerCamelCase , is_main_process=lowerCamelCase , save_function=lowerCamelCase , safe_serialization=lowerCamelCase , variant=lowerCamelCase , )
idx += 1
snake_case__ : Optional[Any] = model_path_to_save + f'''_{idx}'''
@classmethod
def lowercase__ ( cls , lowerCamelCase , **lowerCamelCase ) -> int:
"""simple docstring"""
snake_case__ : Optional[Any] = 0
snake_case__ : int = []
# load controlnet and append to list until no controlnet directory exists anymore
# first controlnet has to be saved under `./mydirectory/controlnet` to be compliant with `DiffusionPipeline.from_prertained`
# second, third, ... controlnets have to be saved under `./mydirectory/controlnet_1`, `./mydirectory/controlnet_2`, ...
snake_case__ : Optional[Any] = pretrained_model_path
while os.path.isdir(lowerCamelCase ):
snake_case__ : List[Any] = ControlNetModel.from_pretrained(lowerCamelCase , **lowerCamelCase )
controlnets.append(lowerCamelCase )
idx += 1
snake_case__ : Dict = pretrained_model_path + f'''_{idx}'''
logger.info(f'''{len(lowerCamelCase )} controlnets loaded from {pretrained_model_path}.''' )
if len(lowerCamelCase ) == 0:
raise ValueError(
f'''No ControlNets found under {os.path.dirname(lowerCamelCase )}. Expected at least {pretrained_model_path + '_0'}.''' )
return cls(lowerCamelCase )
| 694
|
'''simple docstring'''
import copy
from ...configuration_utils import PretrainedConfig
from ...utils import logging
_lowerCAmelCase : List[Any] = logging.get_logger(__name__)
class snake_case ( __lowerCamelCase ):
"""simple docstring"""
_lowerCAmelCase = 'encoder-decoder'
_lowerCAmelCase = True
def __init__( self , **lowerCamelCase ) -> Optional[Any]:
"""simple docstring"""
super().__init__(**lowerCamelCase )
assert (
"encoder" in kwargs and "decoder" in kwargs
), "Config has to be initialized with encoder and decoder config"
snake_case__ : List[str] = kwargs.pop('''encoder''' )
snake_case__ : Any = encoder_config.pop('''model_type''' )
snake_case__ : List[str] = kwargs.pop('''decoder''' )
snake_case__ : str = decoder_config.pop('''model_type''' )
from ..auto.configuration_auto import AutoConfig
snake_case__ : Tuple = AutoConfig.for_model(lowerCamelCase , **lowerCamelCase )
snake_case__ : Optional[Any] = AutoConfig.for_model(lowerCamelCase , **lowerCamelCase )
snake_case__ : str = True
@classmethod
def lowercase__ ( cls , lowerCamelCase , lowerCamelCase , **lowerCamelCase ) -> PretrainedConfig:
"""simple docstring"""
logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config''' )
snake_case__ : Optional[int] = True
snake_case__ : str = True
return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **lowerCamelCase )
def lowercase__ ( self ) -> Union[str, Any]:
"""simple docstring"""
snake_case__ : List[Any] = copy.deepcopy(self.__dict__ )
snake_case__ : List[Any] = self.encoder.to_dict()
snake_case__ : str = self.decoder.to_dict()
snake_case__ : Any = self.__class__.model_type
return output
| 694
| 1
|
"""simple docstring"""
from typing import List, Optional, Tuple, Union
import torch
from ...models import UNetaDModel
from ...schedulers import ScoreSdeVeScheduler
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
class lowercase__( _UpperCAmelCase ):
'''simple docstring'''
UpperCamelCase = 42
UpperCamelCase = 42
def __init__( self :List[str] , lowerCamelCase_ :UNetaDModel , lowerCamelCase_ :ScoreSdeVeScheduler ) -> int:
'''simple docstring'''
super().__init__()
self.register_modules(unet=lowerCamelCase_ , scheduler=lowerCamelCase_ )
@torch.no_grad()
def __call__( self :int , lowerCamelCase_ :int = 1 , lowerCamelCase_ :int = 20_00 , lowerCamelCase_ :Optional[Union[torch.Generator, List[torch.Generator]]] = None , lowerCamelCase_ :Optional[str] = "pil" , lowerCamelCase_ :bool = True , **lowerCamelCase_ :Union[str, Any] , ) -> Union[ImagePipelineOutput, Tuple]:
'''simple docstring'''
SCREAMING_SNAKE_CASE : Optional[int] = self.unet.config.sample_size
SCREAMING_SNAKE_CASE : List[str] = (batch_size, 3, img_size, img_size)
SCREAMING_SNAKE_CASE : Any = self.unet
SCREAMING_SNAKE_CASE : Dict = randn_tensor(lowerCamelCase_ , generator=lowerCamelCase_ ) * self.scheduler.init_noise_sigma
SCREAMING_SNAKE_CASE : Union[str, Any] = sample.to(self.device )
self.scheduler.set_timesteps(lowerCamelCase_ )
self.scheduler.set_sigmas(lowerCamelCase_ )
for i, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ):
SCREAMING_SNAKE_CASE : Tuple = self.scheduler.sigmas[i] * torch.ones(shape[0] , device=self.device )
# correction step
for _ in range(self.scheduler.config.correct_steps ):
SCREAMING_SNAKE_CASE : Optional[Any] = self.unet(lowerCamelCase_ , lowerCamelCase_ ).sample
SCREAMING_SNAKE_CASE : List[Any] = self.scheduler.step_correct(lowerCamelCase_ , lowerCamelCase_ , generator=lowerCamelCase_ ).prev_sample
# prediction step
SCREAMING_SNAKE_CASE : Any = model(lowerCamelCase_ , lowerCamelCase_ ).sample
SCREAMING_SNAKE_CASE : Optional[Any] = self.scheduler.step_pred(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , generator=lowerCamelCase_ )
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE : Union[str, Any] = output.prev_sample, output.prev_sample_mean
SCREAMING_SNAKE_CASE : List[str] = sample_mean.clamp(0 , 1 )
SCREAMING_SNAKE_CASE : Any = sample.cpu().permute(0 , 2 , 3 , 1 ).numpy()
if output_type == "pil":
SCREAMING_SNAKE_CASE : Any = self.numpy_to_pil(lowerCamelCase_ )
if not return_dict:
return (sample,)
return ImagePipelineOutput(images=lowerCamelCase_ )
| 698
|
"""simple docstring"""
# using dfs for finding eulerian path traversal
def __A ( a_ : Dict , a_ : int , a_ : str , a_ : Optional[Any]=None )-> List[Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE : Optional[Any] = (path or []) + [u]
for v in graph[u]:
if visited_edge[u][v] is False:
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE : str = True, True
SCREAMING_SNAKE_CASE : List[str] = dfs(a_ , a_ , a_ , a_ )
return path
def __A ( a_ : List[str] , a_ : Any )-> Union[str, Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE : int = 0
SCREAMING_SNAKE_CASE : str = -1
for i in range(a_ ):
if i not in graph.keys():
continue
if len(graph[i] ) % 2 == 1:
odd_degree_nodes += 1
SCREAMING_SNAKE_CASE : Tuple = i
if odd_degree_nodes == 0:
return 1, odd_node
if odd_degree_nodes == 2:
return 2, odd_node
return 3, odd_node
def __A ( a_ : Any , a_ : int )-> Any:
'''simple docstring'''
SCREAMING_SNAKE_CASE : Tuple = [[False for _ in range(max_node + 1 )] for _ in range(max_node + 1 )]
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE : List[str] = check_circuit_or_path(a_ , a_ )
if check == 3:
print('''graph is not Eulerian''' )
print('''no path''' )
return
SCREAMING_SNAKE_CASE : Tuple = 1
if check == 2:
SCREAMING_SNAKE_CASE : Optional[int] = odd_node
print('''graph has a Euler path''' )
if check == 1:
print('''graph has a Euler cycle''' )
SCREAMING_SNAKE_CASE : Optional[int] = dfs(a_ , a_ , a_ )
print(a_ )
def __A ( )-> Union[str, Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE : List[Any] = {1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
SCREAMING_SNAKE_CASE : str = {1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
SCREAMING_SNAKE_CASE : str = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
SCREAMING_SNAKE_CASE : int = {1: [2, 3], 2: [1, 3], 3: [1, 2]}
SCREAMING_SNAKE_CASE : int = {
1: [],
2: []
# all degree is zero
}
SCREAMING_SNAKE_CASE : List[str] = 10
check_euler(a_ , a_ )
check_euler(a_ , a_ )
check_euler(a_ , a_ )
check_euler(a_ , a_ )
check_euler(a_ , a_ )
if __name__ == "__main__":
main()
| 698
| 1
|
import unittest
import numpy as np
from transformers.testing_utils import require_pytesseract, require_torch
from transformers.utils import is_pytesseract_available, is_torch_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_pytesseract_available():
from PIL import Image
from transformers import LayoutLMvaImageProcessor
class _lowerCamelCase ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : List[str] , snake_case : Tuple , snake_case : int=7 , snake_case : str=3 , snake_case : Any=18 , snake_case : Dict=30 , snake_case : Optional[Any]=400 , snake_case : str=True , snake_case : List[str]=None , snake_case : List[str]=True , ):
__UpperCamelCase = size if size is not None else {'''height''': 18, '''width''': 18}
__UpperCamelCase = parent
__UpperCamelCase = batch_size
__UpperCamelCase = num_channels
__UpperCamelCase = image_size
__UpperCamelCase = min_resolution
__UpperCamelCase = max_resolution
__UpperCamelCase = do_resize
__UpperCamelCase = size
__UpperCamelCase = apply_ocr
def snake_case ( self : Tuple ):
return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr}
@require_torch
@require_pytesseract
class _lowerCamelCase ( _SCREAMING_SNAKE_CASE , unittest.TestCase ):
"""simple docstring"""
lowerCAmelCase__ : Dict = LayoutLMvaImageProcessor if is_pytesseract_available() else None
def snake_case ( self : Dict ):
__UpperCamelCase = LayoutLMvaImageProcessingTester(self )
@property
def snake_case ( self : Dict ):
return self.image_processor_tester.prepare_image_processor_dict()
def snake_case ( self : Union[str, Any] ):
__UpperCamelCase = 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 , '''apply_ocr''' ) )
def snake_case ( self : Union[str, Any] ):
__UpperCamelCase = self.image_processing_class.from_dict(self.image_processor_dict )
self.assertEqual(image_processor.size , {'''height''': 18, '''width''': 18} )
__UpperCamelCase = self.image_processing_class.from_dict(self.image_processor_dict , size=42 )
self.assertEqual(image_processor.size , {'''height''': 42, '''width''': 42} )
def snake_case ( self : List[str] ):
pass
def snake_case ( self : List[str] ):
# Initialize image_processing
__UpperCamelCase = self.image_processing_class(**self.image_processor_dict )
# create random PIL images
__UpperCamelCase = 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
__UpperCamelCase = image_processing(image_inputs[0] , return_tensors='''pt''' )
self.assertEqual(
encoding.pixel_values.shape , (
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
self.assertIsInstance(encoding.words , snake_case )
self.assertIsInstance(encoding.boxes , snake_case )
# Test batched
__UpperCamelCase = 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.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
def snake_case ( self : Tuple ):
# Initialize image_processing
__UpperCamelCase = self.image_processing_class(**self.image_processor_dict )
# create random numpy tensors
__UpperCamelCase = 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
__UpperCamelCase = 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.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
# Test batched
__UpperCamelCase = 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.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
def snake_case ( self : Union[str, Any] ):
# Initialize image_processing
__UpperCamelCase = self.image_processing_class(**self.image_processor_dict )
# create random PyTorch tensors
__UpperCamelCase = 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
__UpperCamelCase = 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.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
# Test batched
__UpperCamelCase = 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.size['''height'''],
self.image_processor_tester.size['''width'''],
) , )
def snake_case ( self : Optional[int] ):
# with apply_OCR = True
__UpperCamelCase = LayoutLMvaImageProcessor()
from datasets import load_dataset
__UpperCamelCase = load_dataset('''hf-internal-testing/fixtures_docvqa''' , split='''test''' )
__UpperCamelCase = Image.open(ds[0]['''file'''] ).convert('''RGB''' )
__UpperCamelCase = image_processing(snake_case , return_tensors='''pt''' )
self.assertEqual(encoding.pixel_values.shape , (1, 3, 224, 224) )
self.assertEqual(len(encoding.words ) , len(encoding.boxes ) )
# fmt: off
# the words and boxes were obtained with Tesseract 4.1.1
__UpperCamelCase = [['''11:14''', '''to''', '''11:39''', '''a.m''', '''11:39''', '''to''', '''11:44''', '''a.m.''', '''11:44''', '''a.m.''', '''to''', '''12:25''', '''p.m.''', '''12:25''', '''to''', '''12:58''', '''p.m.''', '''12:58''', '''to''', '''4:00''', '''p.m.''', '''2:00''', '''to''', '''5:00''', '''p.m.''', '''Coffee''', '''Break''', '''Coffee''', '''will''', '''be''', '''served''', '''for''', '''men''', '''and''', '''women''', '''in''', '''the''', '''lobby''', '''adjacent''', '''to''', '''exhibit''', '''area.''', '''Please''', '''move''', '''into''', '''exhibit''', '''area.''', '''(Exhibits''', '''Open)''', '''TRRF''', '''GENERAL''', '''SESSION''', '''(PART''', '''|)''', '''Presiding:''', '''Lee''', '''A.''', '''Waller''', '''TRRF''', '''Vice''', '''President''', '''“Introductory''', '''Remarks”''', '''Lee''', '''A.''', '''Waller,''', '''TRRF''', '''Vice''', '''Presi-''', '''dent''', '''Individual''', '''Interviews''', '''with''', '''TRRF''', '''Public''', '''Board''', '''Members''', '''and''', '''Sci-''', '''entific''', '''Advisory''', '''Council''', '''Mem-''', '''bers''', '''Conducted''', '''by''', '''TRRF''', '''Treasurer''', '''Philip''', '''G.''', '''Kuehn''', '''to''', '''get''', '''answers''', '''which''', '''the''', '''public''', '''refrigerated''', '''warehousing''', '''industry''', '''is''', '''looking''', '''for.''', '''Plus''', '''questions''', '''from''', '''the''', '''floor.''', '''Dr.''', '''Emil''', '''M.''', '''Mrak,''', '''University''', '''of''', '''Cal-''', '''ifornia,''', '''Chairman,''', '''TRRF''', '''Board;''', '''Sam''', '''R.''', '''Cecil,''', '''University''', '''of''', '''Georgia''', '''College''', '''of''', '''Agriculture;''', '''Dr.''', '''Stanley''', '''Charm,''', '''Tufts''', '''University''', '''School''', '''of''', '''Medicine;''', '''Dr.''', '''Robert''', '''H.''', '''Cotton,''', '''ITT''', '''Continental''', '''Baking''', '''Company;''', '''Dr.''', '''Owen''', '''Fennema,''', '''University''', '''of''', '''Wis-''', '''consin;''', '''Dr.''', '''Robert''', '''E.''', '''Hardenburg,''', '''USDA.''', '''Questions''', '''and''', '''Answers''', '''Exhibits''', '''Open''', '''Capt.''', '''Jack''', '''Stoney''', '''Room''', '''TRRF''', '''Scientific''', '''Advisory''', '''Council''', '''Meeting''', '''Ballroom''', '''Foyer''']] # noqa: E231
__UpperCamelCase = [[[141, 57, 214, 69], [228, 58, 252, 69], [141, 75, 216, 88], [230, 79, 280, 88], [142, 260, 218, 273], [230, 261, 255, 273], [143, 279, 218, 290], [231, 282, 290, 291], [143, 342, 218, 354], [231, 345, 289, 355], [202, 362, 227, 373], [143, 379, 220, 392], [231, 382, 291, 394], [144, 714, 220, 726], [231, 715, 256, 726], [144, 732, 220, 745], [232, 736, 291, 747], [144, 769, 218, 782], [231, 770, 256, 782], [141, 788, 202, 801], [215, 791, 274, 804], [143, 826, 204, 838], [215, 826, 240, 838], [142, 844, 202, 857], [215, 847, 274, 859], [334, 57, 427, 69], [440, 57, 522, 69], [369, 75, 461, 88], [469, 75, 516, 88], [528, 76, 562, 88], [570, 76, 667, 88], [675, 75, 711, 87], [721, 79, 778, 88], [789, 75, 840, 88], [369, 97, 470, 107], [484, 94, 507, 106], [518, 94, 562, 107], [576, 94, 655, 110], [668, 94, 792, 109], [804, 95, 829, 107], [369, 113, 465, 125], [477, 116, 547, 125], [562, 113, 658, 125], [671, 116, 748, 125], [761, 113, 811, 125], [369, 131, 465, 143], [477, 133, 548, 143], [563, 130, 698, 145], [710, 130, 802, 146], [336, 171, 412, 183], [423, 171, 572, 183], [582, 170, 716, 184], [728, 171, 817, 187], [829, 171, 844, 186], [338, 197, 482, 212], [507, 196, 557, 209], [569, 196, 595, 208], [610, 196, 702, 209], [505, 214, 583, 226], [595, 214, 656, 227], [670, 215, 807, 227], [335, 259, 543, 274], [556, 259, 708, 272], [372, 279, 422, 291], [435, 279, 460, 291], [474, 279, 574, 292], [587, 278, 664, 291], [676, 278, 738, 291], [751, 279, 834, 291], [372, 298, 434, 310], [335, 341, 483, 354], [497, 341, 655, 354], [667, 341, 728, 354], [740, 341, 825, 354], [335, 360, 430, 372], [442, 360, 534, 372], [545, 359, 687, 372], [697, 360, 754, 372], [765, 360, 823, 373], [334, 378, 428, 391], [440, 378, 577, 394], [590, 378, 705, 391], [720, 378, 801, 391], [334, 397, 400, 409], [370, 416, 529, 429], [544, 416, 576, 432], [587, 416, 665, 428], [677, 416, 814, 429], [372, 435, 452, 450], [465, 434, 495, 447], [511, 434, 600, 447], [611, 436, 637, 447], [649, 436, 694, 451], [705, 438, 824, 447], [369, 453, 452, 466], [464, 454, 509, 466], [522, 453, 611, 469], [625, 453, 792, 469], [370, 472, 556, 488], [570, 472, 684, 487], [697, 472, 718, 485], [732, 472, 835, 488], [369, 490, 411, 503], [425, 490, 484, 503], [496, 490, 635, 506], [645, 490, 707, 503], [718, 491, 761, 503], [771, 490, 840, 503], [336, 510, 374, 521], [388, 510, 447, 522], [460, 510, 489, 521], [503, 510, 580, 522], [592, 509, 736, 525], [745, 509, 770, 522], [781, 509, 840, 522], [338, 528, 434, 541], [448, 528, 596, 541], [609, 527, 687, 540], [700, 528, 792, 541], [336, 546, 397, 559], [407, 546, 431, 559], [443, 546, 525, 560], [537, 546, 680, 562], [688, 546, 714, 559], [722, 546, 837, 562], [336, 565, 449, 581], [461, 565, 485, 577], [497, 565, 665, 581], [681, 565, 718, 577], [732, 565, 837, 580], [337, 584, 438, 597], [452, 583, 521, 596], [535, 584, 677, 599], [690, 583, 787, 596], [801, 583, 825, 596], [338, 602, 478, 615], [492, 602, 530, 614], [543, 602, 638, 615], [650, 602, 676, 614], [688, 602, 788, 615], [802, 602, 843, 614], [337, 621, 502, 633], [516, 621, 615, 637], [629, 621, 774, 636], [789, 621, 827, 633], [337, 639, 418, 652], [432, 640, 571, 653], [587, 639, 731, 655], [743, 639, 769, 652], [780, 639, 841, 652], [338, 658, 440, 673], [455, 658, 491, 670], [508, 658, 602, 671], [616, 658, 638, 670], [654, 658, 835, 674], [337, 677, 429, 689], [337, 714, 482, 726], [495, 714, 548, 726], [561, 714, 683, 726], [338, 770, 461, 782], [474, 769, 554, 785], [489, 788, 562, 803], [576, 788, 643, 801], [656, 787, 751, 804], [764, 788, 844, 801], [334, 825, 421, 838], [430, 824, 574, 838], [584, 824, 723, 841], [335, 844, 450, 857], [464, 843, 583, 860], [628, 862, 755, 875], [769, 861, 848, 878]]] # noqa: E231
# fmt: on
self.assertListEqual(encoding.words , snake_case )
self.assertListEqual(encoding.boxes , snake_case )
# with apply_OCR = False
__UpperCamelCase = LayoutLMvaImageProcessor(apply_ocr=snake_case )
__UpperCamelCase = image_processing(snake_case , return_tensors='''pt''' )
self.assertEqual(encoding.pixel_values.shape , (1, 3, 224, 224) )
| 375
|
from ...configuration_utils import PretrainedConfig
from ...utils import logging
a_ = logging.get_logger(__name__)
a_ = {
"RWKV/rwkv-4-169m-pile": "https://huggingface.co/RWKV/rwkv-4-169m-pile/resolve/main/config.json",
"RWKV/rwkv-4-430m-pile": "https://huggingface.co/RWKV/rwkv-4-430m-pile/resolve/main/config.json",
"RWKV/rwkv-4-1b5-pile": "https://huggingface.co/RWKV/rwkv-4-1b5-pile/resolve/main/config.json",
"RWKV/rwkv-4-3b-pile": "https://huggingface.co/RWKV/rwkv-4-3b-pile/resolve/main/config.json",
"RWKV/rwkv-4-7b-pile": "https://huggingface.co/RWKV/rwkv-4-7b-pile/resolve/main/config.json",
"RWKV/rwkv-4-14b-pile": "https://huggingface.co/RWKV/rwkv-4-14b-pile/resolve/main/config.json",
"RWKV/rwkv-raven-1b5": "https://huggingface.co/RWKV/rwkv-raven-1b5/resolve/main/config.json",
"RWKV/rwkv-raven-3b": "https://huggingface.co/RWKV/rwkv-raven-3b/resolve/main/config.json",
"RWKV/rwkv-raven-7b": "https://huggingface.co/RWKV/rwkv-raven-7b/resolve/main/config.json",
"RWKV/rwkv-raven-14b": "https://huggingface.co/RWKV/rwkv-raven-14b/resolve/main/config.json",
}
class _lowerCamelCase ( _SCREAMING_SNAKE_CASE ):
"""simple docstring"""
lowerCAmelCase__ : Union[str, Any] = "rwkv"
lowerCAmelCase__ : Union[str, Any] = {"max_position_embeddings": "context_length"}
def __init__( self : Optional[int] , snake_case : Optional[Any]=50277 , snake_case : str=1024 , snake_case : str=4096 , snake_case : Optional[Any]=32 , snake_case : Union[str, Any]=None , snake_case : Optional[Any]=None , snake_case : Optional[Any]=1E-5 , snake_case : List[str]=0 , snake_case : Optional[Any]=0 , snake_case : Union[str, Any]=6 , snake_case : Tuple=False , snake_case : Any=True , **snake_case : List[str] , ):
__UpperCamelCase = vocab_size
__UpperCamelCase = context_length
__UpperCamelCase = hidden_size
__UpperCamelCase = num_hidden_layers
__UpperCamelCase = attention_hidden_size if attention_hidden_size is not None else hidden_size
__UpperCamelCase = intermediate_size if intermediate_size is not None else 4 * hidden_size
__UpperCamelCase = layer_norm_epsilon
__UpperCamelCase = rescale_every
__UpperCamelCase = use_cache
__UpperCamelCase = bos_token_id
__UpperCamelCase = eos_token_id
super().__init__(
tie_word_embeddings=snake_case , bos_token_id=snake_case , eos_token_id=snake_case , **snake_case )
| 375
| 1
|
import re
import time
from typing import Optional
import IPython.display as disp
from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length
def __snake_case ( lowerCAmelCase_ ) -> Optional[Any]:
SCREAMING_SNAKE_CASE__ = int(lowerCAmelCase_ )
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = t // 3_6_0_0, (t // 6_0) % 6_0, t % 6_0
return f'''{h}:{m:02d}:{s:02d}''' if h != 0 else f'''{m:02d}:{s:02d}'''
def __snake_case ( lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_=3_0_0 ) -> Dict:
# docstyle-ignore
return f'''
<div>
{prefix}
<progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
{label}
</div>
'''
def __snake_case ( lowerCAmelCase_ ) -> Optional[Any]:
SCREAMING_SNAKE_CASE__ = '''<table border="1" class="dataframe">\n'''
html_code += """ <thead>\n <tr style="text-align: left;">\n"""
for i in items[0]:
html_code += f''' <th>{i}</th>\n'''
html_code += " </tr>\n </thead>\n <tbody>\n"
for line in items[1:]:
html_code += " <tr>\n"
for elt in line:
SCREAMING_SNAKE_CASE__ = f'''{elt:.6f}''' if isinstance(lowerCAmelCase_ , lowerCAmelCase_ ) else str(lowerCAmelCase_ )
html_code += f''' <td>{elt}</td>\n'''
html_code += " </tr>\n"
html_code += " </tbody>\n</table><p>"
return html_code
class __snake_case :
'''simple docstring'''
lowerCamelCase__ : Tuple = 5
lowerCamelCase__ : str = 0.2
def __init__( self , A_ , A_ = None , A_ = True , A_ = None , A_ = 3_00 , ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = total
SCREAMING_SNAKE_CASE__ = '''''' if prefix is None else prefix
SCREAMING_SNAKE_CASE__ = leave
SCREAMING_SNAKE_CASE__ = parent
SCREAMING_SNAKE_CASE__ = width
SCREAMING_SNAKE_CASE__ = None
SCREAMING_SNAKE_CASE__ = None
SCREAMING_SNAKE_CASE__ = None
def lowercase_ ( self , A_ , A_ = False , A_ = None ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = value
if comment is not None:
SCREAMING_SNAKE_CASE__ = comment
if self.last_value is None:
SCREAMING_SNAKE_CASE__ = SCREAMING_SNAKE_CASE__ = time.time()
SCREAMING_SNAKE_CASE__ = SCREAMING_SNAKE_CASE__ = value
SCREAMING_SNAKE_CASE__ = SCREAMING_SNAKE_CASE__ = None
SCREAMING_SNAKE_CASE__ = self.warmup
SCREAMING_SNAKE_CASE__ = 1
self.update_bar(A_ )
elif value <= self.last_value and not force_update:
return
elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for , self.total ):
if self.first_calls > 0:
self.first_calls -= 1
SCREAMING_SNAKE_CASE__ = time.time()
SCREAMING_SNAKE_CASE__ = current_time - self.start_time
# We could have value = self.start_value if the update is called twixe with the same start value.
if value > self.start_value:
SCREAMING_SNAKE_CASE__ = self.elapsed_time / (value - self.start_value)
else:
SCREAMING_SNAKE_CASE__ = None
if value >= self.total:
SCREAMING_SNAKE_CASE__ = self.total
SCREAMING_SNAKE_CASE__ = None
if not self.leave:
self.close()
elif self.average_time_per_item is not None:
SCREAMING_SNAKE_CASE__ = self.average_time_per_item * (self.total - value)
self.update_bar(A_ )
SCREAMING_SNAKE_CASE__ = value
SCREAMING_SNAKE_CASE__ = current_time
if self.average_time_per_item is None:
SCREAMING_SNAKE_CASE__ = 1
else:
SCREAMING_SNAKE_CASE__ = max(int(self.update_every / self.average_time_per_item ) , 1 )
def lowercase_ ( self , A_ , A_=None ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = ''' ''' * (len(str(self.total ) ) - len(str(A_ ) )) + str(A_ )
if self.elapsed_time is None:
SCREAMING_SNAKE_CASE__ = f'''[{spaced_value}/{self.total} : < :'''
elif self.predicted_remaining is None:
SCREAMING_SNAKE_CASE__ = f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time )}'''
else:
SCREAMING_SNAKE_CASE__ = (
f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time )} <'''
f''' {format_time(self.predicted_remaining )}'''
)
self.label += f''', {1/self.average_time_per_item:.2f} it/s'''
self.label += "]" if self.comment is None or len(self.comment ) == 0 else f''', {self.comment}]'''
self.display()
def lowercase_ ( self ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = html_progress_bar(self.value , self.total , self.prefix , self.label , self.width )
if self.parent is not None:
# If this is a child bar, the parent will take care of the display.
self.parent.display()
return
if self.output is None:
SCREAMING_SNAKE_CASE__ = disp.display(disp.HTML(self.html_code ) , display_id=A_ )
else:
self.output.update(disp.HTML(self.html_code ) )
def lowercase_ ( self ):
'''simple docstring'''
if self.parent is None and self.output is not None:
self.output.update(disp.HTML('''''' ) )
class __snake_case ( __SCREAMING_SNAKE_CASE ):
'''simple docstring'''
def __init__( self , A_ , A_=None ):
'''simple docstring'''
super().__init__(A_ )
SCREAMING_SNAKE_CASE__ = None if column_names is None else [column_names]
SCREAMING_SNAKE_CASE__ = None
def lowercase_ ( self ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = html_progress_bar(self.value , self.total , self.prefix , self.label , self.width )
if self.inner_table is not None:
self.html_code += text_to_html_table(self.inner_table )
if self.child_bar is not None:
self.html_code += self.child_bar.html_code
if self.output is None:
SCREAMING_SNAKE_CASE__ = disp.display(disp.HTML(self.html_code ) , display_id=A_ )
else:
self.output.update(disp.HTML(self.html_code ) )
def lowercase_ ( self , A_ ):
'''simple docstring'''
if self.inner_table is None:
SCREAMING_SNAKE_CASE__ = [list(values.keys() ), list(values.values() )]
else:
SCREAMING_SNAKE_CASE__ = self.inner_table[0]
if len(self.inner_table ) == 1:
# We give a chance to update the column names at the first iteration
for key in values.keys():
if key not in columns:
columns.append(A_ )
SCREAMING_SNAKE_CASE__ = columns
self.inner_table.append([values[c] for c in columns] )
def lowercase_ ( self , A_ , A_=None , A_=3_00 ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = NotebookProgressBar(A_ , prefix=A_ , parent=self , width=A_ )
return self.child_bar
def lowercase_ ( self ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = None
self.display()
class __snake_case ( __SCREAMING_SNAKE_CASE ):
'''simple docstring'''
def __init__( self ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = None
SCREAMING_SNAKE_CASE__ = None
SCREAMING_SNAKE_CASE__ = False
def lowercase_ ( self , A_ , A_ , A_ , **A_ ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = '''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
SCREAMING_SNAKE_CASE__ = 0
SCREAMING_SNAKE_CASE__ = 0
SCREAMING_SNAKE_CASE__ = [self.first_column] + ['''Training Loss''']
if args.evaluation_strategy != IntervalStrategy.NO:
column_names.append('''Validation Loss''' )
SCREAMING_SNAKE_CASE__ = NotebookTrainingTracker(state.max_steps , A_ )
def lowercase_ ( self , A_ , A_ , A_ , **A_ ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = int(state.epoch ) if int(state.epoch ) == state.epoch else f'''{state.epoch:.2f}'''
self.training_tracker.update(
state.global_step + 1 , comment=f'''Epoch {epoch}/{state.num_train_epochs}''' , force_update=self._force_next_update , )
SCREAMING_SNAKE_CASE__ = False
def lowercase_ ( self , A_ , A_ , A_ , A_=None , **A_ ):
'''simple docstring'''
if not has_length(A_ ):
return
if self.prediction_bar is None:
if self.training_tracker is not None:
SCREAMING_SNAKE_CASE__ = self.training_tracker.add_child(len(A_ ) )
else:
SCREAMING_SNAKE_CASE__ = NotebookProgressBar(len(A_ ) )
self.prediction_bar.update(1 )
else:
self.prediction_bar.update(self.prediction_bar.value + 1 )
def lowercase_ ( self , A_ , A_ , A_ , **A_ ):
'''simple docstring'''
if self.prediction_bar is not None:
self.prediction_bar.close()
SCREAMING_SNAKE_CASE__ = None
def lowercase_ ( self , A_ , A_ , A_ , A_=None , **A_ ):
'''simple docstring'''
if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
SCREAMING_SNAKE_CASE__ = {'''Training Loss''': logs['''loss''']}
# First column is necessarily Step sine we're not in epoch eval strategy
SCREAMING_SNAKE_CASE__ = state.global_step
self.training_tracker.write_line(A_ )
def lowercase_ ( self , A_ , A_ , A_ , A_=None , **A_ ):
'''simple docstring'''
if self.training_tracker is not None:
SCREAMING_SNAKE_CASE__ = {'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
for log in reversed(state.log_history ):
if "loss" in log:
SCREAMING_SNAKE_CASE__ = log['''loss''']
break
if self.first_column == "Epoch":
SCREAMING_SNAKE_CASE__ = int(state.epoch )
else:
SCREAMING_SNAKE_CASE__ = state.global_step
SCREAMING_SNAKE_CASE__ = '''eval'''
for k in metrics:
if k.endswith('''_loss''' ):
SCREAMING_SNAKE_CASE__ = re.sub(r'''\_loss$''' , '''''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop('''total_flos''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop('''epoch''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop(f'''{metric_key_prefix}_runtime''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop(f'''{metric_key_prefix}_samples_per_second''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop(f'''{metric_key_prefix}_steps_per_second''' , A_ )
SCREAMING_SNAKE_CASE__ = metrics.pop(f'''{metric_key_prefix}_jit_compilation_time''' , A_ )
for k, v in metrics.items():
if k == f'''{metric_key_prefix}_loss''':
SCREAMING_SNAKE_CASE__ = v
else:
SCREAMING_SNAKE_CASE__ = k.split('''_''' )
SCREAMING_SNAKE_CASE__ = ''' '''.join([part.capitalize() for part in splits[1:]] )
SCREAMING_SNAKE_CASE__ = v
self.training_tracker.write_line(A_ )
self.training_tracker.remove_child()
SCREAMING_SNAKE_CASE__ = None
# Evaluation takes a long time so we should force the next update.
SCREAMING_SNAKE_CASE__ = True
def lowercase_ ( self , A_ , A_ , A_ , **A_ ):
'''simple docstring'''
self.training_tracker.update(
state.global_step , comment=f'''Epoch {int(state.epoch )}/{state.num_train_epochs}''' , force_update=A_ )
SCREAMING_SNAKE_CASE__ = None
| 100
|
"""simple docstring"""
import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict
from packaging import version
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig
if TYPE_CHECKING:
from ... import PreTrainedTokenizerBase, TensorType
__UpperCAmelCase = logging.get_logger(__name__)
class __lowercase ( __lowerCamelCase ):
snake_case_ = """vision-encoder-decoder"""
snake_case_ = True
def __init__( self : List[Any] ,**A : Union[str, Any] ):
'''simple docstring'''
super().__init__(**A )
if "encoder" not in kwargs or "decoder" not in kwargs:
raise ValueError(
f"A configuraton of type {self.model_type} cannot be instantiated because "
f"not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}" )
UpperCAmelCase__ : int = kwargs.pop("""encoder""" )
UpperCAmelCase__ : int = encoder_config.pop("""model_type""" )
UpperCAmelCase__ : str = kwargs.pop("""decoder""" )
UpperCAmelCase__ : Dict = decoder_config.pop("""model_type""" )
UpperCAmelCase__ : List[Any] = AutoConfig.for_model(A ,**A )
UpperCAmelCase__ : Any = AutoConfig.for_model(A ,**A )
UpperCAmelCase__ : Union[str, Any] = True
@classmethod
def __lowercase ( cls : List[Any] ,A : PretrainedConfig ,A : PretrainedConfig ,**A : Tuple ):
'''simple docstring'''
logger.info("""Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config""" )
UpperCAmelCase__ : Union[str, Any] = True
UpperCAmelCase__ : List[Any] = True
return cls(encoder=encoder_config.to_dict() ,decoder=decoder_config.to_dict() ,**A )
def __lowercase ( self : Optional[int] ):
'''simple docstring'''
UpperCAmelCase__ : List[Any] = copy.deepcopy(self.__dict__ )
UpperCAmelCase__ : Dict = self.encoder.to_dict()
UpperCAmelCase__ : Any = self.decoder.to_dict()
UpperCAmelCase__ : Dict = self.__class__.model_type
return output
class __lowercase ( __lowerCamelCase ):
snake_case_ = version.parse("""1.11""" )
@property
def __lowercase ( self : Optional[int] ):
'''simple docstring'''
return OrderedDict(
[
("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
] )
@property
def __lowercase ( self : List[Any] ):
'''simple docstring'''
return 1e-4
@property
def __lowercase ( self : List[Any] ):
'''simple docstring'''
return OrderedDict({"""last_hidden_state""": {0: """batch""", 1: """encoder_sequence"""}} )
class __lowercase ( __lowerCamelCase ):
@property
def __lowercase ( self : Any ):
'''simple docstring'''
UpperCAmelCase__ : int = OrderedDict()
UpperCAmelCase__ : Dict = {0: """batch""", 1: """past_decoder_sequence + sequence"""}
UpperCAmelCase__ : Optional[Any] = {0: """batch""", 1: """past_decoder_sequence + sequence"""}
UpperCAmelCase__ : List[str] = {0: """batch""", 1: """encoder_sequence"""}
return common_inputs
def __lowercase ( self : Dict ,A : "PreTrainedTokenizerBase" ,A : int = -1 ,A : int = -1 ,A : bool = False ,A : Optional["TensorType"] = None ,):
'''simple docstring'''
import torch
UpperCAmelCase__ : int = OrderedDict()
UpperCAmelCase__ : List[Any] = super().generate_dummy_inputs(
A ,batch_size=A ,seq_length=A ,is_pair=A ,framework=A )
UpperCAmelCase__ , UpperCAmelCase__ : int = dummy_input["""input_ids"""].shape
UpperCAmelCase__ : int = (batch, encoder_sequence, self._config.encoder_hidden_size)
UpperCAmelCase__ : Tuple = dummy_input.pop("""input_ids""" )
UpperCAmelCase__ : Optional[int] = dummy_input.pop("""attention_mask""" )
UpperCAmelCase__ : Dict = torch.zeros(A )
return common_inputs
class __lowercase ( __lowerCamelCase ):
@property
def __lowercase ( self : str ):
'''simple docstring'''
pass
def __lowercase ( self : Any ,A : PretrainedConfig ):
'''simple docstring'''
return VisionEncoderDecoderEncoderOnnxConfig(A )
def __lowercase ( self : Dict ,A : PretrainedConfig ,A : PretrainedConfig ,A : str = "default" ):
'''simple docstring'''
UpperCAmelCase__ : List[str] = encoder_config.hidden_size
return VisionEncoderDecoderDecoderOnnxConfig(A ,A )
| 65
| 0
|
def UpperCamelCase_ ( a_ ) ->list:
A =int(a_ )
if n_element < 1:
A =ValueError("a should be a positive number" )
raise my_error
A =[1]
A , A , A =(0, 0, 0)
A =1
while index < n_element:
while hamming_list[i] * 2 <= hamming_list[-1]:
i += 1
while hamming_list[j] * 3 <= hamming_list[-1]:
j += 1
while hamming_list[k] * 5 <= hamming_list[-1]:
k += 1
hamming_list.append(
min(hamming_list[i] * 2 , hamming_list[j] * 3 , hamming_list[k] * 5 ) )
index += 1
return hamming_list
if __name__ == "__main__":
__a = input("""Enter the last number (nth term) of the Hamming Number Series: """)
print("""Formula of Hamming Number Series => 2^i * 3^j * 5^k""")
__a = hamming(int(n))
print("""-----------------------------------------------------""")
print(F'''The list with nth numbers is: {hamming_numbers}''')
print("""-----------------------------------------------------""")
| 709
|
import os
import sys
import unittest
__a = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))
import check_dummies # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init # noqa: E402
# Align TRANSFORMERS_PATH in check_dummies with the current path
__a = os.path.join(git_repo_path, """src""", """diffusers""")
class UpperCamelCase__( unittest.TestCase ):
"""simple docstring"""
def _a ( self : List[str] ):
"""simple docstring"""
A =find_backend(" if not is_torch_available():" )
self.assertEqual(snake_case__ , "torch" )
# backend_with_underscore = find_backend(" if not is_tensorflow_text_available():")
# self.assertEqual(backend_with_underscore, "tensorflow_text")
A =find_backend(" if not (is_torch_available() and is_transformers_available()):" )
self.assertEqual(snake_case__ , "torch_and_transformers" )
# double_backend_with_underscore = find_backend(
# " if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
# )
# self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")
A =find_backend(
" if not (is_torch_available() and is_transformers_available() and is_onnx_available()):" )
self.assertEqual(snake_case__ , "torch_and_transformers_and_onnx" )
def _a ( self : List[Any] ):
"""simple docstring"""
A =read_init()
# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
self.assertIn("torch" , snake_case__ )
self.assertIn("torch_and_transformers" , snake_case__ )
self.assertIn("flax_and_transformers" , snake_case__ )
self.assertIn("torch_and_transformers_and_onnx" , snake_case__ )
# Likewise, we can't assert on the exact content of a key
self.assertIn("UNet2DModel" , objects["torch"] )
self.assertIn("FlaxUNet2DConditionModel" , objects["flax"] )
self.assertIn("StableDiffusionPipeline" , objects["torch_and_transformers"] )
self.assertIn("FlaxStableDiffusionPipeline" , objects["flax_and_transformers"] )
self.assertIn("LMSDiscreteScheduler" , objects["torch_and_scipy"] )
self.assertIn("OnnxStableDiffusionPipeline" , objects["torch_and_transformers_and_onnx"] )
def _a ( self : Dict ):
"""simple docstring"""
A =create_dummy_object("CONSTANT" , "'torch'" )
self.assertEqual(snake_case__ , "\nCONSTANT = None\n" )
A =create_dummy_object("function" , "'torch'" )
self.assertEqual(
snake_case__ , "\ndef function(*args, **kwargs):\n requires_backends(function, 'torch')\n" )
A ="\nclass FakeClass(metaclass=DummyObject):\n _backends = 'torch'\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, 'torch')\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, 'torch')\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, 'torch')\n"
A =create_dummy_object("FakeClass" , "'torch'" )
self.assertEqual(snake_case__ , snake_case__ )
def _a ( self : Tuple ):
"""simple docstring"""
A ="# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n requires_backends(function, [\"torch\"])\n\n\nclass FakeClass(metaclass=DummyObject):\n _backends = [\"torch\"]\n\n def __init__(self, *args, **kwargs):\n requires_backends(self, [\"torch\"])\n\n @classmethod\n def from_config(cls, *args, **kwargs):\n requires_backends(cls, [\"torch\"])\n\n @classmethod\n def from_pretrained(cls, *args, **kwargs):\n requires_backends(cls, [\"torch\"])\n"
A =create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]} )
self.assertEqual(dummy_files["torch"] , snake_case__ )
| 689
| 0
|
'''simple docstring'''
import unittest
import numpy as np
import torch
from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device
enable_full_determinism()
class _UpperCAmelCase ( unittest.TestCase ):
@property
def lowerCamelCase__ ( self ):
'''simple docstring'''
torch.manual_seed(0 )
__lowerCAmelCase = UNetaDModel(
block_out_channels=(32, 64),layers_per_block=2,sample_size=32,in_channels=3,out_channels=3,down_block_types=("""DownBlock2D""", """AttnDownBlock2D"""),up_block_types=("""AttnUpBlock2D""", """UpBlock2D"""),)
return model
def lowerCamelCase__ ( self ):
'''simple docstring'''
__lowerCAmelCase = self.dummy_uncond_unet
__lowerCAmelCase = ScoreSdeVeScheduler()
__lowerCAmelCase = ScoreSdeVePipeline(unet=__SCREAMING_SNAKE_CASE,scheduler=__SCREAMING_SNAKE_CASE )
sde_ve.to(__SCREAMING_SNAKE_CASE )
sde_ve.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE )
__lowerCAmelCase = torch.manual_seed(0 )
__lowerCAmelCase = sde_ve(num_inference_steps=2,output_type="""numpy""",generator=__SCREAMING_SNAKE_CASE ).images
__lowerCAmelCase = torch.manual_seed(0 )
__lowerCAmelCase = sde_ve(num_inference_steps=2,output_type="""numpy""",generator=__SCREAMING_SNAKE_CASE,return_dict=__SCREAMING_SNAKE_CASE )[
0
]
__lowerCAmelCase = image[0, -3:, -3:, -1]
__lowerCAmelCase = image_from_tuple[0, -3:, -3:, -1]
assert image.shape == (1, 32, 32, 3)
__lowerCAmelCase = np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2
@slow
@require_torch
class _UpperCAmelCase ( unittest.TestCase ):
def lowerCamelCase__ ( self ):
'''simple docstring'''
__lowerCAmelCase = """google/ncsnpp-church-256"""
__lowerCAmelCase = UNetaDModel.from_pretrained(__SCREAMING_SNAKE_CASE )
__lowerCAmelCase = ScoreSdeVeScheduler.from_pretrained(__SCREAMING_SNAKE_CASE )
__lowerCAmelCase = ScoreSdeVePipeline(unet=__SCREAMING_SNAKE_CASE,scheduler=__SCREAMING_SNAKE_CASE )
sde_ve.to(__SCREAMING_SNAKE_CASE )
sde_ve.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE )
__lowerCAmelCase = torch.manual_seed(0 )
__lowerCAmelCase = sde_ve(num_inference_steps=10,output_type="""numpy""",generator=__SCREAMING_SNAKE_CASE ).images
__lowerCAmelCase = image[0, -3:, -3:, -1]
assert image.shape == (1, 2_56, 2_56, 3)
__lowerCAmelCase = np.array([0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 689
|
'''simple docstring'''
from argparse import ArgumentParser
from .env import EnvironmentCommand
def _lowerCAmelCase ( ) -> Union[str, Any]:
__lowerCAmelCase = ArgumentParser("""Diffusers CLI tool""" , usage="""diffusers-cli <command> [<args>]""" )
__lowerCAmelCase = parser.add_subparsers(help="""diffusers-cli command helpers""" )
# Register commands
EnvironmentCommand.register_subcommand(lowercase )
# Let's go
__lowerCAmelCase = parser.parse_args()
if not hasattr(lowercase , """func""" ):
parser.print_help()
exit(1 )
# Run
__lowerCAmelCase = args.func(lowercase )
service.run()
if __name__ == "__main__":
main()
| 689
| 1
|
from typing import Dict, Iterable, List, Optional, Union
import numpy as np
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_DEFAULT_MEAN,
IMAGENET_DEFAULT_STD,
ChannelDimension,
ImageInput,
PILImageResampling,
make_list_of_images,
to_numpy_array,
valid_images,
)
from ...utils import TensorType, logging
__SCREAMING_SNAKE_CASE = logging.get_logger(__name__)
class lowerCAmelCase_ ( __A ):
'''simple docstring'''
_lowercase = ['pixel_values']
def __init__( self , __UpperCAmelCase = True , __UpperCAmelCase = None , __UpperCAmelCase = PILImageResampling.BICUBIC , __UpperCAmelCase = True , __UpperCAmelCase = None , __UpperCAmelCase = True , __UpperCAmelCase = 1 / 255 , __UpperCAmelCase = True , __UpperCAmelCase = IMAGENET_DEFAULT_MEAN , __UpperCAmelCase = IMAGENET_DEFAULT_STD , **__UpperCAmelCase , ):
super().__init__(**__UpperCAmelCase )
SCREAMING_SNAKE_CASE_ : Tuple =size if size is not None else {'shortest_edge': 224}
SCREAMING_SNAKE_CASE_ : List[Any] =get_size_dict(__UpperCAmelCase , default_to_square=__UpperCAmelCase )
SCREAMING_SNAKE_CASE_ : List[str] =crop_size if crop_size is not None else {'height': 224, 'width': 224}
SCREAMING_SNAKE_CASE_ : Union[str, Any] =get_size_dict(__UpperCAmelCase , param_name='crop_size' )
SCREAMING_SNAKE_CASE_ : Tuple =do_resize
SCREAMING_SNAKE_CASE_ : Dict =size
SCREAMING_SNAKE_CASE_ : Tuple =resample
SCREAMING_SNAKE_CASE_ : List[str] =do_center_crop
SCREAMING_SNAKE_CASE_ : Optional[int] =crop_size
SCREAMING_SNAKE_CASE_ : int =do_rescale
SCREAMING_SNAKE_CASE_ : List[Any] =rescale_factor
SCREAMING_SNAKE_CASE_ : Any =do_normalize
SCREAMING_SNAKE_CASE_ : Tuple =image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
SCREAMING_SNAKE_CASE_ : Tuple =image_std if image_std is not None else IMAGENET_DEFAULT_STD
def __lowerCamelCase ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = PILImageResampling.BICUBIC , __UpperCAmelCase = None , **__UpperCAmelCase , ):
SCREAMING_SNAKE_CASE_ : Optional[Any] =get_size_dict(__UpperCAmelCase , default_to_square=__UpperCAmelCase )
# size_dict is a dict with either keys "height" and "width" or "shortest_edge"
if "shortest_edge" in size:
SCREAMING_SNAKE_CASE_ : List[str] =int((256 / 224) * size['shortest_edge'] )
SCREAMING_SNAKE_CASE_ : Optional[Any] =get_resize_output_image_size(__UpperCAmelCase , size=__UpperCAmelCase , default_to_square=__UpperCAmelCase )
SCREAMING_SNAKE_CASE_ : Tuple ={'height': output_size[0], 'width': output_size[1]}
if "height" not in size_dict or "width" not in size_dict:
raise ValueError(
F"""Size dict must have keys 'height' and 'width' or 'shortest_edge'. Got {size_dict.keys()}""" )
return resize(
__UpperCAmelCase , size=(size_dict['height'], size_dict['width']) , resample=__UpperCAmelCase , data_format=__UpperCAmelCase , **__UpperCAmelCase )
def __lowerCamelCase ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = None , **__UpperCAmelCase , ):
SCREAMING_SNAKE_CASE_ : List[Any] =get_size_dict(__UpperCAmelCase )
if "height" not in size or "width" not in size:
raise ValueError(F"""Size dict must have keys 'height' and 'width'. Got {size.keys()}""" )
return center_crop(__UpperCAmelCase , size=(size['height'], size['width']) , data_format=__UpperCAmelCase , **__UpperCAmelCase )
def __lowerCamelCase ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = None , **__UpperCAmelCase , ):
return rescale(__UpperCAmelCase , scale=__UpperCAmelCase , data_format=__UpperCAmelCase , **__UpperCAmelCase )
def __lowerCamelCase ( self , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase = None , **__UpperCAmelCase , ):
return normalize(__UpperCAmelCase , mean=__UpperCAmelCase , std=__UpperCAmelCase , data_format=__UpperCAmelCase , **__UpperCAmelCase )
def __lowerCamelCase ( self , __UpperCAmelCase , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = None , __UpperCAmelCase = ChannelDimension.FIRST , **__UpperCAmelCase , ):
SCREAMING_SNAKE_CASE_ : Optional[int] =do_resize if do_resize is not None else self.do_resize
SCREAMING_SNAKE_CASE_ : List[str] =resample if resample is not None else self.resample
SCREAMING_SNAKE_CASE_ : Tuple =do_center_crop if do_center_crop is not None else self.do_center_crop
SCREAMING_SNAKE_CASE_ : Union[str, Any] =do_rescale if do_rescale is not None else self.do_rescale
SCREAMING_SNAKE_CASE_ : Tuple =rescale_factor if rescale_factor is not None else self.rescale_factor
SCREAMING_SNAKE_CASE_ : Tuple =do_normalize if do_normalize is not None else self.do_normalize
SCREAMING_SNAKE_CASE_ : int =image_mean if image_mean is not None else self.image_mean
SCREAMING_SNAKE_CASE_ : List[Any] =image_std if image_std is not None else self.image_std
SCREAMING_SNAKE_CASE_ : List[str] =size if size is not None else self.size
SCREAMING_SNAKE_CASE_ : Any =get_size_dict(__UpperCAmelCase , default_to_square=__UpperCAmelCase )
SCREAMING_SNAKE_CASE_ : Optional[Any] =crop_size if crop_size is not None else self.crop_size
SCREAMING_SNAKE_CASE_ : Optional[Any] =get_size_dict(__UpperCAmelCase , param_name='crop_size' )
SCREAMING_SNAKE_CASE_ : Optional[Any] =make_list_of_images(__UpperCAmelCase )
if not valid_images(__UpperCAmelCase ):
raise ValueError(
'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
'torch.Tensor, tf.Tensor or jax.ndarray.' )
if do_resize and size is None:
raise ValueError('Size must be specified if do_resize is True.' )
if do_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.' )
# All transformations expect numpy arrays.
SCREAMING_SNAKE_CASE_ : Any =[to_numpy_array(__UpperCAmelCase ) for image in images]
if do_resize:
SCREAMING_SNAKE_CASE_ : Dict =[self.resize(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) for image in images]
if do_center_crop:
SCREAMING_SNAKE_CASE_ : Any =[self.center_crop(__UpperCAmelCase , __UpperCAmelCase ) for image in images]
if do_rescale:
SCREAMING_SNAKE_CASE_ : List[Any] =[self.rescale(__UpperCAmelCase , __UpperCAmelCase ) for image in images]
if do_normalize:
SCREAMING_SNAKE_CASE_ : List[str] =[self.normalize(__UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ) for image in images]
SCREAMING_SNAKE_CASE_ : Tuple =[to_channel_dimension_format(__UpperCAmelCase , __UpperCAmelCase ) for image in images]
SCREAMING_SNAKE_CASE_ : Tuple ={'pixel_values': images}
return BatchFeature(data=__UpperCAmelCase , tensor_type=__UpperCAmelCase )
| 153
|
import importlib.metadata
import warnings
from copy import deepcopy
from packaging import version
from ..utils import logging
from .import_utils import is_accelerate_available, is_bitsandbytes_available
if is_bitsandbytes_available():
import bitsandbytes as bnb
import torch
import torch.nn as nn
from ..pytorch_utils import ConvaD
if is_accelerate_available():
from accelerate import init_empty_weights
from accelerate.utils import find_tied_parameters
__SCREAMING_SNAKE_CASE = logging.get_logger(__name__)
def SCREAMING_SNAKE_CASE__ ( lowerCAmelCase_ : Optional[int] ,lowerCAmelCase_ : Any ,lowerCAmelCase_ : str ,lowerCAmelCase_ : Tuple=None ,lowerCAmelCase_ : Optional[int]=None ) -> Optional[int]:
"""simple docstring"""
if "." in tensor_name:
SCREAMING_SNAKE_CASE_ : Dict =tensor_name.split('.' )
for split in splits[:-1]:
SCREAMING_SNAKE_CASE_ : Dict =getattr(lowerCAmelCase_ ,lowerCAmelCase_ )
if new_module is None:
raise ValueError(F"""{module} has no attribute {split}.""" )
SCREAMING_SNAKE_CASE_ : Union[str, Any] =new_module
SCREAMING_SNAKE_CASE_ : Union[str, Any] =splits[-1]
if tensor_name not in module._parameters and tensor_name not in module._buffers:
raise ValueError(F"""{module} does not have a parameter or a buffer named {tensor_name}.""" )
SCREAMING_SNAKE_CASE_ : List[str] =tensor_name in module._buffers
SCREAMING_SNAKE_CASE_ : List[str] =getattr(lowerCAmelCase_ ,lowerCAmelCase_ )
if old_value.device == torch.device('meta' ) and device not in ["meta", torch.device('meta' )] and value is None:
raise ValueError(F"""{tensor_name} is on the meta device, we need a `value` to put in on {device}.""" )
SCREAMING_SNAKE_CASE_ : Dict =False
SCREAMING_SNAKE_CASE_ : str =False
if is_buffer or not is_bitsandbytes_available():
SCREAMING_SNAKE_CASE_ : Optional[int] =False
SCREAMING_SNAKE_CASE_ : Dict =False
else:
SCREAMING_SNAKE_CASE_ : Optional[Any] =hasattr(bnb.nn ,'Params4bit' ) and isinstance(module._parameters[tensor_name] ,bnb.nn.Paramsabit )
SCREAMING_SNAKE_CASE_ : Union[str, Any] =isinstance(module._parameters[tensor_name] ,bnb.nn.IntaParams )
if is_abit or is_abit:
SCREAMING_SNAKE_CASE_ : str =module._parameters[tensor_name]
if param.device.type != "cuda":
if value is None:
SCREAMING_SNAKE_CASE_ : List[str] =old_value.to(lowerCAmelCase_ )
elif isinstance(lowerCAmelCase_ ,torch.Tensor ):
SCREAMING_SNAKE_CASE_ : Optional[int] =value.to('cpu' )
if value.dtype == torch.inta:
SCREAMING_SNAKE_CASE_ : List[Any] =version.parse(importlib.metadata.version('bitsandbytes' ) ) > version.parse(
'0.37.2' )
if not is_abit_serializable:
raise ValueError(
'Detected int8 weights but the version of bitsandbytes is not compatible with int8 serialization. '
'Make sure to download the latest `bitsandbytes` version. `pip install --upgrade bitsandbytes`.' )
else:
SCREAMING_SNAKE_CASE_ : Optional[Any] =torch.tensor(lowerCAmelCase_ ,device='cpu' )
# Support models using `Conv1D` in place of `nn.Linear` (e.g. gpt2) by transposing the weight matrix prior to quantization.
# Since weights are saved in the correct "orientation", we skip transposing when loading.
if issubclass(module.source_cls ,lowerCAmelCase_ ) and fpaa_statistics is None:
SCREAMING_SNAKE_CASE_ : Dict =new_value.T
SCREAMING_SNAKE_CASE_ : List[str] =old_value.__dict__
if is_abit:
SCREAMING_SNAKE_CASE_ : Dict =bnb.nn.IntaParams(lowerCAmelCase_ ,requires_grad=lowerCAmelCase_ ,**lowerCAmelCase_ ).to(lowerCAmelCase_ )
elif is_abit:
SCREAMING_SNAKE_CASE_ : Dict =bnb.nn.Paramsabit(lowerCAmelCase_ ,requires_grad=lowerCAmelCase_ ,**lowerCAmelCase_ ).to(lowerCAmelCase_ )
SCREAMING_SNAKE_CASE_ : Tuple =new_value
if fpaa_statistics is not None:
setattr(module.weight ,'SCB' ,fpaa_statistics.to(lowerCAmelCase_ ) )
else:
if value is None:
SCREAMING_SNAKE_CASE_ : Optional[int] =old_value.to(lowerCAmelCase_ )
elif isinstance(lowerCAmelCase_ ,torch.Tensor ):
SCREAMING_SNAKE_CASE_ : Optional[Any] =value.to(lowerCAmelCase_ )
else:
SCREAMING_SNAKE_CASE_ : Union[str, Any] =torch.tensor(lowerCAmelCase_ ,device=lowerCAmelCase_ )
if is_buffer:
SCREAMING_SNAKE_CASE_ : Dict =new_value
else:
SCREAMING_SNAKE_CASE_ : int =nn.Parameter(lowerCAmelCase_ ,requires_grad=old_value.requires_grad )
SCREAMING_SNAKE_CASE_ : str =new_value
def SCREAMING_SNAKE_CASE__ ( lowerCAmelCase_ : Any ,lowerCAmelCase_ : Optional[int]=None ,lowerCAmelCase_ : Union[str, Any]=None ,lowerCAmelCase_ : Tuple=None ,lowerCAmelCase_ : Union[str, Any]=False ) -> Any:
"""simple docstring"""
for name, module in model.named_children():
if current_key_name is None:
SCREAMING_SNAKE_CASE_ : Dict =[]
current_key_name.append(lowerCAmelCase_ )
if (isinstance(lowerCAmelCase_ ,nn.Linear ) or isinstance(lowerCAmelCase_ ,lowerCAmelCase_ )) and name not in modules_to_not_convert:
# Check if the current key is not in the `modules_to_not_convert`
if not any(key in '.'.join(lowerCAmelCase_ ) for key in modules_to_not_convert ):
with init_empty_weights():
if isinstance(lowerCAmelCase_ ,lowerCAmelCase_ ):
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Dict =module.weight.shape
else:
SCREAMING_SNAKE_CASE_ : int =module.in_features
SCREAMING_SNAKE_CASE_ : Optional[int] =module.out_features
if quantization_config.quantization_method() == "llm_int8":
SCREAMING_SNAKE_CASE_ : Union[str, Any] =bnb.nn.LinearabitLt(
lowerCAmelCase_ ,lowerCAmelCase_ ,module.bias is not None ,has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight ,threshold=quantization_config.llm_inta_threshold ,)
SCREAMING_SNAKE_CASE_ : Optional[int] =True
else:
if (
quantization_config.llm_inta_skip_modules is not None
and name in quantization_config.llm_inta_skip_modules
):
pass
else:
SCREAMING_SNAKE_CASE_ : int =bnb.nn.Linearabit(
lowerCAmelCase_ ,lowerCAmelCase_ ,module.bias is not None ,quantization_config.bnb_abit_compute_dtype ,compress_statistics=quantization_config.bnb_abit_use_double_quant ,quant_type=quantization_config.bnb_abit_quant_type ,)
SCREAMING_SNAKE_CASE_ : int =True
# Store the module class in case we need to transpose the weight later
SCREAMING_SNAKE_CASE_ : List[Any] =type(lowerCAmelCase_ )
# Force requires grad to False to avoid unexpected errors
model._modules[name].requires_grad_(lowerCAmelCase_ )
if len(list(module.children() ) ) > 0:
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : List[str] =_replace_with_bnb_linear(
lowerCAmelCase_ ,lowerCAmelCase_ ,lowerCAmelCase_ ,lowerCAmelCase_ ,has_been_replaced=lowerCAmelCase_ ,)
# Remove the last key for recursion
current_key_name.pop(-1 )
return model, has_been_replaced
def SCREAMING_SNAKE_CASE__ ( lowerCAmelCase_ : List[str] ,lowerCAmelCase_ : str=None ,lowerCAmelCase_ : int=None ,lowerCAmelCase_ : Optional[int]=None ) -> str:
"""simple docstring"""
SCREAMING_SNAKE_CASE_ : Optional[Any] =['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ : Tuple =_replace_with_bnb_linear(
lowerCAmelCase_ ,lowerCAmelCase_ ,lowerCAmelCase_ ,lowerCAmelCase_ )
if not has_been_replaced:
logger.warning(
'You are loading your model in 8bit or 4bit but no linear modules were found in your model.'
' Please double check your model architecture, or submit an issue on github if you think this is'
' a bug.' )
return model
def SCREAMING_SNAKE_CASE__ ( *lowerCAmelCase_ : Optional[Any] ,**lowerCAmelCase_ : Tuple ) -> int:
"""simple docstring"""
warnings.warn(
'`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead' ,lowerCAmelCase_ ,)
return replace_with_bnb_linear(*lowerCAmelCase_ ,**lowerCAmelCase_ )
def SCREAMING_SNAKE_CASE__ ( *lowerCAmelCase_ : Optional[Any] ,**lowerCAmelCase_ : Dict ) -> int:
"""simple docstring"""
warnings.warn(
'`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead' ,lowerCAmelCase_ ,)
return set_module_quantized_tensor_to_device(*lowerCAmelCase_ ,**lowerCAmelCase_ )
def SCREAMING_SNAKE_CASE__ ( lowerCAmelCase_ : Union[str, Any] ) -> Any:
"""simple docstring"""
SCREAMING_SNAKE_CASE_ : Tuple =deepcopy(lowerCAmelCase_ ) # this has 0 cost since it is done inside `init_empty_weights` context manager`
tied_model.tie_weights()
SCREAMING_SNAKE_CASE_ : Any =find_tied_parameters(lowerCAmelCase_ )
# For compatibility with Accelerate < 0.18
if isinstance(lowerCAmelCase_ ,lowerCAmelCase_ ):
SCREAMING_SNAKE_CASE_ : Optional[Any] =sum(list(tied_params.values() ) ,[] ) + list(tied_params.keys() )
else:
SCREAMING_SNAKE_CASE_ : Union[str, Any] =sum(lowerCAmelCase_ ,[] )
SCREAMING_SNAKE_CASE_ : List[Any] =len(lowerCAmelCase_ ) > 0
# Check if it is a base model
SCREAMING_SNAKE_CASE_ : int =not hasattr(lowerCAmelCase_ ,model.base_model_prefix )
# Ignore this for base models (BertModel, GPT2Model, etc.)
if (not has_tied_params) and is_base_model:
return []
# otherwise they have an attached head
SCREAMING_SNAKE_CASE_ : Tuple =list(model.named_children() )
SCREAMING_SNAKE_CASE_ : str =[list_modules[-1][0]]
# add last module together with tied weights
SCREAMING_SNAKE_CASE_ : Tuple =set(lowerCAmelCase_ ) - set(lowerCAmelCase_ )
SCREAMING_SNAKE_CASE_ : Union[str, Any] =list(set(lowerCAmelCase_ ) ) + list(lowerCAmelCase_ )
# remove ".weight" from the keys
SCREAMING_SNAKE_CASE_ : Tuple =['.weight', '.bias']
SCREAMING_SNAKE_CASE_ : List[Any] =[]
for name in list_untouched:
for name_to_remove in names_to_remove:
if name_to_remove in name:
SCREAMING_SNAKE_CASE_ : int =name.replace(lowerCAmelCase_ ,'' )
filtered_module_names.append(lowerCAmelCase_ )
return filtered_module_names
| 153
| 1
|
import collections
import os
import re
from pathlib import Path
_UpperCAmelCase : Optional[Any] = """src/transformers"""
# Matches is_xxx_available()
_UpperCAmelCase : int = re.compile(R"""is\_([a-z_]*)_available()""")
# Catches a one-line _import_struct = {xxx}
_UpperCAmelCase : List[str] = re.compile(R"""^_import_structure\s+=\s+\{([^\}]+)\}""")
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
_UpperCAmelCase : Optional[int] = re.compile(R"""\s+\"\S*\":\s+\[([^\]]*)\]""")
# Catches a line if not is_foo_available
_UpperCAmelCase : List[Any] = re.compile(R"""^\s*if\s+not\s+is\_[a-z_]*\_available\(\)""")
# Catches a line _import_struct["bla"].append("foo")
_UpperCAmelCase : Optional[int] = re.compile(R"""^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)""")
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
_UpperCAmelCase : Dict = re.compile(R"""^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]""")
# Catches a line with an object between quotes and a comma: "MyModel",
_UpperCAmelCase : Any = re.compile(R"""^\s+\"([^\"]+)\",""")
# Catches a line with objects between brackets only: ["foo", "bar"],
_UpperCAmelCase : Optional[int] = re.compile(R"""^\s+\[([^\]]+)\]""")
# Catches a line with from foo import bar, bla, boo
_UpperCAmelCase : Optional[Any] = re.compile(R"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")
# Catches a line with try:
_UpperCAmelCase : Tuple = re.compile(R"""^\s*try:""")
# Catches a line with else:
_UpperCAmelCase : Dict = re.compile(R"""^\s*else:""")
def SCREAMING_SNAKE_CASE ( _UpperCAmelCase ) -> Union[str, Any]:
if _re_test_backend.search(_UpperCAmelCase ) is None:
return None
lowerCamelCase__ : Tuple = [b[0] for b in _re_backend.findall(_UpperCAmelCase )]
backends.sort()
return "_and_".join(_UpperCAmelCase )
def SCREAMING_SNAKE_CASE ( _UpperCAmelCase ) -> Union[str, Any]:
with open(_UpperCAmelCase , 'r' , encoding='utf-8' , newline='\n' ) as f:
lowerCamelCase__ : Optional[Any] = f.readlines()
lowerCamelCase__ : str = 0
while line_index < len(_UpperCAmelCase ) and not lines[line_index].startswith('_import_structure = {' ):
line_index += 1
# If this is a traditional init, just return.
if line_index >= len(_UpperCAmelCase ):
return None
# First grab the objects without a specific backend in _import_structure
lowerCamelCase__ : int = []
while not lines[line_index].startswith('if TYPE_CHECKING' ) and find_backend(lines[line_index] ) is None:
lowerCamelCase__ : Optional[int] = lines[line_index]
# If we have everything on a single line, let's deal with it.
if _re_one_line_import_struct.search(_UpperCAmelCase ):
lowerCamelCase__ : int = _re_one_line_import_struct.search(_UpperCAmelCase ).groups()[0]
lowerCamelCase__ : int = re.findall(r'\[([^\]]+)\]' , _UpperCAmelCase )
for imp in imports:
objects.extend([obj[1:-1] for obj in imp.split(', ' )] )
line_index += 1
continue
lowerCamelCase__ : Optional[Any] = _re_import_struct_key_value.search(_UpperCAmelCase )
if single_line_import_search is not None:
lowerCamelCase__ : Optional[int] = [obj[1:-1] for obj in single_line_import_search.groups()[0].split(', ' ) if len(_UpperCAmelCase ) > 0]
objects.extend(_UpperCAmelCase )
elif line.startswith(' ' * 8 + '"' ):
objects.append(line[9:-3] )
line_index += 1
lowerCamelCase__ : Union[str, Any] = {'none': objects}
# Let's continue with backend-specific objects in _import_structure
while not lines[line_index].startswith('if TYPE_CHECKING' ):
# If the line is an if not is_backend_available, we grab all objects associated.
lowerCamelCase__ : Union[str, Any] = find_backend(lines[line_index] )
# Check if the backend declaration is inside a try block:
if _re_try.search(lines[line_index - 1] ) is None:
lowerCamelCase__ : Dict = None
if backend is not None:
line_index += 1
# Scroll until we hit the else block of try-except-else
while _re_else.search(lines[line_index] ) is None:
line_index += 1
line_index += 1
lowerCamelCase__ : Dict = []
# Until we unindent, add backend objects to the list
while len(lines[line_index] ) <= 1 or lines[line_index].startswith(' ' * 4 ):
lowerCamelCase__ : int = lines[line_index]
if _re_import_struct_add_one.search(_UpperCAmelCase ) is not None:
objects.append(_re_import_struct_add_one.search(_UpperCAmelCase ).groups()[0] )
elif _re_import_struct_add_many.search(_UpperCAmelCase ) is not None:
lowerCamelCase__ : List[str] = _re_import_struct_add_many.search(_UpperCAmelCase ).groups()[0].split(', ' )
lowerCamelCase__ : Any = [obj[1:-1] for obj in imports if len(_UpperCAmelCase ) > 0]
objects.extend(_UpperCAmelCase )
elif _re_between_brackets.search(_UpperCAmelCase ) is not None:
lowerCamelCase__ : Any = _re_between_brackets.search(_UpperCAmelCase ).groups()[0].split(', ' )
lowerCamelCase__ : Optional[Any] = [obj[1:-1] for obj in imports if len(_UpperCAmelCase ) > 0]
objects.extend(_UpperCAmelCase )
elif _re_quote_object.search(_UpperCAmelCase ) is not None:
objects.append(_re_quote_object.search(_UpperCAmelCase ).groups()[0] )
elif line.startswith(' ' * 8 + '"' ):
objects.append(line[9:-3] )
elif line.startswith(' ' * 12 + '"' ):
objects.append(line[13:-3] )
line_index += 1
lowerCamelCase__ : Any = objects
else:
line_index += 1
# At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
lowerCamelCase__ : Dict = []
while (
line_index < len(_UpperCAmelCase )
and find_backend(lines[line_index] ) is None
and not lines[line_index].startswith('else' )
):
lowerCamelCase__ : Dict = lines[line_index]
lowerCamelCase__ : Dict = _re_import.search(_UpperCAmelCase )
if single_line_import_search is not None:
objects.extend(single_line_import_search.groups()[0].split(', ' ) )
elif line.startswith(' ' * 8 ):
objects.append(line[8:-2] )
line_index += 1
lowerCamelCase__ : Tuple = {'none': objects}
# Let's continue with backend-specific objects
while line_index < len(_UpperCAmelCase ):
# If the line is an if is_backend_available, we grab all objects associated.
lowerCamelCase__ : Dict = find_backend(lines[line_index] )
# Check if the backend declaration is inside a try block:
if _re_try.search(lines[line_index - 1] ) is None:
lowerCamelCase__ : Tuple = None
if backend is not None:
line_index += 1
# Scroll until we hit the else block of try-except-else
while _re_else.search(lines[line_index] ) is None:
line_index += 1
line_index += 1
lowerCamelCase__ : Optional[int] = []
# Until we unindent, add backend objects to the list
while len(lines[line_index] ) <= 1 or lines[line_index].startswith(' ' * 8 ):
lowerCamelCase__ : Dict = lines[line_index]
lowerCamelCase__ : Optional[Any] = _re_import.search(_UpperCAmelCase )
if single_line_import_search is not None:
objects.extend(single_line_import_search.groups()[0].split(', ' ) )
elif line.startswith(' ' * 12 ):
objects.append(line[12:-2] )
line_index += 1
lowerCamelCase__ : int = objects
else:
line_index += 1
return import_dict_objects, type_hint_objects
def SCREAMING_SNAKE_CASE ( _UpperCAmelCase , _UpperCAmelCase ) -> List[str]:
def find_duplicates(_UpperCAmelCase ):
return [k for k, v in collections.Counter(_UpperCAmelCase ).items() if v > 1]
if list(import_dict_objects.keys() ) != list(type_hint_objects.keys() ):
return ["Both sides of the init do not have the same backends!"]
lowerCamelCase__ : List[str] = []
for key in import_dict_objects.keys():
lowerCamelCase__ : Optional[int] = find_duplicates(import_dict_objects[key] )
if duplicate_imports:
errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}""" )
lowerCamelCase__ : int = find_duplicates(type_hint_objects[key] )
if duplicate_type_hints:
errors.append(F"""Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}""" )
if sorted(set(import_dict_objects[key] ) ) != sorted(set(type_hint_objects[key] ) ):
lowerCamelCase__ : Union[str, Any] = 'base imports' if key == 'none' else F"""{key} backend"""
errors.append(F"""Differences for {name}:""" )
for a in type_hint_objects[key]:
if a not in import_dict_objects[key]:
errors.append(F""" {a} in TYPE_HINT but not in _import_structure.""" )
for a in import_dict_objects[key]:
if a not in type_hint_objects[key]:
errors.append(F""" {a} in _import_structure but not in TYPE_HINT.""" )
return errors
def SCREAMING_SNAKE_CASE ( ) -> Any:
lowerCamelCase__ : int = []
for root, _, files in os.walk(_UpperCAmelCase ):
if "__init__.py" in files:
lowerCamelCase__ : List[str] = os.path.join(_UpperCAmelCase , '__init__.py' )
lowerCamelCase__ : List[str] = parse_init(_UpperCAmelCase )
if objects is not None:
lowerCamelCase__ : Any = analyze_results(*_UpperCAmelCase )
if len(_UpperCAmelCase ) > 0:
lowerCamelCase__ : List[str] = F"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
failures.append('\n'.join(_UpperCAmelCase ) )
if len(_UpperCAmelCase ) > 0:
raise ValueError('\n\n'.join(_UpperCAmelCase ) )
def SCREAMING_SNAKE_CASE ( ) -> Optional[Any]:
lowerCamelCase__ : Dict = []
for path, directories, files in os.walk(_UpperCAmelCase ):
for folder in directories:
# Ignore private modules
if folder.startswith('_' ):
directories.remove(_UpperCAmelCase )
continue
# Ignore leftovers from branches (empty folders apart from pycache)
if len(list((Path(_UpperCAmelCase ) / folder).glob('*.py' ) ) ) == 0:
continue
lowerCamelCase__ : Union[str, Any] = str((Path(_UpperCAmelCase ) / folder).relative_to(_UpperCAmelCase ) )
lowerCamelCase__ : Union[str, Any] = short_path.replace(os.path.sep , '.' )
submodules.append(_UpperCAmelCase )
for fname in files:
if fname == "__init__.py":
continue
lowerCamelCase__ : Optional[Any] = str((Path(_UpperCAmelCase ) / fname).relative_to(_UpperCAmelCase ) )
lowerCamelCase__ : Optional[int] = short_path.replace('.py' , '' ).replace(os.path.sep , '.' )
if len(submodule.split('.' ) ) == 1:
submodules.append(_UpperCAmelCase )
return submodules
_UpperCAmelCase : int = [
"""convert_pytorch_checkpoint_to_tf2""",
"""modeling_flax_pytorch_utils""",
"""models.esm.openfold_utils""",
]
def SCREAMING_SNAKE_CASE ( ) -> Optional[int]:
# This is to make sure the transformers module imported is the one in the repo.
from transformers.utils import direct_transformers_import
lowerCamelCase__ : Tuple = direct_transformers_import(_UpperCAmelCase )
lowerCamelCase__ : Dict = set(transformers._import_structure.keys() )
# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
# (potentiall re-) add them.
with open(os.path.join(_UpperCAmelCase , '__init__.py' ) , 'r' ) as f:
lowerCamelCase__ : str = f.read()
import_structure_keys.update(set(re.findall(r'import_structure\[\"([^\"]*)\"\]' , _UpperCAmelCase ) ) )
lowerCamelCase__ : Optional[int] = [
module
for module in get_transformers_submodules()
if module not in IGNORE_SUBMODULES and module not in import_structure_keys
]
if len(_UpperCAmelCase ) > 0:
lowerCamelCase__ : Optional[int] = '\n'.join(F"""- {module}""" for module in module_not_registered )
raise ValueError(
'The following submodules are not properly registed in the main init of Transformers:\n'
F"""{list_of_modules}\n"""
'Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.' )
if __name__ == "__main__":
check_all_inits()
check_submodules()
| 295
|
from typing import List
from ...configuration_utils import PretrainedConfig
from ...utils import logging
_UpperCAmelCase : Any = logging.get_logger(__name__)
_UpperCAmelCase : Union[str, Any] = {
"""snap-research/efficientformer-l1-300""": (
"""https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json"""
),
}
class lowerCAmelCase ( __UpperCamelCase ):
UpperCAmelCase__ = """efficientformer"""
def __init__( self : Dict , UpperCAmelCase : List[int] = [3, 2, 6, 4] , UpperCAmelCase : List[int] = [48, 96, 224, 448] , UpperCAmelCase : List[bool] = [True, True, True, True] , UpperCAmelCase : int = 448 , UpperCAmelCase : int = 32 , UpperCAmelCase : int = 4 , UpperCAmelCase : int = 7 , UpperCAmelCase : int = 5 , UpperCAmelCase : int = 8 , UpperCAmelCase : int = 4 , UpperCAmelCase : float = 0.0 , UpperCAmelCase : int = 16 , UpperCAmelCase : int = 3 , UpperCAmelCase : int = 3 , UpperCAmelCase : int = 3 , UpperCAmelCase : int = 2 , UpperCAmelCase : int = 1 , UpperCAmelCase : float = 0.0 , UpperCAmelCase : int = 1 , UpperCAmelCase : bool = True , UpperCAmelCase : bool = True , UpperCAmelCase : float = 1e-5 , UpperCAmelCase : str = "gelu" , UpperCAmelCase : float = 0.0_2 , UpperCAmelCase : float = 1e-12 , UpperCAmelCase : int = 224 , UpperCAmelCase : float = 1e-05 , **UpperCAmelCase : Tuple , ) -> None:
super().__init__(**UpperCAmelCase )
lowerCamelCase__ : Optional[Any] = hidden_act
lowerCamelCase__ : int = hidden_dropout_prob
lowerCamelCase__ : List[Any] = hidden_sizes
lowerCamelCase__ : int = num_hidden_layers
lowerCamelCase__ : int = num_attention_heads
lowerCamelCase__ : Dict = initializer_range
lowerCamelCase__ : Optional[Any] = layer_norm_eps
lowerCamelCase__ : int = patch_size
lowerCamelCase__ : List[Any] = num_channels
lowerCamelCase__ : List[str] = depths
lowerCamelCase__ : Any = mlp_expansion_ratio
lowerCamelCase__ : Any = downsamples
lowerCamelCase__ : str = dim
lowerCamelCase__ : Tuple = key_dim
lowerCamelCase__ : int = attention_ratio
lowerCamelCase__ : int = resolution
lowerCamelCase__ : Dict = pool_size
lowerCamelCase__ : List[str] = downsample_patch_size
lowerCamelCase__ : Tuple = downsample_stride
lowerCamelCase__ : int = downsample_pad
lowerCamelCase__ : Optional[int] = drop_path_rate
lowerCamelCase__ : Optional[Any] = num_metaad_blocks
lowerCamelCase__ : Any = distillation
lowerCamelCase__ : Optional[int] = use_layer_scale
lowerCamelCase__ : Union[str, Any] = layer_scale_init_value
lowerCamelCase__ : Optional[int] = image_size
lowerCamelCase__ : Optional[Any] = batch_norm_eps
| 295
| 1
|
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
SCREAMING_SNAKE_CASE_ = logging.get_logger(__name__)
SCREAMING_SNAKE_CASE_ = {
"""facebook/convnextv2-tiny-1k-224""": """https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json""",
}
class UpperCamelCase__ ( lowerCAmelCase_ , lowerCAmelCase_ ):
'''simple docstring'''
__snake_case : Any = "convnextv2"
def __init__( self : Union[str, Any] ,lowerCamelCase__ : Tuple=3 ,lowerCamelCase__ : Any=4 ,lowerCamelCase__ : str=4 ,lowerCamelCase__ : str=None ,lowerCamelCase__ : Union[str, Any]=None ,lowerCamelCase__ : int="gelu" ,lowerCamelCase__ : List[Any]=0.02 ,lowerCamelCase__ : int=1e-1_2 ,lowerCamelCase__ : int=0.0 ,lowerCamelCase__ : Optional[Any]=224 ,lowerCamelCase__ : Optional[int]=None ,lowerCamelCase__ : str=None ,**lowerCamelCase__ : Union[str, Any] ,) -> int:
'''simple docstring'''
super().__init__(**lowerCamelCase__ )
SCREAMING_SNAKE_CASE = num_channels
SCREAMING_SNAKE_CASE = patch_size
SCREAMING_SNAKE_CASE = num_stages
SCREAMING_SNAKE_CASE = [96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
SCREAMING_SNAKE_CASE = [3, 3, 9, 3] if depths is None else depths
SCREAMING_SNAKE_CASE = hidden_act
SCREAMING_SNAKE_CASE = initializer_range
SCREAMING_SNAKE_CASE = layer_norm_eps
SCREAMING_SNAKE_CASE = drop_path_rate
SCREAMING_SNAKE_CASE = image_size
SCREAMING_SNAKE_CASE = ["""stem"""] + [F"""stage{idx}""" for idx in range(1 ,len(self.depths ) + 1 )]
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = get_aligned_output_features_output_indices(
out_features=lowerCamelCase__ ,out_indices=lowerCamelCase__ ,stage_names=self.stage_names )
| 116
|
import inspect
import unittest
import numpy as np
from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel
if is_vision_available():
from transformers import MaskaFormerImageProcessor
if is_vision_available():
from PIL import Image
class UpperCamelCase__ :
'''simple docstring'''
def __init__( self : Tuple ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Tuple=2 ,lowerCamelCase__ : Optional[int]=True ,lowerCamelCase__ : int=False ,lowerCamelCase__ : List[str]=10 ,lowerCamelCase__ : int=3 ,lowerCamelCase__ : Optional[Any]=32 * 8 ,lowerCamelCase__ : Tuple=32 * 8 ,lowerCamelCase__ : Tuple=4 ,lowerCamelCase__ : int=64 ,) -> List[Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = parent
SCREAMING_SNAKE_CASE = batch_size
SCREAMING_SNAKE_CASE = is_training
SCREAMING_SNAKE_CASE = use_auxiliary_loss
SCREAMING_SNAKE_CASE = num_queries
SCREAMING_SNAKE_CASE = num_channels
SCREAMING_SNAKE_CASE = min_size
SCREAMING_SNAKE_CASE = max_size
SCREAMING_SNAKE_CASE = num_labels
SCREAMING_SNAKE_CASE = hidden_dim
SCREAMING_SNAKE_CASE = hidden_dim
def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ) -> str:
'''simple docstring'''
SCREAMING_SNAKE_CASE = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to(
lowerCamelCase__ )
SCREAMING_SNAKE_CASE = torch.ones([self.batch_size, self.min_size, self.max_size] ,device=lowerCamelCase__ )
SCREAMING_SNAKE_CASE = (
torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] ,device=lowerCamelCase__ ) > 0.5
).float()
SCREAMING_SNAKE_CASE = (torch.rand((self.batch_size, self.num_labels) ,device=lowerCamelCase__ ) > 0.5).long()
SCREAMING_SNAKE_CASE = self.get_config()
return config, pixel_values, pixel_mask, mask_labels, class_labels
def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ) -> int:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerConfig(
hidden_size=self.hidden_dim ,)
SCREAMING_SNAKE_CASE = self.num_queries
SCREAMING_SNAKE_CASE = self.num_labels
SCREAMING_SNAKE_CASE = [1, 1, 1, 1]
SCREAMING_SNAKE_CASE = self.num_channels
SCREAMING_SNAKE_CASE = 64
SCREAMING_SNAKE_CASE = 128
SCREAMING_SNAKE_CASE = self.hidden_dim
SCREAMING_SNAKE_CASE = self.hidden_dim
SCREAMING_SNAKE_CASE = self.hidden_dim
return config
def SCREAMING_SNAKE_CASE__ ( self : str ) -> Dict:
'''simple docstring'''
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs()
SCREAMING_SNAKE_CASE = {"""pixel_values""": pixel_values, """pixel_mask""": pixel_mask}
return config, inputs_dict
def SCREAMING_SNAKE_CASE__ ( self : List[str] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Dict ) -> str:
'''simple docstring'''
SCREAMING_SNAKE_CASE = output.encoder_hidden_states
SCREAMING_SNAKE_CASE = output.pixel_decoder_hidden_states
SCREAMING_SNAKE_CASE = output.transformer_decoder_hidden_states
self.parent.assertTrue(len(lowerCamelCase__ ) ,len(config.backbone_config.depths ) )
self.parent.assertTrue(len(lowerCamelCase__ ) ,len(config.backbone_config.depths ) )
self.parent.assertTrue(len(lowerCamelCase__ ) ,config.decoder_layers )
def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Any ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int]=False ) -> int:
'''simple docstring'''
with torch.no_grad():
SCREAMING_SNAKE_CASE = MaskaFormerModel(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
SCREAMING_SNAKE_CASE = model(pixel_values=lowerCamelCase__ ,pixel_mask=lowerCamelCase__ )
SCREAMING_SNAKE_CASE = model(lowerCamelCase__ ,output_hidden_states=lowerCamelCase__ )
self.parent.assertEqual(
output.transformer_decoder_last_hidden_state.shape ,(self.batch_size, self.num_queries, self.hidden_dim) ,)
# let's ensure the other two hidden state exists
self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None )
self.parent.assertTrue(output.encoder_last_hidden_state is not None )
if output_hidden_states:
self.check_output_hidden_state(lowerCamelCase__ ,lowerCamelCase__ )
def SCREAMING_SNAKE_CASE__ ( self : Any ,lowerCamelCase__ : Any ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Any ) -> Optional[int]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerForUniversalSegmentation(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
def comm_check_on_output(lowerCamelCase__ : Optional[int] ):
# let's still check that all the required stuff is there
self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None )
self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None )
self.parent.assertTrue(result.encoder_last_hidden_state is not None )
# okay, now we need to check the logits shape
# due to the encoder compression, masks have a //4 spatial size
self.parent.assertEqual(
result.masks_queries_logits.shape ,(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) ,)
# + 1 for null class
self.parent.assertEqual(
result.class_queries_logits.shape ,(self.batch_size, self.num_queries, self.num_labels + 1) )
with torch.no_grad():
SCREAMING_SNAKE_CASE = model(pixel_values=lowerCamelCase__ ,pixel_mask=lowerCamelCase__ )
SCREAMING_SNAKE_CASE = model(lowerCamelCase__ )
comm_check_on_output(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = model(
pixel_values=lowerCamelCase__ ,pixel_mask=lowerCamelCase__ ,mask_labels=lowerCamelCase__ ,class_labels=lowerCamelCase__ )
comm_check_on_output(lowerCamelCase__ )
self.parent.assertTrue(result.loss is not None )
self.parent.assertEqual(result.loss.shape ,torch.Size([1] ) )
@require_torch
class UpperCamelCase__ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ):
'''simple docstring'''
__snake_case : Union[str, Any] = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
__snake_case : Optional[Any] = {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}
__snake_case : Dict = False
__snake_case : Tuple = False
__snake_case : Union[str, Any] = False
__snake_case : Optional[Any] = False
def SCREAMING_SNAKE_CASE__ ( self : int ) -> Optional[int]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerModelTester(self )
SCREAMING_SNAKE_CASE = ConfigTester(self ,config_class=lowerCamelCase__ ,has_text_modality=lowerCamelCase__ )
def SCREAMING_SNAKE_CASE__ ( self : int ) -> Dict:
'''simple docstring'''
self.config_tester.run_common_tests()
def SCREAMING_SNAKE_CASE__ ( self : str ) -> Union[str, Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common()
self.model_tester.create_and_check_maskaformer_model(lowerCamelCase__ ,**lowerCamelCase__ ,output_hidden_states=lowerCamelCase__ )
def SCREAMING_SNAKE_CASE__ ( self : List[str] ) -> Optional[Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowerCamelCase__ )
@unittest.skip(reason="""Mask2Former does not use inputs_embeds""" )
def SCREAMING_SNAKE_CASE__ ( self : Dict ) -> int:
'''simple docstring'''
pass
@unittest.skip(reason="""Mask2Former does not have a get_input_embeddings method""" )
def SCREAMING_SNAKE_CASE__ ( self : Tuple ) -> Tuple:
'''simple docstring'''
pass
@unittest.skip(reason="""Mask2Former is not a generative model""" )
def SCREAMING_SNAKE_CASE__ ( self : Tuple ) -> Dict:
'''simple docstring'''
pass
@unittest.skip(reason="""Mask2Former does not use token embeddings""" )
def SCREAMING_SNAKE_CASE__ ( self : Optional[Any] ) -> List[Any]:
'''simple docstring'''
pass
@require_torch_multi_gpu
@unittest.skip(
reason="""Mask2Former has some layers using `add_module` which doesn't work well with `nn.DataParallel`""" )
def SCREAMING_SNAKE_CASE__ ( self : Tuple ) -> Any:
'''simple docstring'''
pass
@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
def SCREAMING_SNAKE_CASE__ ( self : List[str] ) -> Tuple:
'''simple docstring'''
pass
def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ) -> List[Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
SCREAMING_SNAKE_CASE = model_class(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
SCREAMING_SNAKE_CASE = [*signature.parameters.keys()]
SCREAMING_SNAKE_CASE = ["""pixel_values"""]
self.assertListEqual(arg_names[:1] ,lowerCamelCase__ )
@slow
def SCREAMING_SNAKE_CASE__ ( self : Any ) -> Any:
'''simple docstring'''
for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
SCREAMING_SNAKE_CASE = MaskaFormerModel.from_pretrained(lowerCamelCase__ )
self.assertIsNotNone(lowerCamelCase__ )
def SCREAMING_SNAKE_CASE__ ( self : Any ) -> Union[str, Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = (self.model_tester.min_size,) * 2
SCREAMING_SNAKE_CASE = {
"""pixel_values""": torch.randn((2, 3, *size) ,device=lowerCamelCase__ ),
"""mask_labels""": torch.randn((2, 10, *size) ,device=lowerCamelCase__ ),
"""class_labels""": torch.zeros(2 ,10 ,device=lowerCamelCase__ ).long(),
}
SCREAMING_SNAKE_CASE = self.model_tester.get_config()
SCREAMING_SNAKE_CASE = MaskaFormerForUniversalSegmentation(lowerCamelCase__ ).to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = model(**lowerCamelCase__ )
self.assertTrue(outputs.loss is not None )
def SCREAMING_SNAKE_CASE__ ( self : int ) -> List[str]:
'''simple docstring'''
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common()
self.model_tester.create_and_check_maskaformer_model(lowerCamelCase__ ,**lowerCamelCase__ ,output_hidden_states=lowerCamelCase__ )
def SCREAMING_SNAKE_CASE__ ( self : Dict ) -> Optional[Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
SCREAMING_SNAKE_CASE = model_class(lowerCamelCase__ ).to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = model(**lowerCamelCase__ ,output_attentions=lowerCamelCase__ )
self.assertTrue(outputs.attentions is not None )
def SCREAMING_SNAKE_CASE__ ( self : Tuple ) -> List[str]:
'''simple docstring'''
if not self.model_tester.is_training:
return
SCREAMING_SNAKE_CASE = self.all_model_classes[1]
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs()
SCREAMING_SNAKE_CASE = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.train()
SCREAMING_SNAKE_CASE = model(lowerCamelCase__ ,mask_labels=lowerCamelCase__ ,class_labels=lowerCamelCase__ ).loss
loss.backward()
def SCREAMING_SNAKE_CASE__ ( self : int ) -> Optional[int]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = self.all_model_classes[1]
SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs()
SCREAMING_SNAKE_CASE = True
SCREAMING_SNAKE_CASE = True
SCREAMING_SNAKE_CASE = model_class(lowerCamelCase__ ).to(lowerCamelCase__ )
model.train()
SCREAMING_SNAKE_CASE = model(lowerCamelCase__ ,mask_labels=lowerCamelCase__ ,class_labels=lowerCamelCase__ )
SCREAMING_SNAKE_CASE = outputs.encoder_hidden_states[0]
encoder_hidden_states.retain_grad()
SCREAMING_SNAKE_CASE = outputs.pixel_decoder_hidden_states[0]
pixel_decoder_hidden_states.retain_grad()
SCREAMING_SNAKE_CASE = outputs.transformer_decoder_hidden_states[0]
transformer_decoder_hidden_states.retain_grad()
SCREAMING_SNAKE_CASE = outputs.attentions[0]
attentions.retain_grad()
outputs.loss.backward(retain_graph=lowerCamelCase__ )
self.assertIsNotNone(encoder_hidden_states.grad )
self.assertIsNotNone(pixel_decoder_hidden_states.grad )
self.assertIsNotNone(transformer_decoder_hidden_states.grad )
self.assertIsNotNone(attentions.grad )
SCREAMING_SNAKE_CASE_ = 1e-4
def __lowercase ( ) -> Any:
'''simple docstring'''
SCREAMING_SNAKE_CASE = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
return image
@require_vision
@slow
class UpperCamelCase__ ( unittest.TestCase ):
'''simple docstring'''
@cached_property
def SCREAMING_SNAKE_CASE__ ( self : str ) -> Optional[int]:
'''simple docstring'''
return "facebook/mask2former-swin-small-coco-instance"
@cached_property
def SCREAMING_SNAKE_CASE__ ( self : Optional[Any] ) -> Optional[int]:
'''simple docstring'''
return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None
def SCREAMING_SNAKE_CASE__ ( self : Dict ) -> int:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = self.default_image_processor
SCREAMING_SNAKE_CASE = prepare_img()
SCREAMING_SNAKE_CASE = image_processor(lowerCamelCase__ ,return_tensors="""pt""" ).to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = inputs["""pixel_values"""].shape
# check size is divisible by 32
self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
# check size
self.assertEqual(lowerCamelCase__ ,(1, 3, 384, 384) )
with torch.no_grad():
SCREAMING_SNAKE_CASE = model(**lowerCamelCase__ )
SCREAMING_SNAKE_CASE = torch.tensor(
[[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]] ).to(lowerCamelCase__ )
self.assertTrue(
torch.allclose(
outputs.encoder_last_hidden_state[0, 0, :3, :3] ,lowerCamelCase__ ,atol=lowerCamelCase__ ) )
SCREAMING_SNAKE_CASE = torch.tensor(
[[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]] ).to(lowerCamelCase__ )
self.assertTrue(
torch.allclose(
outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] ,lowerCamelCase__ ,atol=lowerCamelCase__ ) )
SCREAMING_SNAKE_CASE = torch.tensor(
[[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]] ).to(lowerCamelCase__ )
self.assertTrue(
torch.allclose(
outputs.transformer_decoder_last_hidden_state[0, :3, :3] ,lowerCamelCase__ ,atol=lowerCamelCase__ ) )
def SCREAMING_SNAKE_CASE__ ( self : int ) -> int:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(lowerCamelCase__ ).eval()
SCREAMING_SNAKE_CASE = self.default_image_processor
SCREAMING_SNAKE_CASE = prepare_img()
SCREAMING_SNAKE_CASE = image_processor(lowerCamelCase__ ,return_tensors="""pt""" ).to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = inputs["""pixel_values"""].shape
# check size is divisible by 32
self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
# check size
self.assertEqual(lowerCamelCase__ ,(1, 3, 384, 384) )
with torch.no_grad():
SCREAMING_SNAKE_CASE = model(**lowerCamelCase__ )
# masks_queries_logits
SCREAMING_SNAKE_CASE = outputs.masks_queries_logits
self.assertEqual(
masks_queries_logits.shape ,(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) )
SCREAMING_SNAKE_CASE = [
[-8.7839, -9.0056, -8.8121],
[-7.4104, -7.0313, -6.5401],
[-6.6105, -6.3427, -6.4675],
]
SCREAMING_SNAKE_CASE = torch.tensor(lowerCamelCase__ ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] ,lowerCamelCase__ ,atol=lowerCamelCase__ ) )
# class_queries_logits
SCREAMING_SNAKE_CASE = outputs.class_queries_logits
self.assertEqual(class_queries_logits.shape ,(1, model.config.num_queries, model.config.num_labels + 1) )
SCREAMING_SNAKE_CASE = torch.tensor(
[
[1.8324, -8.0835, -4.1922],
[0.8450, -9.0050, -3.6053],
[0.3045, -7.7293, -3.0275],
] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] ,lowerCamelCase__ ,atol=lowerCamelCase__ ) )
def SCREAMING_SNAKE_CASE__ ( self : int ) -> Optional[int]:
'''simple docstring'''
SCREAMING_SNAKE_CASE = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(lowerCamelCase__ ).eval()
SCREAMING_SNAKE_CASE = self.default_image_processor
SCREAMING_SNAKE_CASE = image_processor(
[np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] ,segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] ,return_tensors="""pt""" ,)
SCREAMING_SNAKE_CASE = inputs["""pixel_values"""].to(lowerCamelCase__ )
SCREAMING_SNAKE_CASE = [el.to(lowerCamelCase__ ) for el in inputs["""mask_labels"""]]
SCREAMING_SNAKE_CASE = [el.to(lowerCamelCase__ ) for el in inputs["""class_labels"""]]
with torch.no_grad():
SCREAMING_SNAKE_CASE = model(**lowerCamelCase__ )
self.assertTrue(outputs.loss is not None )
| 116
| 1
|
'''simple docstring'''
import argparse
import random
import joblib
import numpy as np
import torch
from igf.igf import (
SecondaryLearner,
collect_objective_set,
compute_perplexity,
generate_datasets,
load_gpta,
recopy_gpta,
set_seed,
train_secondary_learner,
)
from torch.utils.data import DataLoader, RandomSampler
from transformers import GPTaLMHeadModel
def __lowerCamelCase ( SCREAMING_SNAKE_CASE_ : Tuple=3_2 , SCREAMING_SNAKE_CASE_ : Dict=1_0 , SCREAMING_SNAKE_CASE_ : Any=1_0_0 , SCREAMING_SNAKE_CASE_ : Any=1_0_2_6 , SCREAMING_SNAKE_CASE_ : Any=True , SCREAMING_SNAKE_CASE_ : List[Any]="data/tokenized_stories_train_wikitext103.jbl" , SCREAMING_SNAKE_CASE_ : Optional[Any]="igf_context_pairs.jbl" , ) -> Dict:
"""simple docstring"""
set_seed(3 )
# generate train_data and objective_set
SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ : Union[str, Any] = generate_datasets(
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , number=SCREAMING_SNAKE_CASE_ , min_len=1_0_2_6 , trim=SCREAMING_SNAKE_CASE_ )
# keeps model same across runs
set_seed(4 )
# model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights
# can we train on GPU?
SCREAMING_SNAKE_CASE_ : List[str] = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" )
# load pretrained model
SCREAMING_SNAKE_CASE_ : List[Any] = load_gpta("gpt2" ).to(SCREAMING_SNAKE_CASE_ )
print("computing perplexity on objective set" )
SCREAMING_SNAKE_CASE_ : Tuple = compute_perplexity(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ).item()
print("perplexity on objective set:" , SCREAMING_SNAKE_CASE_ )
# collect igf pairs and save to file demo.jbl
collect_objective_set(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
# clean up, delete model and data we don't need anymore
del model, train_data, objective_set
torch.cuda.empty_cache()
def __lowerCamelCase ( SCREAMING_SNAKE_CASE_ : Optional[int] , SCREAMING_SNAKE_CASE_ : str=1_5 , SCREAMING_SNAKE_CASE_ : int=1_2_8 , SCREAMING_SNAKE_CASE_ : Optional[int]=1_0_0 , SCREAMING_SNAKE_CASE_ : Any="igf_model.pt" , ) -> List[str]:
"""simple docstring"""
set_seed(4_2 )
# Load pre-trained model
SCREAMING_SNAKE_CASE_ : Optional[Any] = GPTaLMHeadModel.from_pretrained("gpt2" )
# Initialize secondary learner to use embedding weights of model
SCREAMING_SNAKE_CASE_ : str = SecondaryLearner(SCREAMING_SNAKE_CASE_ )
# Train secondary learner
SCREAMING_SNAKE_CASE_ : List[str] = train_secondary_learner(
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , max_epochs=SCREAMING_SNAKE_CASE_ , batch_size=SCREAMING_SNAKE_CASE_ , eval_freq=1_0_0 , igf_model_path=SCREAMING_SNAKE_CASE_ , )
del model, secondary_learner_train_data
torch.cuda.empty_cache()
return secondary_learner
def __lowerCamelCase ( SCREAMING_SNAKE_CASE_ : List[Any] , SCREAMING_SNAKE_CASE_ : int , SCREAMING_SNAKE_CASE_ : Dict , SCREAMING_SNAKE_CASE_ : List[Any]=3_2 , SCREAMING_SNAKE_CASE_ : Optional[Any]=1_0_0_0 , SCREAMING_SNAKE_CASE_ : Tuple=1_6 , SCREAMING_SNAKE_CASE_ : Dict=1.0 , SCREAMING_SNAKE_CASE_ : List[Any]=recopy_gpta , SCREAMING_SNAKE_CASE_ : Optional[Any]=None , SCREAMING_SNAKE_CASE_ : int=1_0 , SCREAMING_SNAKE_CASE_ : List[Any]="gpt2_finetuned.pt" , ) -> List[str]:
"""simple docstring"""
SCREAMING_SNAKE_CASE_ : Any = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" )
SCREAMING_SNAKE_CASE_ : List[Any] = RandomSampler(SCREAMING_SNAKE_CASE_ )
SCREAMING_SNAKE_CASE_ : Dict = DataLoader(SCREAMING_SNAKE_CASE_ , sampler=SCREAMING_SNAKE_CASE_ )
SCREAMING_SNAKE_CASE_ : Tuple = max_steps // (len(SCREAMING_SNAKE_CASE_ )) + 1
SCREAMING_SNAKE_CASE_ : int = 0
SCREAMING_SNAKE_CASE_ : Optional[int] = torch.zeros((1, context_len) , dtype=torch.long , device=SCREAMING_SNAKE_CASE_ )
SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ : List[Any] = recopy_model(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
model.train()
if secondary_learner is not None:
secondary_learner.to(SCREAMING_SNAKE_CASE_ )
secondary_learner.eval()
SCREAMING_SNAKE_CASE_ : Tuple = []
SCREAMING_SNAKE_CASE_ : Any = 0
SCREAMING_SNAKE_CASE_ : List[Any] = []
SCREAMING_SNAKE_CASE_ : Any = []
# Compute the performance of the transformer model at the beginning
SCREAMING_SNAKE_CASE_ : Tuple = compute_perplexity(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
test_perps.append(SCREAMING_SNAKE_CASE_ )
print("Test perplexity, step" , SCREAMING_SNAKE_CASE_ , ":" , SCREAMING_SNAKE_CASE_ )
for epoch in range(int(SCREAMING_SNAKE_CASE_ ) ):
for step, example in enumerate(SCREAMING_SNAKE_CASE_ ):
torch.cuda.empty_cache()
SCREAMING_SNAKE_CASE_ : List[Any] = random.randint(0 , example.size(2 ) - context_len - 1 )
SCREAMING_SNAKE_CASE_ : Optional[int] = example[0, 0, start : start + context_len]
lm_optimizer.zero_grad()
SCREAMING_SNAKE_CASE_ : Dict = model(SCREAMING_SNAKE_CASE_ , labels=SCREAMING_SNAKE_CASE_ )
SCREAMING_SNAKE_CASE_ : Optional[int] = True
if secondary_learner is not None:
SCREAMING_SNAKE_CASE_ : Union[str, Any] = secondary_learner.forward(
torch.tensor(SCREAMING_SNAKE_CASE_ , dtype=torch.long , device=SCREAMING_SNAKE_CASE_ ).unsqueeze(0 ) )[0].item()
observed_qs.append(float(SCREAMING_SNAKE_CASE_ ) )
# Here we implement the simple non-constant threshold for the predicted IG(X) value
# We will decay the selectivity of our secondary learner filter from
# 1 standard deviation above average to 1 below average after 10 batches.
if global_step == 1_0:
SCREAMING_SNAKE_CASE_ : str = -1
if predicted_q < threshold:
SCREAMING_SNAKE_CASE_ : Optional[Any] = False
# If we passed the filter, add the context to the batch!
if do_backprop:
contexts.append(np.array(context.cpu() ) )
SCREAMING_SNAKE_CASE_ : Union[str, Any] = outputs[0]
lm_loss.backward()
examples += 1
del outputs
# Once the batch is filled with enough contexts, backprop on the batch.
if examples == batch_size:
torch.cuda.empty_cache()
SCREAMING_SNAKE_CASE_ : List[str] = 0
# Do LM backprop
torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0 )
lm_optimizer.step()
lm_scheduler.step() # Update learning rate schedule
global_step += 1
# Compute the performance of the transformer model at this batch
if global_step % eval_interval == 0:
SCREAMING_SNAKE_CASE_ : Optional[int] = compute_perplexity(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
test_perps.append(SCREAMING_SNAKE_CASE_ )
print("Test perplexity, step" , SCREAMING_SNAKE_CASE_ , ":" , SCREAMING_SNAKE_CASE_ )
# Break out of the loop after 60 batches
if max_steps > 0 and global_step > 6_0:
break
if max_steps > 0 and global_step > 6_0:
break
# save finetuned transformer model
torch.save(model.state_dict() , SCREAMING_SNAKE_CASE_ )
torch.cuda.empty_cache()
# Do some cleaning up so we can reinitialize for the next run of this function
del lm_optimizer
del lm_scheduler
return model
def __lowerCamelCase ( ) -> Union[str, Any]:
"""simple docstring"""
SCREAMING_SNAKE_CASE_ : str = argparse.ArgumentParser(description="Fine-tune a transformer model with IGF on a language modeling task" )
# Required parameters
parser.add_argument(
"--data_dir" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , required=SCREAMING_SNAKE_CASE_ , help="The input data dir. Should contain data files for WikiText." , )
parser.add_argument(
"--model_name_or_path" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , required=SCREAMING_SNAKE_CASE_ , help="Path to pretrained model or model identifier from huggingface.co/models" , )
parser.add_argument(
"--data_file" , type=SCREAMING_SNAKE_CASE_ , default=SCREAMING_SNAKE_CASE_ , help=(
"A jbl file containing tokenized data which can be split as objective dataset, "
"train_dataset and test_dataset."
) , )
parser.add_argument(
"--igf_data_file" , type=SCREAMING_SNAKE_CASE_ , default=SCREAMING_SNAKE_CASE_ , help="A jbl file containing the context and information gain pairs to train secondary learner." , )
parser.add_argument(
"--output_dir" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , required=SCREAMING_SNAKE_CASE_ , help="The output directory where the final fine-tuned model is stored." , )
parser.add_argument(
"--tokenizer_name" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , help="Pretrained tokenizer name or path if not the same as model_name" , )
parser.add_argument("--seed" , type=SCREAMING_SNAKE_CASE_ , default=SCREAMING_SNAKE_CASE_ , help="A seed for reproducible training." )
parser.add_argument(
"--context_len" , default=3_2 , type=SCREAMING_SNAKE_CASE_ , help=(
"The maximum total input sequence length after tokenization. Sequences longer "
"than this will be truncated, sequences shorter will be padded."
) , )
parser.add_argument(
"--size_objective_set" , default=1_0_0 , type=SCREAMING_SNAKE_CASE_ , help="number of articles that are long enough to be used as our objective set" , )
parser.add_argument(
"--eval_freq" , default=1_0_0 , type=SCREAMING_SNAKE_CASE_ , help="secondary model evaluation is triggered at eval_freq" )
parser.add_argument("--max_steps" , default=1_0_0_0 , type=SCREAMING_SNAKE_CASE_ , help="To calculate training epochs" )
parser.add_argument(
"--secondary_learner_batch_size" , default=1_2_8 , type=SCREAMING_SNAKE_CASE_ , help="batch size of training data for secondary learner" , )
parser.add_argument(
"--batch_size" , default=1_6 , type=SCREAMING_SNAKE_CASE_ , help="batch size of training data of language model(gpt2) " )
parser.add_argument(
"--eval_interval" , default=1_0 , type=SCREAMING_SNAKE_CASE_ , help=(
"decay the selectivity of our secondary learner filter from"
"1 standard deviation above average to 1 below average after 10 batches"
) , )
parser.add_argument(
"--number" , default=1_0_0 , type=SCREAMING_SNAKE_CASE_ , help="The number of examples split to be used as objective_set/test_data" )
parser.add_argument(
"--min_len" , default=1_0_2_6 , type=SCREAMING_SNAKE_CASE_ , help="The minimum length of the article to be used as objective set" )
parser.add_argument(
"--secondary_learner_max_epochs" , default=1_5 , type=SCREAMING_SNAKE_CASE_ , help="number of epochs to train secondary learner" )
parser.add_argument("--trim" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , help="truncate the example if it exceeds context length" )
parser.add_argument(
"--threshold" , default=1.0 , type=SCREAMING_SNAKE_CASE_ , help=(
"The threshold value used by secondary learner to filter the train_data and allow only"
" informative data as input to the model"
) , )
parser.add_argument("--finetuned_model_name" , default="gpt2_finetuned.pt" , type=SCREAMING_SNAKE_CASE_ , help="finetuned_model_name" )
parser.add_argument(
"--recopy_model" , default=SCREAMING_SNAKE_CASE_ , type=SCREAMING_SNAKE_CASE_ , help="Reset the model to the original pretrained GPT-2 weights after each iteration" , )
# function calls
# Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner
generate_n_pairs(
context_len=3_2 , max_steps=1_0 , size_objective_set=1_0_0 , min_len=1_0_2_6 , trim=SCREAMING_SNAKE_CASE_ , data_file="data/tokenized_stories_train_wikitext103.jbl" , igf_data_file="igf_context_pairs.jbl" , )
# Load train data for secondary learner
SCREAMING_SNAKE_CASE_ : Any = joblib.load("data/IGF_values.jbl" )
# Train secondary learner
SCREAMING_SNAKE_CASE_ : str = training_secondary_learner(
SCREAMING_SNAKE_CASE_ , secondary_learner_max_epochs=1_5 , secondary_learner_batch_size=1_2_8 , eval_freq=1_0_0 , igf_model_path="igf_model.pt" , )
# load pretrained gpt2 model
SCREAMING_SNAKE_CASE_ : Optional[int] = GPTaLMHeadModel.from_pretrained("gpt2" )
set_seed(4_2 )
# Generate train and test data to train and evaluate gpt2 model
SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ : Any = generate_datasets(
context_len=3_2 , file="data/tokenized_stories_train_wikitext103.jbl" , number=1_0_0 , min_len=1_0_2_6 , trim=SCREAMING_SNAKE_CASE_ )
# fine-tuning of the gpt2 model using igf (Information Gain Filtration)
finetune(
SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , context_len=3_2 , max_steps=1_0_0_0 , batch_size=1_6 , threshold=1.0 , recopy_model=SCREAMING_SNAKE_CASE_ , secondary_learner=SCREAMING_SNAKE_CASE_ , eval_interval=1_0 , finetuned_model_name="gpt2_finetuned.pt" , )
if __name__ == "__main__":
main()
| 421
|
'''simple docstring'''
import os
import time
import warnings
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional, Union
import torch
from filelock import FileLock
from torch.utils.data import Dataset
from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from ..processors.utils import InputFeatures
snake_case_ = logging.get_logger(__name__)
@dataclass
class SCREAMING_SNAKE_CASE__ :
_A = field(metadata={"help": "The name of the task to train on: " + ", ".join(glue_processors.keys() )} )
_A = field(
metadata={"help": "The input data dir. Should contain the .tsv files (or other data files) for the task."} )
_A = field(
default=128,metadata={
"help": (
"The maximum total input sequence length after tokenization. Sequences longer "
"than this will be truncated, sequences shorter will be padded."
)
},)
_A = field(
default=_UpperCAmelCase,metadata={"help": "Overwrite the cached training and evaluation sets"} )
def __lowerCamelCase ( self ):
"""simple docstring"""
SCREAMING_SNAKE_CASE_ : Any = self.task_name.lower()
class SCREAMING_SNAKE_CASE__ ( _UpperCAmelCase ):
_A = "train"
_A = "dev"
_A = "test"
class SCREAMING_SNAKE_CASE__ ( _UpperCAmelCase ):
_A = 42
_A = 42
_A = 42
def __init__( self , lowercase__ , lowercase__ , lowercase__ = None , lowercase__ = Split.train , lowercase__ = None , ):
"""simple docstring"""
warnings.warn(
"This dataset will be removed from the library soon, preprocessing should be handled with the 🤗 Datasets "
"library. You can have a look at this example script for pointers: "
"https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py" , lowercase__ , )
SCREAMING_SNAKE_CASE_ : int = args
SCREAMING_SNAKE_CASE_ : List[str] = glue_processors[args.task_name]()
SCREAMING_SNAKE_CASE_ : List[Any] = glue_output_modes[args.task_name]
if isinstance(lowercase__ , lowercase__ ):
try:
SCREAMING_SNAKE_CASE_ : str = Split[mode]
except KeyError:
raise KeyError("mode is not a valid split name" )
# Load data features from cache or dataset file
SCREAMING_SNAKE_CASE_ : Union[str, Any] = os.path.join(
cache_dir if cache_dir is not None else args.data_dir , F"cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{args.task_name}" , )
SCREAMING_SNAKE_CASE_ : Tuple = self.processor.get_labels()
if args.task_name in ["mnli", "mnli-mm"] and tokenizer.__class__.__name__ in (
"RobertaTokenizer",
"RobertaTokenizerFast",
"XLMRobertaTokenizer",
"BartTokenizer",
"BartTokenizerFast",
):
# HACK(label indices are swapped in RoBERTa pretrained model)
SCREAMING_SNAKE_CASE_, SCREAMING_SNAKE_CASE_ : int = label_list[2], label_list[1]
SCREAMING_SNAKE_CASE_ : Optional[Any] = label_list
# Make sure only the first process in distributed training processes the dataset,
# and the others will use the cache.
SCREAMING_SNAKE_CASE_ : Optional[Any] = cached_features_file + ".lock"
with FileLock(lowercase__ ):
if os.path.exists(lowercase__ ) and not args.overwrite_cache:
SCREAMING_SNAKE_CASE_ : int = time.time()
SCREAMING_SNAKE_CASE_ : int = torch.load(lowercase__ )
logger.info(
F"Loading features from cached file {cached_features_file} [took %.3f s]" , time.time() - start )
else:
logger.info(F"Creating features from dataset file at {args.data_dir}" )
if mode == Split.dev:
SCREAMING_SNAKE_CASE_ : str = self.processor.get_dev_examples(args.data_dir )
elif mode == Split.test:
SCREAMING_SNAKE_CASE_ : int = self.processor.get_test_examples(args.data_dir )
else:
SCREAMING_SNAKE_CASE_ : Tuple = self.processor.get_train_examples(args.data_dir )
if limit_length is not None:
SCREAMING_SNAKE_CASE_ : int = examples[:limit_length]
SCREAMING_SNAKE_CASE_ : Optional[Any] = glue_convert_examples_to_features(
lowercase__ , lowercase__ , max_length=args.max_seq_length , label_list=lowercase__ , output_mode=self.output_mode , )
SCREAMING_SNAKE_CASE_ : Optional[Any] = time.time()
torch.save(self.features , lowercase__ )
# ^ This seems to take a lot of time so I want to investigate why and how we can improve.
logger.info(
F"Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]" )
def __len__( self ):
"""simple docstring"""
return len(self.features )
def __getitem__( self , lowercase__ ):
"""simple docstring"""
return self.features[i]
def __lowerCamelCase ( self ):
"""simple docstring"""
return self.label_list
| 421
| 1
|
"""simple docstring"""
import unittest
from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
_lowerCamelCase = get_tests_dir('''fixtures/test_sentencepiece.model''')
@require_sentencepiece
@require_tokenizers
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
lowerCamelCase__ = ReformerTokenizer
lowerCamelCase__ = ReformerTokenizerFast
lowerCamelCase__ = True
lowerCamelCase__ = False
lowerCamelCase__ = True
def SCREAMING_SNAKE_CASE_ ( self :Dict ):
super().setUp()
__SCREAMING_SNAKE_CASE : List[Any] = ReformerTokenizer(_lowerCamelCase , keep_accents=_lowerCamelCase )
tokenizer.save_pretrained(self.tmpdirname )
def SCREAMING_SNAKE_CASE_ ( self :List[Any] ):
__SCREAMING_SNAKE_CASE : Any = '''<s>'''
__SCREAMING_SNAKE_CASE : Tuple = 1
self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowerCamelCase ) , _lowerCamelCase )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowerCamelCase ) , _lowerCamelCase )
def SCREAMING_SNAKE_CASE_ ( self :Optional[Any] ):
__SCREAMING_SNAKE_CASE : Dict = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] , '''<unk>''' )
self.assertEqual(vocab_keys[1] , '''<s>''' )
self.assertEqual(vocab_keys[-1] , '''j''' )
self.assertEqual(len(_lowerCamelCase ) , 1_0_0_0 )
def SCREAMING_SNAKE_CASE_ ( self :List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size , 1_0_0_0 )
def SCREAMING_SNAKE_CASE_ ( self :str ):
if not self.test_rust_tokenizer:
return
__SCREAMING_SNAKE_CASE : Dict = self.get_tokenizer()
__SCREAMING_SNAKE_CASE : List[Any] = self.get_rust_tokenizer()
__SCREAMING_SNAKE_CASE : List[Any] = '''I was born in 92000, and this is falsé.'''
__SCREAMING_SNAKE_CASE : Optional[Any] = tokenizer.tokenize(_lowerCamelCase )
__SCREAMING_SNAKE_CASE : Tuple = rust_tokenizer.tokenize(_lowerCamelCase )
self.assertListEqual(_lowerCamelCase , _lowerCamelCase )
__SCREAMING_SNAKE_CASE : List[str] = tokenizer.encode(_lowerCamelCase , add_special_tokens=_lowerCamelCase )
__SCREAMING_SNAKE_CASE : Tuple = rust_tokenizer.encode(_lowerCamelCase , add_special_tokens=_lowerCamelCase )
self.assertListEqual(_lowerCamelCase , _lowerCamelCase )
__SCREAMING_SNAKE_CASE : List[str] = self.get_rust_tokenizer()
__SCREAMING_SNAKE_CASE : List[Any] = tokenizer.encode(_lowerCamelCase )
__SCREAMING_SNAKE_CASE : Dict = rust_tokenizer.encode(_lowerCamelCase )
self.assertListEqual(_lowerCamelCase , _lowerCamelCase )
def SCREAMING_SNAKE_CASE_ ( self :int , _lowerCamelCase :str=1_5 ):
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
__SCREAMING_SNAKE_CASE : Dict = self.rust_tokenizer_class.from_pretrained(_lowerCamelCase , **_lowerCamelCase )
# Simple input
__SCREAMING_SNAKE_CASE : Dict = '''This is a simple input'''
__SCREAMING_SNAKE_CASE : Optional[Any] = ['''This is a simple input 1''', '''This is a simple input 2''']
__SCREAMING_SNAKE_CASE : Union[str, Any] = ('''This is a simple input''', '''This is a pair''')
__SCREAMING_SNAKE_CASE : Tuple = [
('''This is a simple input 1''', '''This is a simple input 2'''),
('''This is a simple pair 1''', '''This is a simple pair 2'''),
]
# Simple input tests
self.assertRaises(_lowerCamelCase , tokenizer_r.encode , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' )
# Simple input
self.assertRaises(_lowerCamelCase , tokenizer_r.encode_plus , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' )
# Simple input
self.assertRaises(
_lowerCamelCase , tokenizer_r.batch_encode_plus , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' , )
# Pair input
self.assertRaises(_lowerCamelCase , tokenizer_r.encode , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' )
# Pair input
self.assertRaises(_lowerCamelCase , tokenizer_r.encode_plus , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' )
# Pair input
self.assertRaises(
_lowerCamelCase , tokenizer_r.batch_encode_plus , _lowerCamelCase , max_length=_lowerCamelCase , padding='''max_length''' , )
def SCREAMING_SNAKE_CASE_ ( self :List[str] ):
pass
def SCREAMING_SNAKE_CASE_ ( self :List[Any] ):
__SCREAMING_SNAKE_CASE : Dict = ReformerTokenizer(_lowerCamelCase , keep_accents=_lowerCamelCase )
__SCREAMING_SNAKE_CASE : int = tokenizer.tokenize('''This is a test''' )
self.assertListEqual(_lowerCamelCase , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(_lowerCamelCase ) , [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2] , )
__SCREAMING_SNAKE_CASE : str = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' )
self.assertListEqual(
_lowerCamelCase , [
SPIECE_UNDERLINE + '''I''',
SPIECE_UNDERLINE + '''was''',
SPIECE_UNDERLINE + '''b''',
'''or''',
'''n''',
SPIECE_UNDERLINE + '''in''',
SPIECE_UNDERLINE + '''''',
'''9''',
'''2''',
'''0''',
'''0''',
'''0''',
''',''',
SPIECE_UNDERLINE + '''and''',
SPIECE_UNDERLINE + '''this''',
SPIECE_UNDERLINE + '''is''',
SPIECE_UNDERLINE + '''f''',
'''al''',
'''s''',
'''é''',
'''.''',
] , )
__SCREAMING_SNAKE_CASE : Union[str, Any] = tokenizer.convert_tokens_to_ids(_lowerCamelCase )
self.assertListEqual(
_lowerCamelCase , [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4] , )
__SCREAMING_SNAKE_CASE : int = tokenizer.convert_ids_to_tokens(_lowerCamelCase )
self.assertListEqual(
_lowerCamelCase , [
SPIECE_UNDERLINE + '''I''',
SPIECE_UNDERLINE + '''was''',
SPIECE_UNDERLINE + '''b''',
'''or''',
'''n''',
SPIECE_UNDERLINE + '''in''',
SPIECE_UNDERLINE + '''''',
'''<unk>''',
'''2''',
'''0''',
'''0''',
'''0''',
''',''',
SPIECE_UNDERLINE + '''and''',
SPIECE_UNDERLINE + '''this''',
SPIECE_UNDERLINE + '''is''',
SPIECE_UNDERLINE + '''f''',
'''al''',
'''s''',
'''<unk>''',
'''.''',
] , )
@cached_property
def SCREAMING_SNAKE_CASE_ ( self :Tuple ):
return ReformerTokenizer.from_pretrained('''google/reformer-crime-and-punishment''' )
@slow
def SCREAMING_SNAKE_CASE_ ( self :List[str] ):
__SCREAMING_SNAKE_CASE : Optional[Any] = '''Hello World!'''
__SCREAMING_SNAKE_CASE : Tuple = [1_2_6, 3_2, 2_6_2, 1_5_2, 3_8, 7_2, 2_8_7]
self.assertListEqual(_lowerCamelCase , self.big_tokenizer.encode(_lowerCamelCase ) )
@slow
def SCREAMING_SNAKE_CASE_ ( self :Tuple ):
__SCREAMING_SNAKE_CASE : Union[str, Any] = (
'''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
)
__SCREAMING_SNAKE_CASE : Optional[int] = [
1_0_8,
2_6_5,
2_4,
1_1_1,
4,
2_5_8,
1_5_6,
3_5,
2_8,
2_7_5,
3,
2_5_9,
2_9_7,
2_6_0,
8_4,
4,
3_5,
1_1_0,
4_4,
8,
2_5_9,
9_1,
2_6_8,
2_1,
1_1,
2_0_9,
2_7_4,
1_0_9,
2_6_6,
2_7_7,
1_1_7,
8_6,
9_3,
3_1_5,
2_5_8,
2_7_8,
2_5_8,
2_7_7,
2_5_8,
0,
2_5_8,
2_8_8,
2_5_8,
3_1_9,
2_5_8,
0,
2_5_8,
0,
2_5_8,
0,
2_5_8,
0,
2_5_8,
2_8_7,
2_5_8,
3_1_5,
2_5_8,
2_8_9,
2_5_8,
2_7_8,
9_9,
2_6_9,
2_6_6,
2_6_2,
8,
2_5_9,
2_4_1,
4,
2_1_7,
2_3_0,
2_6_8,
2_6_6,
5_5,
1_6_8,
1_0_6,
7_5,
1_9_3,
2_6_6,
2_2_3,
2_7,
4_9,
2_6,
2_8_2,
2_5,
2_6_4,
2_9_9,
1_9,
2_6,
0,
2_5_8,
2_7_7,
1_1_7,
8_6,
9_3,
1_7_6,
1_8_3,
2_7_0,
1_1,
2_6_2,
4_2,
6_1,
2_6_5,
]
self.assertListEqual(_lowerCamelCase , self.big_tokenizer.encode(_lowerCamelCase ) )
@require_torch
@slow
def SCREAMING_SNAKE_CASE_ ( self :Dict ):
import torch
from transformers import ReformerConfig, ReformerModel
# Build sequence
__SCREAMING_SNAKE_CASE : Any = list(self.big_tokenizer.get_vocab().keys() )[:1_0]
__SCREAMING_SNAKE_CASE : Tuple = ''' '''.join(_lowerCamelCase )
__SCREAMING_SNAKE_CASE : Tuple = self.big_tokenizer.encode_plus(_lowerCamelCase , return_tensors='''pt''' )
__SCREAMING_SNAKE_CASE : Dict = self.big_tokenizer.batch_encode_plus([sequence, sequence] , return_tensors='''pt''' )
__SCREAMING_SNAKE_CASE : Any = ReformerConfig()
# The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
__SCREAMING_SNAKE_CASE : Tuple = encoded_sequence['''input_ids'''].shape
__SCREAMING_SNAKE_CASE : Any = ReformerModel(_lowerCamelCase )
# Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size
with torch.no_grad():
model(**_lowerCamelCase )
model(**_lowerCamelCase )
@slow
def SCREAMING_SNAKE_CASE_ ( self :str ):
# fmt: off
__SCREAMING_SNAKE_CASE : Any = {'''input_ids''': [[1_0_8, 2_6_5, 2_4, 1_1_1, 4, 2_5_8, 1_5_6, 7, 5_1, 2_7_9, 5_8, 7, 7_6, 2_5, 6_9, 2_7_8], [1_4_0, 2_4_3, 2_6_4, 1_3_4, 1_7, 2_6_7, 7_7, 2_6_3, 2_2, 2_6_2, 2_9_7, 2_5_8, 3_0_4, 1_7_7, 2_7_9, 2_6_6, 1_4, 8_9, 1_3, 3_5, 2_6_1, 2_9_9, 2_7_2, 1_3_7, 2_7_5, 2_7_8]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # noqa: E501
# fmt: on
# This tokenizer does not know some characters like ")".
# That is the reason why we use very simple texts here.
# Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
__SCREAMING_SNAKE_CASE : Any = [
'''This is a very simple sentence.''',
'''The quick brown fox jumps over the lazy dog.''',
]
self.tokenizer_integration_test_util(
expected_encoding=_lowerCamelCase , model_name='''google/reformer-crime-and-punishment''' , revision='''0e6c3decb8211d49bf881013425dc8b0448b3f5a''' , padding=_lowerCamelCase , sequences=_lowerCamelCase , )
| 710
|
"""simple docstring"""
from __future__ import annotations
_lowerCamelCase = 8.988e9 # units = N * m^s * C^-2
def lowerCAmelCase_ ( lowercase_ : float , lowercase_ : float , lowercase_ : float , lowercase_ : float ):
'''simple docstring'''
__SCREAMING_SNAKE_CASE : Dict = 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:
__SCREAMING_SNAKE_CASE : int = COULOMBS_CONSTANT * charge_product / (distance**2)
return {"force": force}
elif chargea == 0:
__SCREAMING_SNAKE_CASE : List[str] = abs(lowercase_ ) * (distance**2) / (COULOMBS_CONSTANT * chargea)
return {"charge1": chargea}
elif chargea == 0:
__SCREAMING_SNAKE_CASE : Optional[int] = abs(lowercase_ ) * (distance**2) / (COULOMBS_CONSTANT * chargea)
return {"charge2": chargea}
elif distance == 0:
__SCREAMING_SNAKE_CASE : Tuple = (COULOMBS_CONSTANT * charge_product / abs(lowercase_ )) ** 0.5
return {"distance": distance}
raise ValueError('''Exactly one argument must be 0''' )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 401
| 0
|
from ...configuration_utils import PretrainedConfig
from ...utils import logging
_snake_case = logging.get_logger(__name__)
_snake_case = {
'google/fnet-base': 'https://huggingface.co/google/fnet-base/resolve/main/config.json',
'google/fnet-large': 'https://huggingface.co/google/fnet-large/resolve/main/config.json'
# See all FNet models at https://huggingface.co/models?filter=fnet
}
class lowerCAmelCase_ ( _lowercase ):
"""simple docstring"""
UpperCAmelCase__ = "fnet"
def __init__( self , _SCREAMING_SNAKE_CASE=32_000 , _SCREAMING_SNAKE_CASE=768 , _SCREAMING_SNAKE_CASE=12 , _SCREAMING_SNAKE_CASE=3_072 , _SCREAMING_SNAKE_CASE="gelu_new" , _SCREAMING_SNAKE_CASE=0.1 , _SCREAMING_SNAKE_CASE=512 , _SCREAMING_SNAKE_CASE=4 , _SCREAMING_SNAKE_CASE=0.0_2 , _SCREAMING_SNAKE_CASE=1e-1_2 , _SCREAMING_SNAKE_CASE=False , _SCREAMING_SNAKE_CASE=512 , _SCREAMING_SNAKE_CASE=3 , _SCREAMING_SNAKE_CASE=1 , _SCREAMING_SNAKE_CASE=2 , **_SCREAMING_SNAKE_CASE , ) -> str:
super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE , bos_token_id=_SCREAMING_SNAKE_CASE , eos_token_id=_SCREAMING_SNAKE_CASE , **_SCREAMING_SNAKE_CASE )
__UpperCamelCase = vocab_size
__UpperCamelCase = max_position_embeddings
__UpperCamelCase = hidden_size
__UpperCamelCase = num_hidden_layers
__UpperCamelCase = intermediate_size
__UpperCamelCase = hidden_act
__UpperCamelCase = hidden_dropout_prob
__UpperCamelCase = initializer_range
__UpperCamelCase = type_vocab_size
__UpperCamelCase = layer_norm_eps
__UpperCamelCase = use_tpu_fourier_optimizations
__UpperCamelCase = tpu_short_seq_length
| 383
|
def _a ( __lowercase = 1 , __lowercase = 1000 ) -> int:
"""simple docstring"""
__UpperCamelCase = 1
__UpperCamelCase = 0
for divide_by_number in range(__lowercase , digit + 1 ):
__UpperCamelCase = []
__UpperCamelCase = numerator
for _ in range(1 , digit + 1 ):
if now_divide in has_been_divided:
if longest_list_length < len(__lowercase ):
__UpperCamelCase = len(__lowercase )
__UpperCamelCase = divide_by_number
else:
has_been_divided.append(__lowercase )
__UpperCamelCase = now_divide * 10 % divide_by_number
return the_digit
# Tests
if __name__ == "__main__":
import doctest
doctest.testmod()
| 383
| 1
|
"""simple docstring"""
import unittest
from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
if is_flax_available():
import jax.numpy as jnp
from transformers import FlaxXLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_flax
class A__( unittest.TestCase ):
@slow
def _a ( self : Union[str, Any] ) -> Any:
"""simple docstring"""
__SCREAMING_SNAKE_CASE = FlaxXLMRobertaModel.from_pretrained('''xlm-roberta-base''' )
__SCREAMING_SNAKE_CASE = AutoTokenizer.from_pretrained('''xlm-roberta-base''' )
__SCREAMING_SNAKE_CASE = '''The dog is cute and lives in the garden house'''
__SCREAMING_SNAKE_CASE = jnp.array([tokenizer.encode(__SCREAMING_SNAKE_CASE )] )
__SCREAMING_SNAKE_CASE = (1, 12, 7_68) # batch_size, sequence_length, embedding_vector_dim
__SCREAMING_SNAKE_CASE = jnp.array(
[[-0.01_01, 0.12_18, -0.08_03, 0.08_01, 0.13_27, 0.07_76, -0.12_15, 0.23_83, 0.33_38, 0.31_06, 0.03_00, 0.02_52]] )
__SCREAMING_SNAKE_CASE = model(__SCREAMING_SNAKE_CASE )['''last_hidden_state''']
self.assertEqual(output.shape , __SCREAMING_SNAKE_CASE )
# compare the actual values for a slice of last dim
self.assertTrue(jnp.allclose(output[:, :, -1] , __SCREAMING_SNAKE_CASE , atol=1E-3 ) )
| 690
|
"""simple docstring"""
from sklearn.metrics import recall_score
import datasets
lowerCAmelCase__ ="\nRecall is the fraction of the positive examples that were correctly labeled by the model as positive. It can be computed with the equation:\nRecall = TP / (TP + FN)\nWhere TP is the true positives and FN is the false negatives.\n"
lowerCAmelCase__ ="\nArgs:\n- **predictions** (`list` of `int`): The predicted labels.\n- **references** (`list` of `int`): The ground truth labels.\n- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `binary`, and their order when average is `None`. Labels present in the data can be excluded in this input, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in y_true and y_pred are used in sorted order. Defaults to None.\n- **pos_label** (`int`): The class label to use as the 'positive class' when calculating the recall. Defaults to `1`.\n- **average** (`string`): This parameter is required for multiclass/multilabel targets. If None, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.\n - `'binary'`: Only report results for the class specified by `pos_label`. This is applicable only if the target labels and predictions are binary.\n - `'micro'`: Calculate metrics globally by counting the total true positives, false negatives, and false positives.\n - `'macro'`: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - `'weighted'`: Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. Note that it can result in an F-score that is not between precision and recall.\n - `'samples'`: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n- **sample_weight** (`list` of `float`): Sample weights Defaults to `None`.\n- **zero_division** (): Sets the value to return when there is a zero division. Defaults to .\n - `'warn'`: If there is a zero division, the return value is `0`, but warnings are also raised.\n - `0`: If there is a zero division, the return value is `0`.\n - `1`: If there is a zero division, the return value is `1`.\n\nReturns:\n- **recall** (`float`, or `array` of `float`): Either the general recall score, or the recall scores for individual classes, depending on the values input to `labels` and `average`. Minimum possible value is 0. Maximum possible value is 1. A higher recall means that more of the positive examples have been labeled correctly. Therefore, a higher recall is generally considered better.\n\nExamples:\n\n Example 1-A simple example with some errors\n >>> recall_metric = datasets.load_metric('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1])\n >>> print(results)\n {'recall': 0.6666666666666666}\n\n Example 2-The same example as Example 1, but with `pos_label=0` instead of the default `pos_label=1`.\n >>> recall_metric = datasets.load_metric('recall')\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], pos_label=0)\n >>> print(results)\n {'recall': 0.5}\n\n Example 3-The same example as Example 1, but with `sample_weight` included.\n >>> recall_metric = datasets.load_metric('recall')\n >>> sample_weight = [0.9, 0.2, 0.9, 0.3, 0.8]\n >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], sample_weight=sample_weight)\n >>> print(results)\n {'recall': 0.55}\n\n Example 4-A multiclass example, using different averages.\n >>> recall_metric = datasets.load_metric('recall')\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='macro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='micro')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average='weighted')\n >>> print(results)\n {'recall': 0.3333333333333333}\n >>> results = recall_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {'recall': array([1., 0., 0.])}\n"
lowerCAmelCase__ ="\n@article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011}\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class A__( datasets.Metric ):
def _a ( self : Any ) -> int:
"""simple docstring"""
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(
{
'''predictions''': datasets.Sequence(datasets.Value('''int32''' ) ),
'''references''': datasets.Sequence(datasets.Value('''int32''' ) ),
}
if self.config_name == '''multilabel'''
else {
'''predictions''': datasets.Value('''int32''' ),
'''references''': datasets.Value('''int32''' ),
} ) , reference_urls=['''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html'''] , )
def _a ( self : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=None , __SCREAMING_SNAKE_CASE : Optional[int]=1 , __SCREAMING_SNAKE_CASE : Optional[Any]="binary" , __SCREAMING_SNAKE_CASE : List[Any]=None , __SCREAMING_SNAKE_CASE : List[Any]="warn" , ) -> Dict:
"""simple docstring"""
__SCREAMING_SNAKE_CASE = recall_score(
__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , labels=__SCREAMING_SNAKE_CASE , pos_label=__SCREAMING_SNAKE_CASE , average=__SCREAMING_SNAKE_CASE , sample_weight=__SCREAMING_SNAKE_CASE , zero_division=__SCREAMING_SNAKE_CASE , )
return {"recall": float(__SCREAMING_SNAKE_CASE ) if score.size == 1 else score}
| 690
| 1
|
'''simple docstring'''
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
snake_case_ = {
"""configuration_swiftformer""": [
"""SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
"""SwiftFormerConfig""",
"""SwiftFormerOnnxConfig""",
]
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
snake_case_ = [
"""SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""SwiftFormerForImageClassification""",
"""SwiftFormerModel""",
"""SwiftFormerPreTrainedModel""",
]
if TYPE_CHECKING:
from .configuration_swiftformer import (
SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
SwiftFormerConfig,
SwiftFormerOnnxConfig,
)
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_swiftformer import (
SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
SwiftFormerForImageClassification,
SwiftFormerModel,
SwiftFormerPreTrainedModel,
)
else:
import sys
snake_case_ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 507
|
'''simple docstring'''
import json
from typing import List, Optional, Tuple
from tokenizers import pre_tokenizers, processors
from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer
snake_case_ = logging.get_logger(__name__)
snake_case_ = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}
snake_case_ = {
"""vocab_file""": {
"""roberta-base""": """https://huggingface.co/roberta-base/resolve/main/vocab.json""",
"""roberta-large""": """https://huggingface.co/roberta-large/resolve/main/vocab.json""",
"""roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json""",
"""distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/vocab.json""",
"""roberta-base-openai-detector""": """https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json""",
"""roberta-large-openai-detector""": (
"""https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json"""
),
},
"""merges_file""": {
"""roberta-base""": """https://huggingface.co/roberta-base/resolve/main/merges.txt""",
"""roberta-large""": """https://huggingface.co/roberta-large/resolve/main/merges.txt""",
"""roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt""",
"""distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/merges.txt""",
"""roberta-base-openai-detector""": """https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt""",
"""roberta-large-openai-detector""": (
"""https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt"""
),
},
"""tokenizer_file""": {
"""roberta-base""": """https://huggingface.co/roberta-base/resolve/main/tokenizer.json""",
"""roberta-large""": """https://huggingface.co/roberta-large/resolve/main/tokenizer.json""",
"""roberta-large-mnli""": """https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json""",
"""distilroberta-base""": """https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json""",
"""roberta-base-openai-detector""": (
"""https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json"""
),
"""roberta-large-openai-detector""": (
"""https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json"""
),
},
}
snake_case_ = {
"""roberta-base""": 512,
"""roberta-large""": 512,
"""roberta-large-mnli""": 512,
"""distilroberta-base""": 512,
"""roberta-base-openai-detector""": 512,
"""roberta-large-openai-detector""": 512,
}
class a__ ( _lowercase ):
__magic_name__ : Any = VOCAB_FILES_NAMES
__magic_name__ : Any = PRETRAINED_VOCAB_FILES_MAP
__magic_name__ : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__magic_name__ : Dict = ["input_ids", "attention_mask"]
__magic_name__ : Tuple = RobertaTokenizer
def __init__(self : Optional[Any], __UpperCAmelCase : Dict=None, __UpperCAmelCase : Tuple=None, __UpperCAmelCase : Tuple=None, __UpperCAmelCase : Any="replace", __UpperCAmelCase : Dict="<s>", __UpperCAmelCase : List[Any]="</s>", __UpperCAmelCase : Union[str, Any]="</s>", __UpperCAmelCase : int="<s>", __UpperCAmelCase : Optional[Any]="<unk>", __UpperCAmelCase : Tuple="<pad>", __UpperCAmelCase : Union[str, Any]="<mask>", __UpperCAmelCase : Any=False, __UpperCAmelCase : Optional[int]=True, **__UpperCAmelCase : Optional[Any], ) -> Tuple:
"""simple docstring"""
super().__init__(
__UpperCAmelCase, __UpperCAmelCase, tokenizer_file=__UpperCAmelCase, errors=__UpperCAmelCase, bos_token=__UpperCAmelCase, eos_token=__UpperCAmelCase, sep_token=__UpperCAmelCase, cls_token=__UpperCAmelCase, unk_token=__UpperCAmelCase, pad_token=__UpperCAmelCase, mask_token=__UpperCAmelCase, add_prefix_space=__UpperCAmelCase, trim_offsets=__UpperCAmelCase, **__UpperCAmelCase, )
SCREAMING_SNAKE_CASE : Optional[Any] = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() )
if pre_tok_state.get('''add_prefix_space''', __UpperCAmelCase ) != add_prefix_space:
SCREAMING_SNAKE_CASE : str = getattr(__UpperCAmelCase, pre_tok_state.pop('''type''' ) )
SCREAMING_SNAKE_CASE : Dict = add_prefix_space
SCREAMING_SNAKE_CASE : Optional[int] = pre_tok_class(**__UpperCAmelCase )
SCREAMING_SNAKE_CASE : Any = add_prefix_space
SCREAMING_SNAKE_CASE : Optional[int] = '''post_processor'''
SCREAMING_SNAKE_CASE : Any = getattr(self.backend_tokenizer, __UpperCAmelCase, __UpperCAmelCase )
if tokenizer_component_instance:
SCREAMING_SNAKE_CASE : Union[str, Any] = json.loads(tokenizer_component_instance.__getstate__() )
# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
if "sep" in state:
SCREAMING_SNAKE_CASE : Optional[Any] = tuple(state['''sep'''] )
if "cls" in state:
SCREAMING_SNAKE_CASE : Tuple = tuple(state['''cls'''] )
SCREAMING_SNAKE_CASE : str = False
if state.get('''add_prefix_space''', __UpperCAmelCase ) != add_prefix_space:
SCREAMING_SNAKE_CASE : int = add_prefix_space
SCREAMING_SNAKE_CASE : List[str] = True
if state.get('''trim_offsets''', __UpperCAmelCase ) != trim_offsets:
SCREAMING_SNAKE_CASE : Any = trim_offsets
SCREAMING_SNAKE_CASE : Dict = True
if changes_to_apply:
SCREAMING_SNAKE_CASE : Tuple = getattr(__UpperCAmelCase, state.pop('''type''' ) )
SCREAMING_SNAKE_CASE : List[Any] = component_class(**__UpperCAmelCase )
setattr(self.backend_tokenizer, __UpperCAmelCase, __UpperCAmelCase )
@property
def lowercase__ (self : int ) -> str:
"""simple docstring"""
if self._mask_token is None:
if self.verbose:
logger.error('''Using mask_token, but it is not set yet.''' )
return None
return str(self._mask_token )
@mask_token.setter
def lowercase__ (self : int, __UpperCAmelCase : List[str] ) -> Tuple:
"""simple docstring"""
SCREAMING_SNAKE_CASE : str = AddedToken(__UpperCAmelCase, lstrip=__UpperCAmelCase, rstrip=__UpperCAmelCase ) if isinstance(__UpperCAmelCase, __UpperCAmelCase ) else value
SCREAMING_SNAKE_CASE : List[str] = value
def lowercase__ (self : Optional[int], *__UpperCAmelCase : List[Any], **__UpperCAmelCase : Optional[Any] ) -> BatchEncoding:
"""simple docstring"""
SCREAMING_SNAKE_CASE : Any = kwargs.get('''is_split_into_words''', __UpperCAmelCase )
assert self.add_prefix_space or not is_split_into_words, (
F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
"to use it with pretokenized inputs."
)
return super()._batch_encode_plus(*__UpperCAmelCase, **__UpperCAmelCase )
def lowercase__ (self : int, *__UpperCAmelCase : List[str], **__UpperCAmelCase : Tuple ) -> BatchEncoding:
"""simple docstring"""
SCREAMING_SNAKE_CASE : str = kwargs.get('''is_split_into_words''', __UpperCAmelCase )
assert self.add_prefix_space or not is_split_into_words, (
F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
"to use it with pretokenized inputs."
)
return super()._encode_plus(*__UpperCAmelCase, **__UpperCAmelCase )
def lowercase__ (self : Optional[Any], __UpperCAmelCase : str, __UpperCAmelCase : Optional[str] = None ) -> Tuple[str]:
"""simple docstring"""
SCREAMING_SNAKE_CASE : Any = self._tokenizer.model.save(__UpperCAmelCase, name=__UpperCAmelCase )
return tuple(__UpperCAmelCase )
def lowercase__ (self : Optional[int], __UpperCAmelCase : Dict, __UpperCAmelCase : List[str]=None ) -> Optional[Any]:
"""simple docstring"""
SCREAMING_SNAKE_CASE : List[Any] = [self.bos_token_id] + token_ids_a + [self.eos_token_id]
if token_ids_a is None:
return output
return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]
def lowercase__ (self : Union[str, Any], __UpperCAmelCase : List[int], __UpperCAmelCase : Optional[List[int]] = None ) -> List[int]:
"""simple docstring"""
SCREAMING_SNAKE_CASE : Union[str, Any] = [self.sep_token_id]
SCREAMING_SNAKE_CASE : int = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
| 507
| 1
|
import torch
from diffusers import EulerDiscreteScheduler
from diffusers.utils import torch_device
from .test_schedulers import SchedulerCommonTest
class a ( _UpperCamelCase ):
'''simple docstring'''
__lowerCAmelCase : Optional[int] = (EulerDiscreteScheduler,)
__lowerCAmelCase : Any = 10
def __UpperCamelCase ( self , **lowerCamelCase_ ) -> str:
_a : Dict = {
"num_train_timesteps": 1_1_0_0,
"beta_start": 0.0001,
"beta_end": 0.02,
"beta_schedule": "linear",
}
config.update(**__a )
return config
def __UpperCamelCase ( self ) -> List[Any]:
for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]:
self.check_over_configs(num_train_timesteps=__a )
def __UpperCamelCase ( self ) -> int:
for beta_start, beta_end in zip([0.00001, 0.0001, 0.001] , [0.0002, 0.002, 0.02] ):
self.check_over_configs(beta_start=__a , beta_end=__a )
def __UpperCamelCase ( self ) -> int:
for schedule in ["linear", "scaled_linear"]:
self.check_over_configs(beta_schedule=__a )
def __UpperCamelCase ( self ) -> Optional[Any]:
for prediction_type in ["epsilon", "v_prediction"]:
self.check_over_configs(prediction_type=__a )
def __UpperCamelCase ( self ) -> Any:
_a : List[Any] = self.scheduler_classes[0]
_a : Any = self.get_scheduler_config()
_a : Dict = scheduler_class(**__a )
scheduler.set_timesteps(self.num_inference_steps )
_a : List[str] = torch.manual_seed(0 )
_a : Optional[Any] = self.dummy_model()
_a : Optional[int] = self.dummy_sample_deter * scheduler.init_noise_sigma
_a : str = sample.to(__a )
for i, t in enumerate(scheduler.timesteps ):
_a : List[str] = scheduler.scale_model_input(__a , __a )
_a : int = model(__a , __a )
_a : Dict = scheduler.step(__a , __a , __a , generator=__a )
_a : Optional[int] = output.prev_sample
_a : Union[str, Any] = torch.sum(torch.abs(__a ) )
_a : Any = torch.mean(torch.abs(__a ) )
assert abs(result_sum.item() - 10.0807 ) < 1e-2
assert abs(result_mean.item() - 0.0131 ) < 1e-3
def __UpperCamelCase ( self ) -> Any:
_a : Dict = self.scheduler_classes[0]
_a : Optional[int] = self.get_scheduler_config(prediction_type='v_prediction' )
_a : List[str] = scheduler_class(**__a )
scheduler.set_timesteps(self.num_inference_steps )
_a : Optional[int] = torch.manual_seed(0 )
_a : List[Any] = self.dummy_model()
_a : Optional[Any] = self.dummy_sample_deter * scheduler.init_noise_sigma
_a : Tuple = sample.to(__a )
for i, t in enumerate(scheduler.timesteps ):
_a : Tuple = scheduler.scale_model_input(__a , __a )
_a : Dict = model(__a , __a )
_a : int = scheduler.step(__a , __a , __a , generator=__a )
_a : Any = output.prev_sample
_a : Optional[Any] = torch.sum(torch.abs(__a ) )
_a : str = torch.mean(torch.abs(__a ) )
assert abs(result_sum.item() - 0.0002 ) < 1e-2
assert abs(result_mean.item() - 2.2676e-06 ) < 1e-3
def __UpperCamelCase ( self ) -> Tuple:
_a : Optional[Any] = self.scheduler_classes[0]
_a : Optional[Any] = self.get_scheduler_config()
_a : Optional[int] = scheduler_class(**__a )
scheduler.set_timesteps(self.num_inference_steps , device=__a )
_a : Optional[Any] = torch.manual_seed(0 )
_a : str = self.dummy_model()
_a : Optional[int] = self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
_a : str = sample.to(__a )
for t in scheduler.timesteps:
_a : str = scheduler.scale_model_input(__a , __a )
_a : Tuple = model(__a , __a )
_a : Optional[int] = scheduler.step(__a , __a , __a , generator=__a )
_a : int = output.prev_sample
_a : List[Any] = torch.sum(torch.abs(__a ) )
_a : List[Any] = torch.mean(torch.abs(__a ) )
assert abs(result_sum.item() - 10.0807 ) < 1e-2
assert abs(result_mean.item() - 0.0131 ) < 1e-3
def __UpperCamelCase ( self ) -> str:
_a : int = self.scheduler_classes[0]
_a : str = self.get_scheduler_config()
_a : int = scheduler_class(**__a , use_karras_sigmas=__a )
scheduler.set_timesteps(self.num_inference_steps , device=__a )
_a : List[str] = torch.manual_seed(0 )
_a : Union[str, Any] = self.dummy_model()
_a : int = self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
_a : List[str] = sample.to(__a )
for t in scheduler.timesteps:
_a : Optional[int] = scheduler.scale_model_input(__a , __a )
_a : Tuple = model(__a , __a )
_a : Dict = scheduler.step(__a , __a , __a , generator=__a )
_a : Union[str, Any] = output.prev_sample
_a : List[str] = torch.sum(torch.abs(__a ) )
_a : Any = torch.mean(torch.abs(__a ) )
assert abs(result_sum.item() - 1_2_4.5_2_2_9_9_4_9_9_5_1_1_7_1_9 ) < 1e-2
assert abs(result_mean.item() - 0.16213932633399963 ) < 1e-3
| 707
|
'''simple docstring'''
def UpperCAmelCase_ ( A ):
'''simple docstring'''
if len(A ) <= 1:
return [tuple(A )]
_a : str = []
def generate(A , A ):
if k == 1:
res.append(tuple(arr[:] ) )
return
generate(k - 1 , A )
for i in range(k - 1 ):
if k % 2 == 0: # k is even
_a , _a : Optional[Any] = arr[k - 1], arr[i]
else: # k is odd
_a , _a : str = arr[k - 1], arr[0]
generate(k - 1 , A )
generate(len(A ) , A )
return res
if __name__ == "__main__":
UpperCAmelCase_ : Any = input("Enter numbers separated by a comma:\n").strip()
UpperCAmelCase_ : Tuple = [int(item) for item in user_input.split(",")]
print(heaps(arr))
| 424
| 0
|
from typing import Optional, Union
import torch
from torch import nn
from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin
class A_ ( UpperCAmelCase , UpperCAmelCase ):
"""simple docstring"""
@register_to_config
def __init__( self : List[str] ,__A : int = 768 ,) -> List[Any]:
super().__init__()
_lowercase = nn.Parameter(torch.zeros(1 ,__A ) )
_lowercase = nn.Parameter(torch.ones(1 ,__A ) )
def __UpperCAmelCase ( self : List[str] ,__A : Optional[Union[str, torch.device]] = None ,__A : Optional[torch.dtype] = None ,) -> Optional[int]:
_lowercase = nn.Parameter(self.mean.to(__A ).to(__A ) )
_lowercase = nn.Parameter(self.std.to(__A ).to(__A ) )
return self
def __UpperCAmelCase ( self : int ,__A : str ) -> List[Any]:
_lowercase = (embeds - self.mean) * 1.0 / self.std
return embeds
def __UpperCAmelCase ( self : str ,__A : str ) -> Tuple:
_lowercase = (embeds * self.std) + self.mean
return embeds
| 67
|
import inspect
import logging
import os
import random
import shutil
import tempfile
import unittest
import pytest
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_cuda
from accelerate.utils import ProjectConfiguration, set_seed
SCREAMING_SNAKE_CASE :Optional[int] = logging.getLogger(__name__)
def lowerCAmelCase( SCREAMING_SNAKE_CASE_=2 , SCREAMING_SNAKE_CASE_=3 , SCREAMING_SNAKE_CASE_=1_6 , SCREAMING_SNAKE_CASE_ = 1_0 , SCREAMING_SNAKE_CASE_ = 2 )-> Optional[Any]:
"""simple docstring"""
def get_dataset(SCREAMING_SNAKE_CASE_ ):
UpperCamelCase_ = torch.randn(batch_size * n_batches , 1 )
return TensorDataset(SCREAMING_SNAKE_CASE_ , a * x + b + 0.1 * torch.randn(batch_size * n_batches , 1 ) )
UpperCamelCase_ = get_dataset(SCREAMING_SNAKE_CASE_ )
UpperCamelCase_ = get_dataset(SCREAMING_SNAKE_CASE_ )
UpperCamelCase_ = DataLoader(SCREAMING_SNAKE_CASE_ , shuffle=SCREAMING_SNAKE_CASE_ , batch_size=SCREAMING_SNAKE_CASE_ , num_workers=4 )
UpperCamelCase_ = DataLoader(SCREAMING_SNAKE_CASE_ , shuffle=SCREAMING_SNAKE_CASE_ , batch_size=SCREAMING_SNAKE_CASE_ , num_workers=4 )
return (train_dataloader, valid_dataloader)
def lowerCAmelCase( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_=None )-> Any:
"""simple docstring"""
UpperCamelCase_ = []
for epoch in range(SCREAMING_SNAKE_CASE_ ):
# Train quickly
model.train()
for batch in dataloader:
UpperCamelCase_ , UpperCamelCase_ = batch
UpperCamelCase_ = model(SCREAMING_SNAKE_CASE_ )
UpperCamelCase_ = torch.nn.functional.mse_loss(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
accelerator.backward(SCREAMING_SNAKE_CASE_ )
optimizer.step()
optimizer.zero_grad()
rands.append(random.random() ) # Introduce some randomness
if scheduler is not None:
scheduler.step()
return rands
class __magic_name__ ( nn.Module ):
def __init__( self )-> List[Any]:
super().__init__()
UpperCamelCase_ = nn.Parameter(torch.randn(1 ) )
UpperCamelCase_ = nn.Parameter(torch.randn(1 ) )
def UpperCAmelCase_ ( self , _lowercase )-> str:
return x * self.a + self.b
class __magic_name__ ( unittest.TestCase ):
def UpperCAmelCase_ ( self )-> List[Any]:
with tempfile.TemporaryDirectory() as tmpdir:
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
UpperCamelCase_ = ProjectConfiguration(total_limit=1 , project_dir=_lowercase , automatic_checkpoint_naming=_lowercase )
# Train baseline
UpperCamelCase_ = Accelerator(project_config=_lowercase )
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase )
# Save initial
accelerator.save_state()
# Save second state
accelerator.save_state()
self.assertEqual(len(os.listdir(accelerator.project_dir ) ) , 1 )
def UpperCAmelCase_ ( self )-> Optional[Any]:
with tempfile.TemporaryDirectory() as tmpdir:
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
# Train baseline
UpperCamelCase_ = Accelerator()
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase )
# Save initial
UpperCamelCase_ = os.path.join(_lowercase , "initial" )
accelerator.save_state(_lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
UpperCamelCase_ = train(3 , _lowercase , _lowercase , _lowercase , _lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
# Train partially
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
UpperCamelCase_ = Accelerator()
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase )
accelerator.load_state(_lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
UpperCamelCase_ = train(2 , _lowercase , _lowercase , _lowercase , _lowercase )
# Save everything
UpperCamelCase_ = os.path.join(_lowercase , "checkpoint" )
accelerator.save_state(_lowercase )
# Load everything back in and make sure all states work
accelerator.load_state(_lowercase )
test_rands += train(1 , _lowercase , _lowercase , _lowercase , _lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
def UpperCAmelCase_ ( self )-> Union[str, Any]:
with tempfile.TemporaryDirectory() as tmpdir:
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
UpperCamelCase_ = ProjectConfiguration(automatic_checkpoint_naming=_lowercase )
# Train baseline
UpperCamelCase_ = Accelerator(project_dir=_lowercase , project_config=_lowercase )
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase )
# Save initial
accelerator.save_state()
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
UpperCamelCase_ = train(3 , _lowercase , _lowercase , _lowercase , _lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
# Train partially
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
UpperCamelCase_ = ProjectConfiguration(iteration=1 , automatic_checkpoint_naming=_lowercase )
UpperCamelCase_ = Accelerator(project_dir=_lowercase , project_config=_lowercase )
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase )
accelerator.load_state(os.path.join(_lowercase , "checkpoints" , "checkpoint_0" ) )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
UpperCamelCase_ = train(2 , _lowercase , _lowercase , _lowercase , _lowercase )
# Save everything
accelerator.save_state()
# Load everything back in and make sure all states work
accelerator.load_state(os.path.join(_lowercase , "checkpoints" , "checkpoint_1" ) )
test_rands += train(1 , _lowercase , _lowercase , _lowercase , _lowercase )
((UpperCamelCase_) , (UpperCamelCase_)) = model.a.item(), model.b.item()
UpperCamelCase_ = optimizer.state_dict()
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
self.assertEqual(_lowercase , _lowercase )
def UpperCAmelCase_ ( self )-> Any:
UpperCamelCase_ = torch.tensor([1, 2, 3] )
UpperCamelCase_ = torch.tensor([2, 3, 4] )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(net.parameters() )
UpperCamelCase_ = Accelerator()
with self.assertRaises(_lowercase ) as ve:
accelerator.register_for_checkpointing(_lowercase , _lowercase , _lowercase , _lowercase )
UpperCamelCase_ = str(ve.exception )
self.assertTrue("Item at index 0" in message )
self.assertTrue("Item at index 1" in message )
self.assertFalse("Item at index 2" in message )
self.assertFalse("Item at index 3" in message )
def UpperCAmelCase_ ( self )-> Optional[Any]:
with tempfile.TemporaryDirectory() as tmpdir:
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = torch.optim.Adam(params=model.parameters() , lr=1e-3 )
UpperCamelCase_ = torch.optim.lr_scheduler.StepLR(_lowercase , step_size=1 , gamma=0.99 )
UpperCamelCase_ , UpperCamelCase_ = dummy_dataloaders()
UpperCamelCase_ = ProjectConfiguration(automatic_checkpoint_naming=_lowercase )
# Train baseline
UpperCamelCase_ = Accelerator(project_dir=_lowercase , project_config=_lowercase )
UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare(
_lowercase , _lowercase , _lowercase , _lowercase , _lowercase )
# Save initial
accelerator.save_state()
UpperCamelCase_ = scheduler.state_dict()
train(3 , _lowercase , _lowercase , _lowercase , _lowercase , _lowercase )
self.assertNotEqual(_lowercase , scheduler.state_dict() )
# Load everything back in and make sure all states work
accelerator.load_state(os.path.join(_lowercase , "checkpoints" , "checkpoint_0" ) )
self.assertEqual(_lowercase , scheduler.state_dict() )
def UpperCAmelCase_ ( self )-> str:
with tempfile.TemporaryDirectory() as tmpdir:
set_seed(42 )
UpperCamelCase_ = DummyModel()
UpperCamelCase_ = ProjectConfiguration(automatic_checkpoint_naming=_lowercase , total_limit=2 )
# Train baseline
UpperCamelCase_ = Accelerator(project_dir=_lowercase , project_config=_lowercase )
UpperCamelCase_ = accelerator.prepare(_lowercase )
# Save 3 states:
for _ in range(11 ):
accelerator.save_state()
self.assertTrue(not os.path.exists(os.path.join(_lowercase , "checkpoints" , "checkpoint_0" ) ) )
self.assertTrue(os.path.exists(os.path.join(_lowercase , "checkpoints" , "checkpoint_9" ) ) )
self.assertTrue(os.path.exists(os.path.join(_lowercase , "checkpoints" , "checkpoint_10" ) ) )
@require_cuda
def UpperCAmelCase_ ( self )-> int:
UpperCamelCase_ = ["torchrun", F"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )]
execute_subprocess_async(_lowercase , env=os.environ.copy() )
if __name__ == "__main__":
SCREAMING_SNAKE_CASE :Any = """/tmp/accelerate/state_checkpointing"""
SCREAMING_SNAKE_CASE :Any = DummyModel()
SCREAMING_SNAKE_CASE :Union[str, Any] = torch.optim.Adam(params=model.parameters(), lr=1e-3)
SCREAMING_SNAKE_CASE :Dict = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9)
SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE :str = dummy_dataloaders()
SCREAMING_SNAKE_CASE :Tuple = ProjectConfiguration(automatic_checkpoint_naming=True)
# Train baseline
SCREAMING_SNAKE_CASE :int = Accelerator(project_dir=savedir, project_config=project_config, mixed_precision="""no""")
if accelerator.process_index == 0:
if os.path.exists(savedir):
shutil.rmtree(savedir)
os.makedirs(savedir)
SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE :Tuple = accelerator.prepare(
model, optimizer, train_dataloader, valid_dataloader, scheduler
)
SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE :List[str] = accelerator.prepare(model, optimizer)
train(3, model, train_dataloader, optimizer, accelerator, scheduler)
# Check that the intial optimizer is loaded on the GPU
for group in optimizer.param_groups:
SCREAMING_SNAKE_CASE :Optional[Any] = group["""params"""][0].device
break
assert param_device.type == accelerator.device.type
SCREAMING_SNAKE_CASE :List[str] = model.cpu()
accelerator.wait_for_everyone()
accelerator.save_state()
accelerator.wait_for_everyone()
# Check CPU state
accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""cpu""")
for group in optimizer.param_groups:
SCREAMING_SNAKE_CASE :Optional[int] = group["""params"""][0].device
break
assert (
param_device.type == torch.device("""cpu""").type
), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}"
# Check device state
model.to(accelerator.device)
accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""on_device""")
for group in optimizer.param_groups:
SCREAMING_SNAKE_CASE :str = group["""params"""][0].device
break
assert (
param_device.type == accelerator.device.type
), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}"
# Check error
with pytest.raises(TypeError, match="""Unsupported optimizer map location passed"""):
accelerator.load_state(os.path.join(savedir, """checkpoints""", """checkpoint_0"""), map_location="""invalid""")
accelerator.wait_for_everyone()
if accelerator.process_index == 0:
shutil.rmtree(savedir)
accelerator.wait_for_everyone()
| 628
| 0
|
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.models import Sequential
if __name__ == "__main__":
SCREAMING_SNAKE_CASE__ = pd.read_csv("""sample_data.csv""", header=None)
SCREAMING_SNAKE_CASE__ = df.shape[:1][0]
# If you're using some other dataset input the target column
SCREAMING_SNAKE_CASE__ = df.iloc[:, 1:2]
SCREAMING_SNAKE_CASE__ = actual_data.values.reshape(len_data, 1)
SCREAMING_SNAKE_CASE__ = MinMaxScaler().fit_transform(actual_data)
SCREAMING_SNAKE_CASE__ = 10
SCREAMING_SNAKE_CASE__ = 5
SCREAMING_SNAKE_CASE__ = 20
SCREAMING_SNAKE_CASE__ = len_data - periods * look_back
SCREAMING_SNAKE_CASE__ = actual_data[:division]
SCREAMING_SNAKE_CASE__ = actual_data[division - look_back :]
SCREAMING_SNAKE_CASE__ = [], []
SCREAMING_SNAKE_CASE__ = [], []
for i in range(0, len(train_data) - forward_days - look_back + 1):
train_x.append(train_data[i : i + look_back])
train_y.append(train_data[i + look_back : i + look_back + forward_days])
for i in range(0, len(test_data) - forward_days - look_back + 1):
test_x.append(test_data[i : i + look_back])
test_y.append(test_data[i + look_back : i + look_back + forward_days])
SCREAMING_SNAKE_CASE__ = np.array(train_x)
SCREAMING_SNAKE_CASE__ = np.array(test_x)
SCREAMING_SNAKE_CASE__ = np.array([list(i.ravel()) for i in train_y])
SCREAMING_SNAKE_CASE__ = np.array([list(i.ravel()) for i in test_y])
SCREAMING_SNAKE_CASE__ = Sequential()
model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True))
model.add(LSTM(64, input_shape=(128, 1)))
model.add(Dense(forward_days))
model.compile(loss="""mean_squared_error""", optimizer="""adam""")
SCREAMING_SNAKE_CASE__ = model.fit(
x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4
)
SCREAMING_SNAKE_CASE__ = model.predict(x_test)
| 710
|
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 A__ ( lowerCAmelCase__ , unittest.TestCase ):
lowerCAmelCase__ : List[str] = ProphetNetTokenizer
lowerCAmelCase__ : str = False
def a__ ( self : str ) -> Tuple:
"""simple docstring"""
super().setUp()
__lowercase = [
'[UNK]',
'[CLS]',
'[SEP]',
'[PAD]',
'[MASK]',
'want',
'##want',
'##ed',
'wa',
'un',
'runn',
'##ing',
',',
'low',
'lowest',
]
__lowercase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] )
with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer:
vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) )
def a__ ( self : str , _UpperCAmelCase : Any ) -> List[str]:
"""simple docstring"""
__lowercase = 'UNwant\u00E9d,running'
__lowercase = 'unwanted, running'
return input_text, output_text
def a__ ( self : Any ) -> Any:
"""simple docstring"""
__lowercase = self.tokenizer_class(self.vocab_file )
__lowercase = tokenizer.tokenize('UNwant\u00E9d,running' )
self.assertListEqual(_UpperCAmelCase , ['un', '##want', '##ed', ',', 'runn', '##ing'] )
self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) , [9, 6, 7, 12, 10, 11] )
def a__ ( self : Optional[Any] ) -> List[Any]:
"""simple docstring"""
__lowercase = BasicTokenizer()
self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz' ) , ['ah', '\u535A', '\u63A8', 'zz'] )
def a__ ( self : int ) -> List[str]:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['hello', '!', 'how', 'are', 'you', '?'] )
self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] )
def a__ ( self : Dict ) -> str:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase , strip_accents=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hällo', '!', 'how', 'are', 'you', '?'] )
self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['h\u00E9llo'] )
def a__ ( self : Optional[Any] ) -> Tuple:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase , strip_accents=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] )
self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] )
def a__ ( self : Dict ) -> Tuple:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['hallo', '!', 'how', 'are', 'you', '?'] )
self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['hello'] )
def a__ ( self : str ) -> str:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHeLLo!how \n Are yoU? ' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?'] )
def a__ ( self : Optional[Any] ) -> Dict:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase , strip_accents=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HäLLo', '!', 'how', 'Are', 'yoU', '?'] )
def a__ ( self : List[Any] ) -> int:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase , strip_accents=_UpperCAmelCase )
self.assertListEqual(
tokenizer.tokenize(' \tHäLLo!how \n Are yoU? ' ) , ['HaLLo', '!', 'how', 'Are', 'yoU', '?'] )
def a__ ( self : str ) -> Dict:
"""simple docstring"""
__lowercase = BasicTokenizer(do_lower_case=_UpperCAmelCase , never_split=['[UNK]'] )
self.assertListEqual(
tokenizer.tokenize(' \tHeLLo!how \n Are yoU? [UNK]' ) , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'] )
def a__ ( self : Any ) -> int:
"""simple docstring"""
__lowercase = ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']
__lowercase = {}
for i, token in enumerate(_UpperCAmelCase ):
__lowercase = i
__lowercase = WordpieceTokenizer(vocab=_UpperCAmelCase , unk_token='[UNK]' )
self.assertListEqual(tokenizer.tokenize('' ) , [] )
self.assertListEqual(tokenizer.tokenize('unwanted running' ) , ['un', '##want', '##ed', 'runn', '##ing'] )
self.assertListEqual(tokenizer.tokenize('unwantedX running' ) , ['[UNK]', 'runn', '##ing'] )
@require_torch
def a__ ( self : Dict ) -> Optional[Any]:
"""simple docstring"""
__lowercase = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' )
__lowercase = ['A long paragraph for summarization.', 'Another paragraph for summarization.']
__lowercase = [10_37, 21_46, 2_04_23, 20_05, 76_80, 78_49, 39_89, 10_12, 1_02]
__lowercase = tokenizer(_UpperCAmelCase , padding=_UpperCAmelCase , return_tensors='pt' )
self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase )
__lowercase = list(batch.input_ids.numpy()[0] )
self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase )
self.assertEqual((2, 9) , batch.input_ids.shape )
self.assertEqual((2, 9) , batch.attention_mask.shape )
def a__ ( self : int ) -> Dict:
"""simple docstring"""
self.assertTrue(_is_whitespace(' ' ) )
self.assertTrue(_is_whitespace('\t' ) )
self.assertTrue(_is_whitespace('\r' ) )
self.assertTrue(_is_whitespace('\n' ) )
self.assertTrue(_is_whitespace('\u00A0' ) )
self.assertFalse(_is_whitespace('A' ) )
self.assertFalse(_is_whitespace('-' ) )
def a__ ( self : Any ) -> List[str]:
"""simple docstring"""
self.assertTrue(_is_control('\u0005' ) )
self.assertFalse(_is_control('A' ) )
self.assertFalse(_is_control(' ' ) )
self.assertFalse(_is_control('\t' ) )
self.assertFalse(_is_control('\r' ) )
def a__ ( self : List[str] ) -> str:
"""simple docstring"""
self.assertTrue(_is_punctuation('-' ) )
self.assertTrue(_is_punctuation('$' ) )
self.assertTrue(_is_punctuation('`' ) )
self.assertTrue(_is_punctuation('.' ) )
self.assertFalse(_is_punctuation('A' ) )
self.assertFalse(_is_punctuation(' ' ) )
@slow
def a__ ( self : List[Any] ) -> List[str]:
"""simple docstring"""
__lowercase = self.tokenizer_class.from_pretrained('microsoft/prophetnet-large-uncased' )
__lowercase = tokenizer.encode('sequence builders' , add_special_tokens=_UpperCAmelCase )
__lowercase = tokenizer.encode('multi-sequence build' , add_special_tokens=_UpperCAmelCase )
__lowercase = tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase )
__lowercase = tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase , _UpperCAmelCase )
assert encoded_sentence == text + [1_02]
assert encoded_pair == text + [1_02] + text_a + [1_02]
| 688
| 0
|
'''simple docstring'''
from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar
__lowerCAmelCase : Optional[Any] =TypeVar("KEY")
__lowerCAmelCase : Dict =TypeVar("VAL")
@dataclass(frozen=UpperCamelCase__ , slots=UpperCamelCase__ )
class UpperCAmelCase ( Generic[KEY, VAL] ):
__lowercase = 42
__lowercase = 42
class UpperCAmelCase ( _Item ):
def __init__( self :int )-> None:
super().__init__(lowercase_ , lowercase_ )
def __bool__( self :Optional[Any] )-> bool:
return False
__lowerCAmelCase : int =_DeletedItem()
class UpperCAmelCase ( MutableMapping[KEY, VAL] ):
def __init__( self :str , lowercase_ :int = 8 , lowercase_ :float = 0.7_5 )-> None:
A__ = initial_block_size
A__ = [None] * initial_block_size
assert 0.0 < capacity_factor < 1.0
A__ = capacity_factor
A__ = 0
def UpperCAmelCase_ ( self :str , lowercase_ :KEY )-> int:
return hash(lowercase_ ) % len(self._buckets )
def UpperCAmelCase_ ( self :int , lowercase_ :int )-> int:
return (ind + 1) % len(self._buckets )
def UpperCAmelCase_ ( self :Any , lowercase_ :int , lowercase_ :KEY , lowercase_ :VAL )-> bool:
A__ = self._buckets[ind]
if not stored:
A__ = _Item(lowercase_ , lowercase_ )
self._len += 1
return True
elif stored.key == key:
A__ = _Item(lowercase_ , lowercase_ )
return True
else:
return False
def UpperCAmelCase_ ( self :List[str] )-> bool:
A__ = len(self._buckets ) * self._capacity_factor
return len(self ) >= int(lowercase_ )
def UpperCAmelCase_ ( self :List[str] )-> bool:
if len(self._buckets ) <= self._initial_block_size:
return False
A__ = len(self._buckets ) * self._capacity_factor / 2
return len(self ) < limit
def UpperCAmelCase_ ( self :str , lowercase_ :int )-> None:
A__ = self._buckets
A__ = [None] * new_size
A__ = 0
for item in old_buckets:
if item:
self._add_item(item.key , item.val )
def UpperCAmelCase_ ( self :Optional[Any] )-> None:
self._resize(len(self._buckets ) * 2 )
def UpperCAmelCase_ ( self :List[str] )-> None:
self._resize(len(self._buckets ) // 2 )
def UpperCAmelCase_ ( self :List[str] , lowercase_ :KEY )-> Iterator[int]:
A__ = self._get_bucket_index(lowercase_ )
for _ in range(len(self._buckets ) ):
yield ind
A__ = self._get_next_ind(lowercase_ )
def UpperCAmelCase_ ( self :str , lowercase_ :KEY , lowercase_ :VAL )-> None:
for ind in self._iterate_buckets(lowercase_ ):
if self._try_set(lowercase_ , lowercase_ , lowercase_ ):
break
def __setitem__( self :Tuple , lowercase_ :KEY , lowercase_ :VAL )-> None:
if self._is_full():
self._size_up()
self._add_item(lowercase_ , lowercase_ )
def __delitem__( self :Union[str, Any] , lowercase_ :KEY )-> None:
for ind in self._iterate_buckets(lowercase_ ):
A__ = self._buckets[ind]
if item is None:
raise KeyError(lowercase_ )
if item is _deleted:
continue
if item.key == key:
A__ = _deleted
self._len -= 1
break
if self._is_sparse():
self._size_down()
def __getitem__( self :Optional[int] , lowercase_ :KEY )-> VAL:
for ind in self._iterate_buckets(lowercase_ ):
A__ = self._buckets[ind]
if item is None:
break
if item is _deleted:
continue
if item.key == key:
return item.val
raise KeyError(lowercase_ )
def __len__( self :Tuple )-> int:
return self._len
def __iter__( self :Tuple )-> Iterator[KEY]:
yield from (item.key for item in self._buckets if item)
def __repr__( self :List[Any] )-> str:
A__ = " ,".join(
F"{item.key}: {item.val}" for item in self._buckets if item )
return F"HashMap({val_string})"
| 440
|
'''simple docstring'''
import warnings
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class UpperCAmelCase ( UpperCamelCase__ ):
__lowercase = ["""image_processor""", """tokenizer"""]
__lowercase = """CLIPImageProcessor"""
__lowercase = ("""CLIPTokenizer""", """CLIPTokenizerFast""")
def __init__( self :List[Any] , lowercase_ :List[str]=None , lowercase_ :Any=None , **lowercase_ :Union[str, Any] )-> Optional[Any]:
A__ = None
if "feature_extractor" in kwargs:
warnings.warn(
"The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
" instead." , lowercase_ , )
A__ = kwargs.pop("feature_extractor" )
A__ = image_processor if image_processor is not None else feature_extractor
if image_processor is None:
raise ValueError("You need to specify an `image_processor`." )
if tokenizer is None:
raise ValueError("You need to specify a `tokenizer`." )
super().__init__(lowercase_ , lowercase_ )
def __call__( self :Optional[Any] , lowercase_ :Optional[int]=None , lowercase_ :Dict=None , lowercase_ :List[Any]=None , **lowercase_ :Optional[Any] )-> Union[str, Any]:
if text is None and images is None:
raise ValueError("You have to specify either text or images. Both cannot be none." )
if text is not None:
A__ = self.tokenizer(lowercase_ , return_tensors=lowercase_ , **lowercase_ )
if images is not None:
A__ = self.image_processor(lowercase_ , return_tensors=lowercase_ , **lowercase_ )
if text is not None and images is not None:
A__ = image_features.pixel_values
return encoding
elif text is not None:
return encoding
else:
return BatchEncoding(data=dict(**lowercase_ ) , tensor_type=lowercase_ )
def UpperCAmelCase_ ( self :int , *lowercase_ :Tuple , **lowercase_ :Any )-> Dict:
return self.tokenizer.batch_decode(*lowercase_ , **lowercase_ )
def UpperCAmelCase_ ( self :Any , *lowercase_ :Any , **lowercase_ :Any )-> List[str]:
return self.tokenizer.decode(*lowercase_ , **lowercase_ )
@property
def UpperCAmelCase_ ( self :Union[str, Any] )-> Optional[int]:
A__ = self.tokenizer.model_input_names
A__ = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
@property
def UpperCAmelCase_ ( self :List[Any] )-> str:
warnings.warn(
"`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead." , lowercase_ , )
return self.image_processor_class
@property
def UpperCAmelCase_ ( self :List[str] )-> List[Any]:
warnings.warn(
"`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead." , lowercase_ , )
return self.image_processor
| 440
| 1
|
'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
_lowerCamelCase = logging.get_logger(__name__)
_lowerCamelCase = {
"""facebook/convnextv2-tiny-1k-224""": """https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json""",
}
class _snake_case (__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE):
__A : Optional[Any] ="convnextv2"
def __init__( self ,_snake_case=3 ,_snake_case=4 ,_snake_case=4 ,_snake_case=None ,_snake_case=None ,_snake_case="gelu" ,_snake_case=0.02 ,_snake_case=1E-12 ,_snake_case=0.0 ,_snake_case=2_24 ,_snake_case=None ,_snake_case=None ,**_snake_case ,):
super().__init__(**_snake_case )
UpperCAmelCase_ : Any = num_channels
UpperCAmelCase_ : Optional[int] = patch_size
UpperCAmelCase_ : int = num_stages
UpperCAmelCase_ : Union[str, Any] = [96, 1_92, 3_84, 7_68] if hidden_sizes is None else hidden_sizes
UpperCAmelCase_ : List[str] = [3, 3, 9, 3] if depths is None else depths
UpperCAmelCase_ : Optional[int] = hidden_act
UpperCAmelCase_ : Optional[int] = initializer_range
UpperCAmelCase_ : str = layer_norm_eps
UpperCAmelCase_ : Tuple = drop_path_rate
UpperCAmelCase_ : int = image_size
UpperCAmelCase_ : List[str] = ["stem"] + [f'''stage{idx}''' for idx in range(1 ,len(self.depths ) + 1 )]
UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = get_aligned_output_features_output_indices(
out_features=_snake_case ,out_indices=_snake_case ,stage_names=self.stage_names )
| 323
|
'''simple docstring'''
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_tf_available,
is_torch_available,
is_vision_available,
)
_lowerCamelCase = {"""configuration_deit""": ["""DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DeiTConfig""", """DeiTOnnxConfig"""]}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase = ["""DeiTFeatureExtractor"""]
_lowerCamelCase = ["""DeiTImageProcessor"""]
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase = [
"""DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""DeiTForImageClassification""",
"""DeiTForImageClassificationWithTeacher""",
"""DeiTForMaskedImageModeling""",
"""DeiTModel""",
"""DeiTPreTrainedModel""",
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase = [
"""TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""TFDeiTForImageClassification""",
"""TFDeiTForImageClassificationWithTeacher""",
"""TFDeiTForMaskedImageModeling""",
"""TFDeiTModel""",
"""TFDeiTPreTrainedModel""",
]
if TYPE_CHECKING:
from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_deit import DeiTFeatureExtractor
from .image_processing_deit import DeiTImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_deit import (
DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
DeiTForImageClassification,
DeiTForImageClassificationWithTeacher,
DeiTForMaskedImageModeling,
DeiTModel,
DeiTPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_deit import (
TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFDeiTForImageClassification,
TFDeiTForImageClassificationWithTeacher,
TFDeiTForMaskedImageModeling,
TFDeiTModel,
TFDeiTPreTrainedModel,
)
else:
import sys
_lowerCamelCase = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 323
| 1
|
'''simple docstring'''
from torch import nn
def a__ ( a__ ):
"""simple docstring"""
if act_fn in ["swish", "silu"]:
return nn.SiLU()
elif act_fn == "mish":
return nn.Mish()
elif act_fn == "gelu":
return nn.GELU()
else:
raise ValueError(F'Unsupported activation function: {act_fn}' )
| 627
|
'''simple docstring'''
import importlib
import os
import fsspec
import pytest
from fsspec import register_implementation
from fsspec.registry import _registry as _fsspec_registry
from datasets.filesystems import COMPRESSION_FILESYSTEMS, HfFileSystem, extract_path_from_uri, is_remote_filesystem
from .utils import require_lza, require_zstandard
def __lowerCamelCase ( _UpperCamelCase : Optional[int] ):
'''simple docstring'''
assert "mock" in _fsspec_registry
assert "bz2" in _fsspec_registry
def __lowerCamelCase ( ):
'''simple docstring'''
assert "mock" not in _fsspec_registry
assert "bz2" in _fsspec_registry
def __lowerCamelCase ( ):
'''simple docstring'''
UpperCAmelCase_ = '''mock-s3-bucket'''
UpperCAmelCase_ = F"""s3://{mock_bucket}"""
UpperCAmelCase_ = extract_path_from_uri(_UpperCamelCase )
assert dataset_path.startswith('''s3://''' ) is False
UpperCAmelCase_ = '''./local/path'''
UpperCAmelCase_ = extract_path_from_uri(_UpperCamelCase )
assert dataset_path == new_dataset_path
def __lowerCamelCase ( _UpperCamelCase : Tuple ):
'''simple docstring'''
UpperCAmelCase_ = is_remote_filesystem(_UpperCamelCase )
assert is_remote is True
UpperCAmelCase_ = fsspec.filesystem('''file''' )
UpperCAmelCase_ = is_remote_filesystem(_UpperCamelCase )
assert is_remote is False
@pytest.mark.parametrize('''compression_fs_class''' , _UpperCamelCase )
def __lowerCamelCase ( _UpperCamelCase : List[Any] , _UpperCamelCase : str , _UpperCamelCase : Any , _UpperCamelCase : Any , _UpperCamelCase : Optional[Any] , _UpperCamelCase : str , _UpperCamelCase : List[Any] ):
'''simple docstring'''
UpperCAmelCase_ = {'''gzip''': gz_file, '''xz''': xz_file, '''zstd''': zstd_file, '''bz2''': bza_file, '''lz4''': lza_file}
UpperCAmelCase_ = input_paths[compression_fs_class.protocol]
if input_path is None:
UpperCAmelCase_ = F"""for '{compression_fs_class.protocol}' compression protocol, """
if compression_fs_class.protocol == "lz4":
reason += require_lza.kwargs["reason"]
elif compression_fs_class.protocol == "zstd":
reason += require_zstandard.kwargs["reason"]
pytest.skip(_UpperCamelCase )
UpperCAmelCase_ = fsspec.filesystem(compression_fs_class.protocol , fo=_UpperCamelCase )
assert isinstance(_UpperCamelCase , _UpperCamelCase )
UpperCAmelCase_ = os.path.basename(_UpperCamelCase )
UpperCAmelCase_ = expected_filename[: expected_filename.rindex('''.''' )]
assert fs.glob('''*''' ) == [expected_filename]
with fs.open(_UpperCamelCase , '''r''' , encoding='''utf-8''' ) as f, open(_UpperCamelCase , encoding='''utf-8''' ) as expected_file:
assert f.read() == expected_file.read()
@pytest.mark.parametrize('''protocol''' , ['''zip''', '''gzip'''] )
def __lowerCamelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : List[Any] , _UpperCamelCase : List[Any] ):
'''simple docstring'''
UpperCAmelCase_ = {'''zip''': zip_jsonl_path, '''gzip''': jsonl_gz_path}
UpperCAmelCase_ = compressed_file_paths[protocol]
UpperCAmelCase_ = '''dataset.jsonl'''
UpperCAmelCase_ = F"""{protocol}://{member_file_path}::{compressed_file_path}"""
UpperCAmelCase_ , *UpperCAmelCase_ = fsspec.get_fs_token_paths(_UpperCamelCase )
assert fs.isfile(_UpperCamelCase )
assert not fs.isfile('''non_existing_''' + member_file_path )
@pytest.mark.integration
def __lowerCamelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Dict , _UpperCamelCase : List[str] , _UpperCamelCase : Dict ):
'''simple docstring'''
UpperCAmelCase_ = hf_api.dataset_info(_UpperCamelCase , token=_UpperCamelCase )
UpperCAmelCase_ = HfFileSystem(repo_info=_UpperCamelCase , token=_UpperCamelCase )
assert sorted(hffs.glob('''*''' ) ) == [".gitattributes", "data"]
assert hffs.isdir('''data''' )
assert hffs.isfile('''.gitattributes''' ) and hffs.isfile('''data/text_data.txt''' )
with open(_UpperCamelCase ) as f:
assert hffs.open('''data/text_data.txt''' , '''r''' ).read() == f.read()
def __lowerCamelCase ( ):
'''simple docstring'''
UpperCAmelCase_ = '''bz2'''
# Import module
import datasets.filesystems
# Overwrite protocol and reload
register_implementation(_UpperCamelCase , _UpperCamelCase , clobber=_UpperCamelCase )
with pytest.warns(_UpperCamelCase ) as warning_info:
importlib.reload(datasets.filesystems )
assert len(_UpperCamelCase ) == 1
assert (
str(warning_info[0].message )
== F"""A filesystem protocol was already set for {protocol} and will be overwritten."""
)
| 390
| 0
|
'''simple docstring'''
from __future__ import annotations
def _lowercase ( lowerCamelCase__ ) -> list[int]:
"""simple docstring"""
return [ord(lowerCamelCase__ ) - 96 for elem in plain]
def _lowercase ( lowerCamelCase__ ) -> str:
"""simple docstring"""
return "".join(chr(elem + 96 ) for elem in encoded )
def _lowercase ( ) -> None:
"""simple docstring"""
__UpperCAmelCase : List[Any] = encode(input("-> " ).strip().lower() )
print("Encoded: " , lowerCamelCase__ )
print("Decoded:" , decode(lowerCamelCase__ ) )
if __name__ == "__main__":
main()
| 701
|
'''simple docstring'''
class __A :
def __init__( self , UpperCamelCase_ ):
__UpperCAmelCase : Any = set_counts
__UpperCAmelCase : int = max(UpperCamelCase_ )
__UpperCAmelCase : List[str] = len(UpperCamelCase_ )
__UpperCAmelCase : Any = [1] * num_sets
__UpperCAmelCase : Any = list(range(UpperCamelCase_ ) )
def _snake_case ( self , UpperCamelCase_ , UpperCamelCase_ ):
__UpperCAmelCase : Optional[int] = self.get_parent(UpperCamelCase_ )
__UpperCAmelCase : List[Any] = self.get_parent(UpperCamelCase_ )
if src_parent == dst_parent:
return False
if self.ranks[dst_parent] >= self.ranks[src_parent]:
self.set_counts[dst_parent] += self.set_counts[src_parent]
__UpperCAmelCase : Optional[Any] = 0
__UpperCAmelCase : List[Any] = dst_parent
if self.ranks[dst_parent] == self.ranks[src_parent]:
self.ranks[dst_parent] += 1
__UpperCAmelCase : Union[str, Any] = self.set_counts[dst_parent]
else:
self.set_counts[src_parent] += self.set_counts[dst_parent]
__UpperCAmelCase : Union[str, Any] = 0
__UpperCAmelCase : Dict = src_parent
__UpperCAmelCase : Dict = self.set_counts[src_parent]
__UpperCAmelCase : Dict = max(self.max_set , UpperCamelCase_ )
return True
def _snake_case ( self , UpperCamelCase_ ):
if self.parents[disj_set] == disj_set:
return disj_set
__UpperCAmelCase : str = self.get_parent(self.parents[disj_set] )
return self.parents[disj_set]
| 10
| 0
|
"""simple docstring"""
import multiprocessing
from typing import TYPE_CHECKING, Optional, Union
from .. import Dataset, Features, config
from ..formatting import query_table
from ..packaged_modules.sql.sql import Sql
from ..utils import logging
from .abc import AbstractDatasetInputStream
if TYPE_CHECKING:
import sqlitea
import sqlalchemy
class __UpperCAmelCase ( snake_case__ ):
"""simple docstring"""
def __init__( self : List[Any] , A_ : Union[str, "sqlalchemy.sql.Selectable"] , A_ : Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"] , A_ : Optional[Features] = None , A_ : str = None , A_ : bool = False , **A_ : Optional[Any] , )-> Tuple:
super().__init__(features=A_ , cache_dir=A_ , keep_in_memory=A_ , **A_ )
__UpperCamelCase = Sql(
cache_dir=A_ , features=A_ , sql=A_ , con=A_ , **A_ , )
def A ( self : Any )-> List[str]:
__UpperCamelCase = None
__UpperCamelCase = None
__UpperCamelCase = None
__UpperCamelCase = None
self.builder.download_and_prepare(
download_config=A_ , download_mode=A_ , verification_mode=A_ , base_path=A_ , )
# Build dataset for splits
__UpperCamelCase = self.builder.as_dataset(
split="train" , verification_mode=A_ , in_memory=self.keep_in_memory )
return dataset
class __UpperCAmelCase :
"""simple docstring"""
def __init__( self : int , A_ : Dataset , A_ : str , A_ : Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"] , A_ : Optional[int] = None , A_ : Optional[int] = None , **A_ : List[Any] , )-> Optional[int]:
if num_proc is not None and num_proc <= 0:
raise ValueError(f"""num_proc {num_proc} must be an integer > 0.""" )
__UpperCamelCase = dataset
__UpperCamelCase = name
__UpperCamelCase = con
__UpperCamelCase = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
__UpperCamelCase = num_proc
__UpperCamelCase = to_sql_kwargs
def A ( self : Tuple )-> int:
__UpperCamelCase = self.to_sql_kwargs.pop("sql" , A_ )
__UpperCamelCase = self.to_sql_kwargs.pop("con" , A_ )
__UpperCamelCase = self.to_sql_kwargs.pop("index" , A_ )
__UpperCamelCase = self._write(index=A_ , **self.to_sql_kwargs )
return written
def A ( self : Union[str, Any] , A_ : Dict )-> int:
__UpperCamelCase , __UpperCamelCase , __UpperCamelCase = args
__UpperCamelCase = {**to_sql_kwargs, "if_exists": "append"} if offset > 0 else to_sql_kwargs
__UpperCamelCase = query_table(
table=self.dataset.data , key=slice(A_ , offset + self.batch_size ) , indices=self.dataset._indices , )
__UpperCamelCase = batch.to_pandas()
__UpperCamelCase = df.to_sql(self.name , self.con , index=A_ , **A_ )
return num_rows or len(A_ )
def A ( self : Optional[int] , A_ : Union[str, Any] , **A_ : str )-> int:
__UpperCamelCase = 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 SQL from Arrow format" , ):
written += self._batch_sql((offset, index, to_sql_kwargs) )
else:
__UpperCamelCase , __UpperCamelCase = len(self.dataset ), self.batch_size
with multiprocessing.Pool(self.num_proc ) as pool:
for num_rows in logging.tqdm(
pool.imap(
self._batch_sql , [(offset, index, to_sql_kwargs) for offset in range(0 , A_ , A_ )] , ) , 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 SQL from Arrow format" , ):
written += num_rows
return written
| 505
|
"""simple docstring"""
import requests
_A = "https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="
def lowercase (_snake_case ) -> None:
'''simple docstring'''
__UpperCamelCase = requests.get(_NEWS_API + bbc_news_api_key ).json()
# each article in the list is a dict
for i, article in enumerate(bbc_news_page["articles"] ,1 ):
print(f"""{i}.) {article["title"]}""" )
if __name__ == "__main__":
fetch_bbc_news(bbc_news_api_key="<Your BBC News API key goes here>")
| 505
| 1
|
'''simple docstring'''
import numpy as np
import skfuzzy as fuzz
if __name__ == "__main__":
# Create universe of discourse in Python using linspace ()
UpperCamelCase_ : Optional[Any] = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False)
# Create two fuzzy sets by defining any membership function
# (trapmf(), gbellmf(), gaussmf(), etc).
UpperCamelCase_ : Dict = [0, 25, 50]
UpperCamelCase_ : Tuple = [25, 50, 75]
UpperCamelCase_ : Tuple = fuzz.membership.trimf(X, abca)
UpperCamelCase_ : int = fuzz.membership.trimf(X, abca)
# Compute the different operations using inbuilt functions.
UpperCamelCase_ : List[str] = np.ones(75)
UpperCamelCase_ : Any = np.zeros((75,))
# 1. Union = max(µA(x), µB(x))
UpperCamelCase_ : int = fuzz.fuzzy_or(X, young, X, middle_aged)[1]
# 2. Intersection = min(µA(x), µB(x))
UpperCamelCase_ : Tuple = fuzz.fuzzy_and(X, young, X, middle_aged)[1]
# 3. Complement (A) = (1- min(µA(x))
UpperCamelCase_ : int = fuzz.fuzzy_not(young)
# 4. Difference (A/B) = min(µA(x),(1- µB(x)))
UpperCamelCase_ : Tuple = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1]
# 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))]
UpperCamelCase_ : int = young + middle_aged - (young * middle_aged)
# 6. Algebraic Product = (µA(x) * µB(x))
UpperCamelCase_ : Dict = young * middle_aged
# 7. Bounded Sum = min[1,(µA(x), µB(x))]
UpperCamelCase_ : List[str] = fuzz.fuzzy_and(X, one, X, young + middle_aged)[1]
# 8. Bounded difference = min[0,(µA(x), µB(x))]
UpperCamelCase_ : Tuple = fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1]
# max-min composition
# max-product composition
# Plot each set A, set B and each operation result using plot() and subplot().
from matplotlib import pyplot as plt
plt.figure()
plt.subplot(4, 3, 1)
plt.plot(X, young)
plt.title("""Young""")
plt.grid(True)
plt.subplot(4, 3, 2)
plt.plot(X, middle_aged)
plt.title("""Middle aged""")
plt.grid(True)
plt.subplot(4, 3, 3)
plt.plot(X, union)
plt.title("""union""")
plt.grid(True)
plt.subplot(4, 3, 4)
plt.plot(X, intersection)
plt.title("""intersection""")
plt.grid(True)
plt.subplot(4, 3, 5)
plt.plot(X, complement_a)
plt.title("""complement_a""")
plt.grid(True)
plt.subplot(4, 3, 6)
plt.plot(X, difference)
plt.title("""difference a/b""")
plt.grid(True)
plt.subplot(4, 3, 7)
plt.plot(X, alg_sum)
plt.title("""alg_sum""")
plt.grid(True)
plt.subplot(4, 3, 8)
plt.plot(X, alg_product)
plt.title("""alg_product""")
plt.grid(True)
plt.subplot(4, 3, 9)
plt.plot(X, bdd_sum)
plt.title("""bdd_sum""")
plt.grid(True)
plt.subplot(4, 3, 10)
plt.plot(X, bdd_difference)
plt.title("""bdd_difference""")
plt.grid(True)
plt.subplots_adjust(hspace=0.5)
plt.show()
| 715
|
'''simple docstring'''
from manim import *
class lowerCamelCase__ ( __lowerCamelCase ):
"""simple docstring"""
def lowerCAmelCase_ ( self : Optional[Any] ):
a__ = Rectangle(height=0.5 ,width=0.5 )
a__ = Rectangle(height=0.46 ,width=0.46 ).set_stroke(width=0 )
a__ = [mem.copy() for i in range(6 )]
a__ = [mem.copy() for i in range(6 )]
a__ = VGroup(*a__ ).arrange(a__ ,buff=0 )
a__ = VGroup(*a__ ).arrange(a__ ,buff=0 )
a__ = VGroup(a__ ,a__ ).arrange(a__ ,buff=0 )
a__ = Text("CPU" ,font_size=24 )
a__ = Group(a__ ,a__ ).arrange(a__ ,buff=0.5 ,aligned_edge=a__ )
cpu.move_to([-2.5, -0.5, 0] )
self.add(a__ )
a__ = [mem.copy() for i in range(1 )]
a__ = VGroup(*a__ ).arrange(a__ ,buff=0 )
a__ = Text("GPU" ,font_size=24 )
a__ = Group(a__ ,a__ ).arrange(a__ ,buff=0.5 ,aligned_edge=a__ )
gpu.align_to(a__ ,a__ )
gpu.set_x(gpu.get_x() - 1 )
self.add(a__ )
a__ = [mem.copy() for i in range(6 )]
a__ = VGroup(*a__ ).arrange(a__ ,buff=0 )
a__ = Text("Model" ,font_size=24 )
a__ = Group(a__ ,a__ ).arrange(a__ ,buff=0.5 ,aligned_edge=a__ )
model.move_to([3, -1.0, 0] )
self.play(
Create(a__ ,run_time=1 ) ,Create(a__ ,run_time=1 ) ,Create(a__ ,run_time=1 ) ,)
a__ = MarkupText(
f'First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.' ,font_size=24 ,)
a__ = Square(side_length=2.2 )
key.move_to([-5, 2, 0] )
a__ = MarkupText(
f'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model' ,font_size=18 ,)
key_text.move_to([-5, 2.4, 0] )
step_a.move_to([2, 2, 0] )
self.play(Write(a__ ,run_time=2.5 ) ,Write(a__ ) ,Write(a__ ) )
self.add(a__ )
a__ = []
a__ = []
a__ = []
for i, rect in enumerate(a__ ):
a__ = Rectangle(height=0.46 ,width=0.46 ).set_stroke(width=0.0 ).set_fill(a__ ,opacity=0.7 )
cpu_target.move_to(a__ )
cpu_target.generate_target()
a__ = 0.46 / 4
a__ = 0.46 / 3
if i == 0:
cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT ) ,buff=0.02 ,direction=a__ )
cpu_target.target.set_x(cpu_target.target.get_x() + 0.1 )
elif i == 3:
cpu_target.target.next_to(cpu_targs[0].target ,direction=a__ ,buff=0.0 )
else:
cpu_target.target.next_to(cpu_targs[i - 1].target ,direction=a__ ,buff=0.0 )
cpu_targs.append(a__ )
first_animations.append(rect.animate(run_time=0.5 ).set_stroke(a__ ) )
second_animations.append(MoveToTarget(a__ ,run_time=1.5 ) )
self.play(*a__ )
self.play(*a__ )
self.wait()
| 394
| 0
|
from tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch
from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch
@require_torch
@require_tf
class SCREAMING_SNAKE_CASE ( snake_case ):
"""simple docstring"""
def __A ( self: Any ) -> Optional[Any]:
_A = SMALL_MODEL_IDENTIFIER
_A = '''pt'''
_A = '''tf'''
def __A ( self: Tuple , __A: str ) -> str:
_A = AutoModel.from_pretrained(self.test_model )
model_pt.save_pretrained(__A )
def __A ( self: List[Any] , __A: Any ) -> Optional[int]:
_A = TFAutoModel.from_pretrained(self.test_model , from_pt=__A )
model_tf.save_pretrained(__A )
def __A ( self: Optional[Any] ) -> int:
_A = '''mock_framework'''
# Framework provided - return whatever the user provides
_A = FeaturesManager.determine_framework(self.test_model , __A )
self.assertEqual(__A , __A )
# Local checkpoint and framework provided - return provided framework
# PyTorch checkpoint
with TemporaryDirectory() as local_pt_ckpt:
self._setup_pt_ckpt(__A )
_A = FeaturesManager.determine_framework(__A , __A )
self.assertEqual(__A , __A )
# TensorFlow checkpoint
with TemporaryDirectory() as local_tf_ckpt:
self._setup_tf_ckpt(__A )
_A = FeaturesManager.determine_framework(__A , __A )
self.assertEqual(__A , __A )
def __A ( self: int ) -> Union[str, Any]:
# PyTorch checkpoint
with TemporaryDirectory() as local_pt_ckpt:
self._setup_pt_ckpt(__A )
_A = FeaturesManager.determine_framework(__A )
self.assertEqual(__A , self.framework_pt )
# TensorFlow checkpoint
with TemporaryDirectory() as local_tf_ckpt:
self._setup_tf_ckpt(__A )
_A = FeaturesManager.determine_framework(__A )
self.assertEqual(__A , self.framework_tf )
# Invalid local checkpoint
with TemporaryDirectory() as local_invalid_ckpt:
with self.assertRaises(__A ):
_A = FeaturesManager.determine_framework(__A )
def __A ( self: Optional[Any] ) -> Dict:
_A = MagicMock(return_value=__A )
with patch('''transformers.onnx.features.is_tf_available''' , __A ):
_A = FeaturesManager.determine_framework(self.test_model )
self.assertEqual(__A , self.framework_pt )
# PyTorch not in environment -> use TensorFlow
_A = MagicMock(return_value=__A )
with patch('''transformers.onnx.features.is_torch_available''' , __A ):
_A = FeaturesManager.determine_framework(self.test_model )
self.assertEqual(__A , self.framework_tf )
# Both in environment -> use PyTorch
_A = MagicMock(return_value=__A )
_A = MagicMock(return_value=__A )
with patch('''transformers.onnx.features.is_tf_available''' , __A ), patch(
'''transformers.onnx.features.is_torch_available''' , __A ):
_A = FeaturesManager.determine_framework(self.test_model )
self.assertEqual(__A , self.framework_pt )
# Both not in environment -> raise error
_A = MagicMock(return_value=__A )
_A = MagicMock(return_value=__A )
with patch('''transformers.onnx.features.is_tf_available''' , __A ), patch(
'''transformers.onnx.features.is_torch_available''' , __A ):
with self.assertRaises(__A ):
_A = FeaturesManager.determine_framework(self.test_model )
| 484
|
import argparse
import json
import os
import re
import shutil
import torch
from transformers import BioGptConfig, BioGptForCausalLM
from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES
from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
from transformers.utils import WEIGHTS_NAME, logging
logging.set_verbosity_warning()
__A = 2
class SCREAMING_SNAKE_CASE :
"""simple docstring"""
def __init__( self: int , *, # begin keyword-only arguments
__A: Any="<s>" , __A: List[str]="<pad>" , __A: Optional[Any]="</s>" , __A: Dict="<unk>" , __A: Any=None , ) -> Tuple:
_A ,_A ,_A ,_A = bos, unk, pad, eos
_A = []
_A = []
_A = {}
_A = self.add_symbol(__A )
_A = self.add_symbol(__A )
_A = self.add_symbol(__A )
_A = self.add_symbol(__A )
if extra_special_symbols:
for s in extra_special_symbols:
self.add_symbol(__A )
_A = len(self.symbols )
def __eq__( self: Any , __A: Any ) -> Optional[Any]:
return self.indices == other.indices
def __getitem__( self: Tuple , __A: Optional[int] ) -> int:
if idx < len(self.symbols ):
return self.symbols[idx]
return self.unk_word
def __len__( self: Optional[Any] ) -> Optional[Any]:
return len(self.symbols )
def __contains__( self: Dict , __A: List[str] ) -> Union[str, Any]:
return sym in self.indices
@classmethod
def __A ( cls: Tuple , __A: Optional[Any] ) -> Optional[Any]:
_A = cls()
d.add_from_file(__A )
return d
def __A ( self: List[Any] , __A: List[str] , __A: List[Any]=1 , __A: List[Any]=False ) -> Optional[Any]:
if word in self.indices and not overwrite:
_A = self.indices[word]
_A = self.count[idx] + n
return idx
else:
_A = len(self.symbols )
_A = idx
self.symbols.append(__A )
self.count.append(__A )
return idx
def __A ( self: Optional[Any] , __A: Optional[int] ) -> str:
return 0
def __A ( self: List[str] , __A: Optional[Any] ) -> List[Any]:
if isinstance(__A , __A ):
try:
with open(__A , '''r''' , encoding='''utf-8''' ) as fd:
self.add_from_file(__A )
except FileNotFoundError as fnfe:
raise fnfe
except UnicodeError:
raise Exception('''Incorrect encoding detected in {}, please rebuild the dataset'''.format(__A ) )
return
_A = f.readlines()
_A = self._load_meta(__A )
for line in lines[indices_start_line:]:
try:
_A ,_A = line.rstrip().rsplit(''' ''' , 1 )
if field == "#fairseq:overwrite":
_A = True
_A ,_A = line.rsplit(''' ''' , 1 )
else:
_A = False
_A = int(__A )
_A = line
if word in self and not overwrite:
raise RuntimeError(
'''Duplicate word found when loading Dictionary: \'{}\'. '''
'''Duplicate words can overwrite earlier ones by adding the '''
'''#fairseq:overwrite flag at the end of the corresponding row '''
'''in the dictionary file. If using the Camembert model, please '''
'''download an updated copy of the model file.'''.format(__A ) )
self.add_symbol(__A , n=__A , overwrite=__A )
except ValueError:
raise ValueError('''Incorrect dictionary format, expected \'<token> <cnt> [flags]\'''' )
def __A ( _lowercase ):
'''simple docstring'''
_A = dict((re.sub(R'''@@$''' , '''''' , _lowercase ), v) if k.endswith('''@@''' ) else (re.sub(R'''$''' , '''</w>''' , _lowercase ), v) for k, v in d.items() )
_A = '''<s> <pad> </s> <unk>'''.split()
# restore the special tokens
for k in keep_keys:
del da[f"""{k}</w>"""]
_A = d[k] # restore
return da
def __A ( _lowercase , _lowercase ):
'''simple docstring'''
if not os.path.exists(_lowercase ):
raise ValueError(f"""path {biogpt_checkpoint_path} does not exist!""" )
os.makedirs(_lowercase , exist_ok=_lowercase )
print(f"""Writing results to {pytorch_dump_folder_path}""" )
# handle various types of models
_A = os.path.join(_lowercase , '''checkpoint.pt''' )
if not os.path.isfile(_lowercase ):
raise ValueError(f"""path to the file {checkpoint_file} does not exist!""" )
_A = torch.load(_lowercase , map_location='''cpu''' )
_A = chkpt['''cfg''']['''model''']
# dicts
_A = os.path.join(_lowercase , '''dict.txt''' )
if not os.path.isfile(_lowercase ):
raise ValueError(f"""path to the file {dict_file} does not exist!""" )
_A = Dictionary.load(_lowercase )
_A = rewrite_dict_keys(src_dict.indices )
_A = len(_lowercase )
_A = os.path.join(_lowercase , VOCAB_FILES_NAMES['''vocab_file'''] )
print(f"""Generating {src_vocab_file} of {src_vocab_size} records""" )
with open(_lowercase , '''w''' , encoding='''utf-8''' ) as f:
f.write(json.dumps(_lowercase , ensure_ascii=_lowercase , indent=_lowercase ) )
# merges_file (bpecodes)
_A = os.path.join(_lowercase , '''bpecodes''' )
if not os.path.isfile(_lowercase ):
raise ValueError(f"""path to the file {bpecodes_file} does not exist!""" )
_A = os.path.join(_lowercase , VOCAB_FILES_NAMES['''merges_file'''] )
shutil.copyfile(_lowercase , _lowercase )
# model config
_A = os.path.join(_lowercase , '''config.json''' )
_A = {
'''activation_dropout''': args['''activation_dropout'''],
'''architectures''': ['''BioGptForCausalLM'''],
'''attention_probs_dropout_prob''': args['''attention_dropout'''],
'''bos_token_id''': 0,
'''eos_token_id''': 2,
'''hidden_act''': args['''activation_fn'''],
'''hidden_dropout_prob''': args['''dropout'''],
'''hidden_size''': args['''decoder_embed_dim'''],
'''initializer_range''': 0.02,
'''intermediate_size''': args['''decoder_ffn_embed_dim'''],
'''layer_norm_eps''': 1e-12,
'''layerdrop''': args['''decoder_layerdrop'''],
'''max_position_embeddings''': args['''max_target_positions'''],
'''model_type''': '''biogpt''',
'''num_attention_heads''': args['''decoder_attention_heads'''],
'''num_hidden_layers''': args['''decoder_layers'''],
'''pad_token_id''': 1,
'''scale_embedding''': not args['''no_scale_embedding'''],
'''tie_word_embeddings''': args['''share_decoder_input_output_embed'''],
'''vocab_size''': src_vocab_size,
}
# good hparam defaults to start with
print(f"""Generating {biogpt_model_config_file}""" )
with open(_lowercase , '''w''' , encoding='''utf-8''' ) as f:
f.write(json.dumps(_lowercase , ensure_ascii=_lowercase , indent=_lowercase ) )
# tokenizer config
_A = os.path.join(_lowercase , _lowercase )
_A = {
'''bos_token''': '''<s>''',
'''eos_token''': '''</s>''',
'''model_max_length''': 10_24,
'''pad_token''': '''<pad>''',
'''special_tokens_map_file''': None,
'''tokenizer_class''': '''BioGptTokenizer''',
'''unk_token''': '''<unk>''',
}
print(f"""Generating {biogpt_tokenizer_config_file}""" )
with open(_lowercase , '''w''' , encoding='''utf-8''' ) as f:
f.write(json.dumps(_lowercase , ensure_ascii=_lowercase , indent=_lowercase ) )
# model
_A = chkpt['''model''']
# remove unneeded keys
_A = [
'''decoder.version''',
]
for k in ignore_keys:
model_state_dict.pop(_lowercase , _lowercase )
_A = list(model_state_dict.keys() )
for layer_name in layer_names:
if layer_name.endswith('''output_projection.weight''' ):
_A = model_state_dict.pop(_lowercase )
else:
_A = model_state_dict.pop(_lowercase )
_A = BioGptConfig.from_pretrained(_lowercase )
_A = BioGptForCausalLM(_lowercase )
# check that it loads ok
model_new.load_state_dict(_lowercase )
# save
_A = os.path.join(_lowercase , _lowercase )
print(f"""Generating {pytorch_weights_dump_path}""" )
torch.save(_lowercase , _lowercase )
print('''Conversion is done!''' )
if __name__ == "__main__":
__A = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--biogpt_checkpoint_path',
default=None,
type=str,
required=True,
help=(
'Path to the official PyTorch checkpoint file which is expected to reside in the dump dir with dicts,'
' bpecodes, etc.'
),
)
parser.add_argument(
'--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
)
__A = parser.parse_args()
convert_biogpt_checkpoint_to_pytorch(args.biogpt_checkpoint_path, args.pytorch_dump_folder_path)
| 484
| 1
|
import os
import tempfile
import unittest
from transformers import is_torch_available
from transformers.testing_utils import require_torch
if is_torch_available():
import torch
from torch import nn
from transformers import (
Adafactor,
AdamW,
get_constant_schedule,
get_constant_schedule_with_warmup,
get_cosine_schedule_with_warmup,
get_cosine_with_hard_restarts_schedule_with_warmup,
get_inverse_sqrt_schedule,
get_linear_schedule_with_warmup,
get_polynomial_decay_schedule_with_warmup,
)
def lowerCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE=10 ):
'''simple docstring'''
__UpperCamelCase :Optional[Any] = []
for _ in range(SCREAMING_SNAKE_CASE ):
lrs.append(scheduler.get_lr()[0] )
scheduler.step()
return lrs
def lowerCamelCase ( SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE=10 ):
'''simple docstring'''
__UpperCamelCase :List[Any] = []
for step in range(SCREAMING_SNAKE_CASE ):
lrs.append(scheduler.get_lr()[0] )
scheduler.step()
if step == num_steps // 2:
with tempfile.TemporaryDirectory() as tmpdirname:
__UpperCamelCase :str = os.path.join(SCREAMING_SNAKE_CASE , '''schedule.bin''' )
torch.save(scheduler.state_dict() , SCREAMING_SNAKE_CASE )
__UpperCamelCase :List[str] = torch.load(SCREAMING_SNAKE_CASE )
scheduler.load_state_dict(SCREAMING_SNAKE_CASE )
return lrs
@require_torch
class lowerCamelCase_ ( unittest.TestCase ):
'''simple docstring'''
def UpperCamelCase__ ( self , __lowercase , __lowercase , __lowercase) -> Optional[int]:
self.assertEqual(len(__lowercase) , len(__lowercase))
for a, b in zip(__lowercase , __lowercase):
self.assertAlmostEqual(__lowercase , __lowercase , delta=__lowercase)
def UpperCamelCase__ ( self) -> Any:
__UpperCamelCase :Tuple = torch.tensor([0.1, -0.2, -0.1] , requires_grad=__lowercase)
__UpperCamelCase :Tuple = torch.tensor([0.4, 0.2, -0.5])
__UpperCamelCase :List[Any] = nn.MSELoss()
# No warmup, constant schedule, no gradient clipping
__UpperCamelCase :Dict = AdamW(params=[w] , lr=2E-1 , weight_decay=0.0)
for _ in range(100):
__UpperCamelCase :Dict = criterion(__lowercase , __lowercase)
loss.backward()
optimizer.step()
w.grad.detach_() # No zero_grad() function on simple tensors. we do it ourselves.
w.grad.zero_()
self.assertListAlmostEqual(w.tolist() , [0.4, 0.2, -0.5] , tol=1E-2)
def UpperCamelCase__ ( self) -> List[str]:
__UpperCamelCase :Tuple = torch.tensor([0.1, -0.2, -0.1] , requires_grad=__lowercase)
__UpperCamelCase :List[str] = torch.tensor([0.4, 0.2, -0.5])
__UpperCamelCase :List[Any] = nn.MSELoss()
# No warmup, constant schedule, no gradient clipping
__UpperCamelCase :Any = Adafactor(
params=[w] , lr=1E-2 , eps=(1E-3_0, 1E-3) , clip_threshold=1.0 , decay_rate=-0.8 , betaa=__lowercase , weight_decay=0.0 , relative_step=__lowercase , scale_parameter=__lowercase , warmup_init=__lowercase , )
for _ in range(1_000):
__UpperCamelCase :int = criterion(__lowercase , __lowercase)
loss.backward()
optimizer.step()
w.grad.detach_() # No zero_grad() function on simple tensors. we do it ourselves.
w.grad.zero_()
self.assertListAlmostEqual(w.tolist() , [0.4, 0.2, -0.5] , tol=1E-2)
@require_torch
class lowerCamelCase_ ( unittest.TestCase ):
'''simple docstring'''
a__ : List[Any] = nn.Linear(5_0 , 5_0 ) if is_torch_available() else None
a__ : Union[str, Any] = AdamW(m.parameters() , lr=1_0.0 ) if is_torch_available() else None
a__ : Union[str, Any] = 1_0
def UpperCamelCase__ ( self , __lowercase , __lowercase , __lowercase , __lowercase=None) -> int:
self.assertEqual(len(__lowercase) , len(__lowercase))
for a, b in zip(__lowercase , __lowercase):
self.assertAlmostEqual(__lowercase , __lowercase , delta=__lowercase , msg=__lowercase)
def UpperCamelCase__ ( self) -> Union[str, Any]:
__UpperCamelCase :str = {'''num_warmup_steps''': 2, '''num_training_steps''': 10}
# schedulers doct format
# function: (sched_args_dict, expected_learning_rates)
__UpperCamelCase :Optional[Any] = {
get_constant_schedule: ({}, [10.0] * self.num_steps),
get_constant_schedule_with_warmup: (
{'''num_warmup_steps''': 4},
[0.0, 2.5, 5.0, 7.5, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0],
),
get_linear_schedule_with_warmup: (
{**common_kwargs},
[0.0, 5.0, 10.0, 8.75, 7.5, 6.25, 5.0, 3.75, 2.5, 1.25],
),
get_cosine_schedule_with_warmup: (
{**common_kwargs},
[0.0, 5.0, 10.0, 9.61, 8.53, 6.91, 5.0, 3.08, 1.46, 0.38],
),
get_cosine_with_hard_restarts_schedule_with_warmup: (
{**common_kwargs, '''num_cycles''': 2},
[0.0, 5.0, 10.0, 8.53, 5.0, 1.46, 10.0, 8.53, 5.0, 1.46],
),
get_polynomial_decay_schedule_with_warmup: (
{**common_kwargs, '''power''': 2.0, '''lr_end''': 1E-7},
[0.0, 5.0, 10.0, 7.6_56, 5.6_25, 3.9_06, 2.5, 1.4_06, 0.6_25, 0.1_56],
),
get_inverse_sqrt_schedule: (
{'''num_warmup_steps''': 2},
[0.0, 5.0, 10.0, 8.1_65, 7.0_71, 6.3_25, 5.7_74, 5.3_45, 5.0, 4.7_14],
),
}
for scheduler_func, data in scheds.items():
__UpperCamelCase :List[Any] = data
__UpperCamelCase :Optional[int] = scheduler_func(self.optimizer , **__lowercase)
self.assertEqual(len([scheduler.get_lr()[0]]) , 1)
__UpperCamelCase :List[str] = unwrap_schedule(__lowercase , self.num_steps)
self.assertListAlmostEqual(
__lowercase , __lowercase , tol=1E-2 , msg=f"""failed for {scheduler_func} in normal scheduler""" , )
__UpperCamelCase :Union[str, Any] = scheduler_func(self.optimizer , **__lowercase)
if scheduler_func.__name__ != "get_constant_schedule":
LambdaScheduleWrapper.wrap_scheduler(__lowercase) # wrap to test picklability of the schedule
__UpperCamelCase :List[str] = unwrap_and_save_reload_schedule(__lowercase , self.num_steps)
self.assertListEqual(__lowercase , __lowercase , msg=f"""failed for {scheduler_func} in save and reload""")
class lowerCamelCase_ :
'''simple docstring'''
def __init__( self , __lowercase) -> Any:
__UpperCamelCase :Union[str, Any] = fn
def __call__( self , *__lowercase , **__lowercase) -> Dict:
return self.fn(*__lowercase , **__lowercase)
@classmethod
def UpperCamelCase__ ( self , __lowercase) -> List[str]:
__UpperCamelCase :Optional[int] = list(map(self , scheduler.lr_lambdas))
| 713
|
import os
import unittest
from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow
from ...test_tokenization_common import TokenizerTesterMixin
@require_jieba
class lowerCamelCase_ ( UpperCAmelCase_ , unittest.TestCase ):
'''simple docstring'''
a__ : Any = CpmAntTokenizer
a__ : Optional[Any] = False
def UpperCamelCase__ ( self) -> Any:
super().setUp()
__UpperCamelCase :Optional[int] = [
'''<d>''',
'''</d>''',
'''<s>''',
'''</s>''',
'''</_>''',
'''<unk>''',
'''<pad>''',
'''</n>''',
'''我''',
'''是''',
'''C''',
'''P''',
'''M''',
'''A''',
'''n''',
'''t''',
]
__UpperCamelCase :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]))
@tooslow
def UpperCamelCase__ ( self) -> Dict:
__UpperCamelCase :Tuple = CpmAntTokenizer.from_pretrained('''openbmb/cpm-ant-10b''')
__UpperCamelCase :Dict = '''今天天气真好！'''
__UpperCamelCase :Tuple = ['''今天''', '''天气''', '''真''', '''好''', '''！''']
__UpperCamelCase :Optional[Any] = tokenizer.tokenize(__lowercase)
self.assertListEqual(__lowercase , __lowercase)
__UpperCamelCase :int = '''今天天气真好！'''
__UpperCamelCase :List[str] = [tokenizer.bos_token] + tokens
__UpperCamelCase :List[str] = [6, 9_802, 14_962, 2_082, 831, 244]
self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase) , __lowercase)
__UpperCamelCase :Dict = tokenizer.decode(__lowercase)
self.assertEqual(__lowercase , __lowercase)
| 452
| 0
|
from ...utils import is_torch_available, is_transformers_available
if is_transformers_available() and is_torch_available():
from .pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings, VQDiffusionPipeline
| 140
|
import argparse
import torch
from datasets import load_dataset
from donut import DonutModel
from transformers import (
DonutImageProcessor,
DonutProcessor,
DonutSwinConfig,
DonutSwinModel,
MBartConfig,
MBartForCausalLM,
VisionEncoderDecoderModel,
XLMRobertaTokenizerFast,
)
def UpperCamelCase ( __magic_name__ : Any ) -> int:
"""simple docstring"""
lowercase__ = model.config
lowercase__ = DonutSwinConfig(
image_size=original_config.input_size , patch_size=4 , depths=original_config.encoder_layer , num_heads=[4, 8, 16, 32] , window_size=original_config.window_size , embed_dim=128 , )
lowercase__ = MBartConfig(
is_decoder=__magic_name__ , is_encoder_decoder=__magic_name__ , add_cross_attention=__magic_name__ , decoder_layers=original_config.decoder_layer , max_position_embeddings=original_config.max_position_embeddings , vocab_size=len(
model.decoder.tokenizer ) , scale_embedding=__magic_name__ , add_final_layer_norm=__magic_name__ , )
return encoder_config, decoder_config
def UpperCamelCase ( __magic_name__ : Optional[Any] ) -> Optional[Any]:
"""simple docstring"""
if "encoder.model" in name:
lowercase__ = name.replace("""encoder.model""" , """encoder""" )
if "decoder.model" in name:
lowercase__ = name.replace("""decoder.model""" , """decoder""" )
if "patch_embed.proj" in name:
lowercase__ = name.replace("""patch_embed.proj""" , """embeddings.patch_embeddings.projection""" )
if "patch_embed.norm" in name:
lowercase__ = name.replace("""patch_embed.norm""" , """embeddings.norm""" )
if name.startswith("""encoder""" ):
if "layers" in name:
lowercase__ = """encoder.""" + name
if "attn.proj" in name:
lowercase__ = name.replace("""attn.proj""" , """attention.output.dense""" )
if "attn" in name and "mask" not in name:
lowercase__ = name.replace("""attn""" , """attention.self""" )
if "norm1" in name:
lowercase__ = name.replace("""norm1""" , """layernorm_before""" )
if "norm2" in name:
lowercase__ = name.replace("""norm2""" , """layernorm_after""" )
if "mlp.fc1" in name:
lowercase__ = name.replace("""mlp.fc1""" , """intermediate.dense""" )
if "mlp.fc2" in name:
lowercase__ = name.replace("""mlp.fc2""" , """output.dense""" )
if name == "encoder.norm.weight":
lowercase__ = """encoder.layernorm.weight"""
if name == "encoder.norm.bias":
lowercase__ = """encoder.layernorm.bias"""
return name
def UpperCamelCase ( __magic_name__ : Any , __magic_name__ : str ) -> Optional[int]:
"""simple docstring"""
for key in orig_state_dict.copy().keys():
lowercase__ = orig_state_dict.pop(__magic_name__ )
if "qkv" in key:
lowercase__ = key.split(""".""" )
lowercase__ = int(key_split[3] )
lowercase__ = int(key_split[5] )
lowercase__ = model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size
if "weight" in key:
lowercase__ = val[:dim, :]
lowercase__ = val[dim : dim * 2, :]
lowercase__ = val[-dim:, :]
else:
lowercase__ = val[:dim]
lowercase__ = val[dim : dim * 2]
lowercase__ = val[-dim:]
elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
# HuggingFace implementation doesn't use attn_mask buffer
# and model doesn't use final LayerNorms for the encoder
pass
else:
lowercase__ = val
return orig_state_dict
def UpperCamelCase ( __magic_name__ : Union[str, Any] , __magic_name__ : List[Any]=None , __magic_name__ : Dict=False ) -> int:
"""simple docstring"""
lowercase__ = DonutModel.from_pretrained(__magic_name__ ).eval()
# load HuggingFace model
lowercase__ , lowercase__ = get_configs(__magic_name__ )
lowercase__ = DonutSwinModel(__magic_name__ )
lowercase__ = MBartForCausalLM(__magic_name__ )
lowercase__ = VisionEncoderDecoderModel(encoder=__magic_name__ , decoder=__magic_name__ )
model.eval()
lowercase__ = original_model.state_dict()
lowercase__ = convert_state_dict(__magic_name__ , __magic_name__ )
model.load_state_dict(__magic_name__ )
# verify results on scanned document
lowercase__ = load_dataset("""hf-internal-testing/example-documents""" )
lowercase__ = dataset["""test"""][0]["""image"""].convert("""RGB""" )
lowercase__ = XLMRobertaTokenizerFast.from_pretrained(__magic_name__ , from_slow=__magic_name__ )
lowercase__ = DonutImageProcessor(
do_align_long_axis=original_model.config.align_long_axis , size=original_model.config.input_size[::-1] )
lowercase__ = DonutProcessor(__magic_name__ , __magic_name__ )
lowercase__ = processor(__magic_name__ , return_tensors="""pt""" ).pixel_values
if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
lowercase__ = """<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
lowercase__ = """When is the coffee break?"""
lowercase__ = task_prompt.replace("""{user_input}""" , __magic_name__ )
elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
lowercase__ = """<s_rvlcdip>"""
elif model_name in [
"naver-clova-ix/donut-base-finetuned-cord-v1",
"naver-clova-ix/donut-base-finetuned-cord-v1-2560",
]:
lowercase__ = """<s_cord>"""
elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
lowercase__ = """s_cord-v2>"""
elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
lowercase__ = """<s_zhtrainticket>"""
elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
# use a random prompt
lowercase__ = """hello world"""
else:
raise ValueError("""Model name not supported""" )
lowercase__ = original_model.decoder.tokenizer(__magic_name__ , add_special_tokens=__magic_name__ , return_tensors="""pt""" )[
"""input_ids"""
]
lowercase__ = original_model.encoder.model.patch_embed(__magic_name__ )
lowercase__ , lowercase__ = model.encoder.embeddings(__magic_name__ )
assert torch.allclose(__magic_name__ , __magic_name__ , atol=1E-3 )
# verify encoder hidden states
lowercase__ = original_model.encoder(__magic_name__ )
lowercase__ = model.encoder(__magic_name__ ).last_hidden_state
assert torch.allclose(__magic_name__ , __magic_name__ , atol=1E-2 )
# verify decoder hidden states
lowercase__ = original_model(__magic_name__ , __magic_name__ , __magic_name__ ).logits
lowercase__ = model(__magic_name__ , decoder_input_ids=__magic_name__ ).logits
assert torch.allclose(__magic_name__ , __magic_name__ , atol=1E-3 )
print("""Looks ok!""" )
if pytorch_dump_folder_path is not None:
print(f'''Saving model and processor to {pytorch_dump_folder_path}''' )
model.save_pretrained(__magic_name__ )
processor.save_pretrained(__magic_name__ )
if push_to_hub:
model.push_to_hub("""nielsr/""" + model_name.split("""/""" )[-1] , commit_message="""Update model""" )
processor.push_to_hub("""nielsr/""" + model_name.split("""/""" )[-1] , commit_message="""Update model""" )
if __name__ == "__main__":
A : Dict = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--model_name',
default='naver-clova-ix/donut-base-finetuned-docvqa',
required=False,
type=str,
help='Name of the original model you\'d like to convert.',
)
parser.add_argument(
'--pytorch_dump_folder_path',
default=None,
required=False,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub',
action='store_true',
help='Whether or not to push the converted model and processor to the 🤗 hub.',
)
A : Optional[int] = parser.parse_args()
convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
| 15
| 0
|
import logging
import re
import pytorch_quantization
import pytorch_quantization.nn as quant_nn
import torch
from pytorch_quantization import calib
from pytorch_quantization.tensor_quant import QuantDescriptor
__lowercase :Any = logging.getLogger(__name__)
__lowercase :List[str] = 50 # max width of layer names
__lowercase :str = 70 # max width of quantizer names
def UpperCAmelCase ( _lowerCamelCase : Optional[int] ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Optional[Any] = parser.add_argument_group("quant_trainer arguments" )
group.add_argument("--wprec" , type=__A , default=8 , help="weight precision" )
group.add_argument("--aprec" , type=__A , default=8 , help="activation precision" )
group.add_argument("--quant-per-tensor" , action="store_true" , help="per tensor weight scaling" )
group.add_argument("--quant-disable" , action="store_true" , help="disable all quantizers" )
group.add_argument("--quant-disable-embeddings" , action="store_true" , help="disable all embeddings quantizers" )
group.add_argument("--quant-disable-keyword" , type=__A , nargs="+" , help="disable quantizers by keyword" )
group.add_argument("--quant-disable-layer-module" , type=__A , help="disable quantizers by keyword under layer." )
group.add_argument("--quant-enable-layer-module" , type=__A , help="enable quantizers by keyword under layer" )
group.add_argument("--calibrator" , default="max" , help="which quantization range calibrator to use" )
group.add_argument("--percentile" , default=__A , type=__A , help="percentile for PercentileCalibrator" )
group.add_argument("--fuse-qkv" , action="store_true" , help="use the same scale factor for qkv" )
group.add_argument("--clip-gelu" , metavar="N" , type=__A , help="clip gelu output maximum value to N" )
group.add_argument(
"--recalibrate-weights" , action="store_true" , help=(
"recalibrate weight amaxes by taking the max of the weights."
" amaxes will be computed with the current quantization granularity (axis)."
) , )
def UpperCAmelCase ( _lowerCamelCase : int ):
'''simple docstring'''
if args.calibrator == "max":
SCREAMING_SNAKE_CASE__ : str = "max"
elif args.calibrator == "percentile":
if args.percentile is None:
raise ValueError("Specify --percentile when using percentile calibrator" )
SCREAMING_SNAKE_CASE__ : Tuple = "histogram"
elif args.calibrator == "mse":
SCREAMING_SNAKE_CASE__ : List[Any] = "histogram"
else:
raise ValueError(f"""Invalid calibrator {args.calibrator}""" )
SCREAMING_SNAKE_CASE__ : int = QuantDescriptor(num_bits=args.aprec , calib_method=__A )
SCREAMING_SNAKE_CASE__ : Union[str, Any] = QuantDescriptor(num_bits=args.wprec , axis=(None if args.quant_per_tensor else (0,)) )
quant_nn.QuantLinear.set_default_quant_desc_input(__A )
quant_nn.QuantLinear.set_default_quant_desc_weight(__A )
def UpperCAmelCase ( _lowerCamelCase : Dict , _lowerCamelCase : Tuple , _lowerCamelCase : str=False , _lowerCamelCase : Tuple=False ):
'''simple docstring'''
logger.info("Configuring Model for Quantization" )
logger.info(f"""using quantization package {pytorch_quantization.__file__}""" )
if not calib:
if args.quant_disable_embeddings:
set_quantizer_by_name(__A , ["embeddings"] , which="weight" , _disabled=__A )
if args.quant_disable:
set_quantizer_by_name(__A , [""] , _disabled=__A )
if args.quant_disable_keyword:
set_quantizer_by_name(__A , args.quant_disable_keyword , _disabled=__A )
if args.quant_disable_layer_module:
set_quantizer_by_name(__A , [r"layer.\d+." + args.quant_disable_layer_module] , _disabled=__A )
if args.quant_enable_layer_module:
set_quantizer_by_name(__A , [r"layer.\d+." + args.quant_enable_layer_module] , _disabled=__A )
if args.recalibrate_weights:
recalibrate_weights(__A )
if args.fuse_qkv:
fuse_qkv(__A , __A )
if args.clip_gelu:
clip_gelu(__A , args.clip_gelu )
# if args.local_rank in [-1, 0] and not calib:
print_quant_summary(__A )
def UpperCAmelCase ( _lowerCamelCase : Optional[Any] ):
'''simple docstring'''
logger.info("Enabling Calibration" )
for name, module in model.named_modules():
if name.endswith("_quantizer" ):
if module._calibrator is not None:
module.disable_quant()
module.enable_calib()
else:
module.disable()
logger.info(f"""{name:80}: {module}""" )
def UpperCAmelCase ( _lowerCamelCase : List[Any] , _lowerCamelCase : Union[str, Any] ):
'''simple docstring'''
logger.info("Loading calibrated amax" )
for name, module in model.named_modules():
if name.endswith("_quantizer" ):
if module._calibrator is not None:
if isinstance(module._calibrator , calib.MaxCalibrator ):
module.load_calib_amax()
else:
module.load_calib_amax("percentile" , percentile=args.percentile )
module.enable_quant()
module.disable_calib()
else:
module.enable()
model.cuda()
print_quant_summary(__A )
def UpperCAmelCase ( _lowerCamelCase : List[Any] , _lowerCamelCase : Dict ):
'''simple docstring'''
def fusea(_lowerCamelCase : int , _lowerCamelCase : List[str] , _lowerCamelCase : List[str] ):
for mod in [qq, qk, qv]:
if not hasattr(__A , "_amax" ):
print(" WARNING: NO AMAX BUFFER" )
return
SCREAMING_SNAKE_CASE__ : str = qq._amax.detach().item()
SCREAMING_SNAKE_CASE__ : Tuple = qk._amax.detach().item()
SCREAMING_SNAKE_CASE__ : List[str] = qv._amax.detach().item()
SCREAMING_SNAKE_CASE__ : str = max(__A , __A , __A )
qq._amax.fill_(__A )
qk._amax.fill_(__A )
qv._amax.fill_(__A )
logger.info(f""" q={q:5.2f} k={k:5.2f} v={v:5.2f} -> {amax:5.2f}""" )
for name, mod in model.named_modules():
if name.endswith(".attention.self" ):
logger.info(f"""FUSE_QKV: {name:{name_width}}""" )
fusea(mod.matmul_q_input_quantizer , mod.matmul_k_input_quantizer , mod.matmul_v_input_quantizer )
if args.quant_per_tensor:
fusea(mod.query._weight_quantizer , mod.key._weight_quantizer , mod.value._weight_quantizer )
def UpperCAmelCase ( _lowerCamelCase : Dict , _lowerCamelCase : Optional[Any] ):
'''simple docstring'''
for name, mod in model.named_modules():
if name.endswith(".output.dense" ) and not name.endswith("attention.output.dense" ):
SCREAMING_SNAKE_CASE__ : List[Any] = mod._input_quantizer._amax.data.detach().item()
mod._input_quantizer._amax.data.detach().clamp_(max=__A )
SCREAMING_SNAKE_CASE__ : Optional[int] = mod._input_quantizer._amax.data.detach().item()
logger.info(f"""CLIP_GELU: {name:{name_width}} amax: {amax_init:5.2f} -> {amax:5.2f}""" )
def UpperCAmelCase ( _lowerCamelCase : int ):
'''simple docstring'''
for name, mod in model.named_modules():
if hasattr(__A , "_weight_quantizer" ) and mod._weight_quantizer.axis is not None:
SCREAMING_SNAKE_CASE__ : str = mod.weight.shape[0]
SCREAMING_SNAKE_CASE__ : Union[str, Any] = mod._weight_quantizer._amax.detach()
SCREAMING_SNAKE_CASE__ : Dict = torch.ones(__A , dtype=amax.dtype , device=amax.device ) * amax
print(f"""expanding {name} {amax} -> {mod._weight_quantizer._amax}""" )
def UpperCAmelCase ( _lowerCamelCase : Optional[int] ):
'''simple docstring'''
for name, mod in model.named_modules():
if hasattr(__A , "_weight_quantizer" ):
if not hasattr(mod.weight_quantizer , "_amax" ):
print("RECALIB: {name:{name_width}} WARNING: NO AMAX BUFFER" )
continue
# determine which axes to reduce across
# e.g. a 4D tensor quantized per axis 0 should reduce over (1,2,3)
SCREAMING_SNAKE_CASE__ : List[str] = set() if mod._weight_quantizer.axis is None else set(mod._weight_quantizer.axis )
SCREAMING_SNAKE_CASE__ : List[Any] = set(range(len(mod.weight.size() ) ) ) - axis_set
SCREAMING_SNAKE_CASE__ : str = pytorch_quantization.utils.reduce_amax(mod.weight , axis=__A , keepdims=__A ).detach()
logger.info(f"""RECALIB: {name:{name_width}} {mod._weight_quantizer._amax.flatten()} -> {amax.flatten()}""" )
SCREAMING_SNAKE_CASE__ : List[str] = amax
def UpperCAmelCase ( _lowerCamelCase : Any , _lowerCamelCase : Any=25 , _lowerCamelCase : Any=180 , _lowerCamelCase : Tuple=None ):
'''simple docstring'''
if ignore is None:
SCREAMING_SNAKE_CASE__ : Any = []
elif not isinstance(__A , __A ):
SCREAMING_SNAKE_CASE__ : List[Any] = [ignore]
SCREAMING_SNAKE_CASE__ : int = 0
for name, mod in model.named_modules():
if not hasattr(__A , "weight" ):
continue
SCREAMING_SNAKE_CASE__ : List[str] = max(__A , len(__A ) )
for name, mod in model.named_modules():
SCREAMING_SNAKE_CASE__ : int = getattr(__A , "_input_quantizer" , __A )
SCREAMING_SNAKE_CASE__ : Dict = getattr(__A , "_weight_quantizer" , __A )
if not hasattr(__A , "weight" ):
continue
if type(__A ) in ignore:
continue
if [True for s in ignore if type(__A ) is str and s in name]:
continue
SCREAMING_SNAKE_CASE__ : Union[str, Any] = f"""Act:{input_q.extra_repr()}"""
SCREAMING_SNAKE_CASE__ : Dict = f"""Wgt:{weight_q.extra_repr()}"""
SCREAMING_SNAKE_CASE__ : int = f"""{name:{name_width}} {act_str} {wgt_str}"""
if len(__A ) <= line_width:
logger.info(__A )
else:
logger.info(f"""{name:{name_width}} {act_str}""" )
logger.info(f"""{' ':{name_width}} {wgt_str}""" )
def UpperCAmelCase ( _lowerCamelCase : Optional[Any] ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Dict = 0
for name, mod in model.named_modules():
if isinstance(__A , pytorch_quantization.nn.TensorQuantizer ):
print(f"""{name:80} {mod}""" )
count += 1
print(f"""{count} TensorQuantizers found in model""" )
def UpperCAmelCase ( _lowerCamelCase : List[str] , _lowerCamelCase : Any , _lowerCamelCase : Optional[Any] , _lowerCamelCase : Optional[int] , _lowerCamelCase : Optional[Any] ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Dict = getattr(__A , __A , __A )
if quantizer_mod is not None:
assert hasattr(__A , __A )
setattr(__A , __A , __A )
else:
logger.warning(f"""{name} has no {quantizer}""" )
def UpperCAmelCase ( _lowerCamelCase : Any , _lowerCamelCase : List[Any] , _lowerCamelCase : List[Any]="both" , **_lowerCamelCase : int ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Union[str, Any] = f"""Warning: changing {which} quantizers of {name:{qname_width}}"""
for k, v in kwargs.items():
s += f""" {k}={v}"""
if which in ["input", "both"]:
set_quantizer(__A , __A , "_input_quantizer" , __A , __A )
if which in ["weight", "both"]:
set_quantizer(__A , __A , "_weight_quantizer" , __A , __A )
logger.info(__A )
def UpperCAmelCase ( _lowerCamelCase : str , _lowerCamelCase : List[str] , **_lowerCamelCase : Any ):
'''simple docstring'''
for name, mod in model.named_modules():
if hasattr(__A , "_input_quantizer" ) or hasattr(__A , "_weight_quantizer" ):
for n in names:
if re.search(__A , __A ):
set_quantizers(__A , __A , **__A )
elif name.endswith("_quantizer" ):
for n in names:
if re.search(__A , __A ):
SCREAMING_SNAKE_CASE__ : Optional[int] = f"""Warning: changing {name:{name_width}}"""
for k, v in kwargs.items():
s += f""" {k}={v}"""
setattr(__A , __A , __A )
logger.info(__A )
| 701
|
import warnings
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class _a ( lowercase__ ):
"""simple docstring"""
snake_case_ = ["image_processor", "tokenizer"]
snake_case_ = "CLIPImageProcessor"
snake_case_ = ("CLIPTokenizer", "CLIPTokenizerFast")
def __init__( self : Any , a : List[Any]=None , a : Any=None , **a : int ) ->int:
SCREAMING_SNAKE_CASE__ : Optional[int] = None
if "feature_extractor" in kwargs:
warnings.warn(
"The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
" instead." , a , )
SCREAMING_SNAKE_CASE__ : List[Any] = kwargs.pop("feature_extractor" )
SCREAMING_SNAKE_CASE__ : int = image_processor if image_processor is not None else feature_extractor
if image_processor is None:
raise ValueError("You need to specify an `image_processor`." )
if tokenizer is None:
raise ValueError("You need to specify a `tokenizer`." )
super().__init__(a , a )
def __call__( self : Tuple , a : Tuple=None , a : Union[str, Any]=None , a : List[str]=None , **a : Optional[Any] ) ->Optional[Any]:
if text is None and images is None:
raise ValueError("You have to specify either text or images. Both cannot be none." )
if text is not None:
SCREAMING_SNAKE_CASE__ : str = self.tokenizer(a , return_tensors=a , **a )
if images is not None:
SCREAMING_SNAKE_CASE__ : int = self.image_processor(a , return_tensors=a , **a )
if text is not None and images is not None:
SCREAMING_SNAKE_CASE__ : Tuple = image_features.pixel_values
return encoding
elif text is not None:
return encoding
else:
return BatchEncoding(data=dict(**a ) , tensor_type=a )
def A_ ( self : Optional[int] , *a : Any , **a : List[str] ) ->Any:
return self.tokenizer.batch_decode(*a , **a )
def A_ ( self : Any , *a : Optional[int] , **a : Dict ) ->Any:
return self.tokenizer.decode(*a , **a )
@property
def A_ ( self : List[str] ) ->Union[str, Any]:
SCREAMING_SNAKE_CASE__ : Dict = self.tokenizer.model_input_names
SCREAMING_SNAKE_CASE__ : Union[str, Any] = self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
@property
def A_ ( self : Optional[int] ) ->List[Any]:
warnings.warn(
"`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead." , a , )
return self.image_processor_class
@property
def A_ ( self : Dict ) ->str:
warnings.warn(
"`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead." , a , )
return self.image_processor
| 26
| 0
|
def lowerCamelCase__ ( __lowerCamelCase : Tuple , __lowerCamelCase : List[Any] ):
__UpperCAmelCase : List[str] = 0
__UpperCAmelCase : List[str] = len(__lowerCamelCase ) - 1
while left <= right:
# avoid divided by 0 during interpolation
if sorted_collection[left] == sorted_collection[right]:
if sorted_collection[left] == item:
return left
else:
return None
__UpperCAmelCase : Union[str, Any] = left + ((item - sorted_collection[left]) * (right - left)) // (
sorted_collection[right] - sorted_collection[left]
)
# out of range check
if point < 0 or point >= len(__lowerCamelCase ):
return None
__UpperCAmelCase : str = sorted_collection[point]
if current_item == item:
return point
else:
if point < left:
__UpperCAmelCase : Optional[Any] = left
__UpperCAmelCase : Tuple = point
elif point > right:
__UpperCAmelCase : Optional[Any] = right
__UpperCAmelCase : Dict = point
else:
if item < current_item:
__UpperCAmelCase : Union[str, Any] = point - 1
else:
__UpperCAmelCase : str = point + 1
return None
def lowerCamelCase__ ( __lowerCamelCase : str , __lowerCamelCase : List[Any] , __lowerCamelCase : Optional[int] , __lowerCamelCase : Tuple ):
# avoid divided by 0 during interpolation
if sorted_collection[left] == sorted_collection[right]:
if sorted_collection[left] == item:
return left
else:
return None
__UpperCAmelCase : str = left + ((item - sorted_collection[left]) * (right - left)) // (
sorted_collection[right] - sorted_collection[left]
)
# out of range check
if point < 0 or point >= len(__lowerCamelCase ):
return None
if sorted_collection[point] == item:
return point
elif point < left:
return interpolation_search_by_recursion(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase )
elif point > right:
return interpolation_search_by_recursion(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase )
else:
if sorted_collection[point] > item:
return interpolation_search_by_recursion(
__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , point - 1 )
else:
return interpolation_search_by_recursion(
__lowerCamelCase , __lowerCamelCase , point + 1 , __lowerCamelCase )
def lowerCamelCase__ ( __lowerCamelCase : int ):
if collection != sorted(__lowerCamelCase ):
raise ValueError("""Collection must be ascending sorted""" )
return True
if __name__ == "__main__":
import sys
a : Optional[Any] = 0
if debug == 1:
a : Optional[Any] = [10, 30, 40, 45, 50, 66, 77, 93]
try:
__assert_sorted(collection)
except ValueError:
sys.exit("Sequence must be ascending sorted to apply interpolation search")
a : Tuple = 67
a : List[Any] = interpolation_search(collection, target)
if result is not None:
print(f"""{target} found at positions: {result}""")
else:
print("Not found")
| 63
|
"""simple docstring"""
import os
from datetime import datetime as dt
from github import Github
UpperCAmelCase__ = [
'good first issue',
'good second issue',
'good difficult issue',
'enhancement',
'new pipeline/model',
'new scheduler',
'wip',
]
def _UpperCAmelCase ( ) -> Optional[Any]:
_snake_case = Github(os.environ['''GITHUB_TOKEN'''] )
_snake_case = g.get_repo('''huggingface/diffusers''' )
_snake_case = repo.get_issues(state='''open''' )
for issue in open_issues:
_snake_case = sorted(issue.get_comments() , key=lambda __lowerCamelCase : i.created_at , reverse=__lowerCamelCase )
_snake_case = comments[0] if len(__lowerCamelCase ) > 0 else None
if (
last_comment is not None
and last_comment.user.login == "github-actions[bot]"
and (dt.utcnow() - issue.updated_at).days > 7
and (dt.utcnow() - issue.created_at).days >= 30
and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() )
):
# Closes the issue after 7 days of inactivity since the Stalebot notification.
issue.edit(state='''closed''' )
elif (
"stale" in issue.get_labels()
and last_comment is not None
and last_comment.user.login != "github-actions[bot]"
):
# Opens the issue if someone other than Stalebot commented.
issue.edit(state='''open''' )
issue.remove_from_labels('''stale''' )
elif (
(dt.utcnow() - issue.updated_at).days > 23
and (dt.utcnow() - issue.created_at).days >= 30
and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() )
):
# Post a Stalebot notification after 23 days of inactivity.
issue.create_comment(
'''This issue has been automatically marked as stale because it has not had '''
'''recent activity. If you think this still needs to be addressed '''
'''please comment on this thread.\n\nPlease note that issues that do not follow the '''
'''[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) '''
'''are likely to be ignored.''' )
issue.add_to_labels('''stale''' )
if __name__ == "__main__":
main()
| 224
| 0
|
'''simple docstring'''
import os
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch
import numpy as np
from datasets import Dataset
from transformers.models.realm.configuration_realm import RealmConfig
from transformers.models.realm.retrieval_realm import _REALM_BLOCK_RECORDS_FILENAME, RealmRetriever
from transformers.models.realm.tokenization_realm import VOCAB_FILES_NAMES, RealmTokenizer
class lowerCamelCase__( snake_case_ ):
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = tempfile.mkdtemp()
__lowercase = 5
# Realm tok
__lowercase = [
"""[UNK]""",
"""[CLS]""",
"""[SEP]""",
"""[PAD]""",
"""[MASK]""",
"""test""",
"""question""",
"""this""",
"""is""",
"""the""",
"""first""",
"""second""",
"""third""",
"""fourth""",
"""fifth""",
"""record""",
"""want""",
"""##want""",
"""##ed""",
"""wa""",
"""un""",
"""runn""",
"""##ing""",
""",""",
"""low""",
"""lowest""",
]
__lowercase = os.path.join(self.tmpdirname , """realm_tokenizer""" )
os.makedirs(__UpperCAmelCase , exist_ok=__UpperCAmelCase )
__lowercase = os.path.join(__UpperCAmelCase , 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 = os.path.join(self.tmpdirname , """realm_block_records""" )
os.makedirs(__UpperCAmelCase , exist_ok=__UpperCAmelCase )
def __magic_name__ ( self ):
"""simple docstring"""
return RealmTokenizer.from_pretrained(os.path.join(self.tmpdirname , """realm_tokenizer""" ) )
def __magic_name__ ( self ):
"""simple docstring"""
shutil.rmtree(self.tmpdirname )
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = RealmConfig(num_block_records=self.num_block_records )
return config
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = Dataset.from_dict(
{
"""id""": ["""0""", """1"""],
"""question""": ["""foo""", """bar"""],
"""answers""": [["""Foo""", """Bar"""], ["""Bar"""]],
} )
return dataset
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = np.array(
[
B"""This is the first record""",
B"""This is the second record""",
B"""This is the third record""",
B"""This is the fourth record""",
B"""This is the fifth record""",
B"""This is a longer longer longer record""",
] , dtype=__UpperCAmelCase , )
return block_records
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = RealmRetriever(
block_records=self.get_dummy_block_records() , tokenizer=self.get_tokenizer() , )
return retriever
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = self.get_config()
__lowercase = self.get_dummy_retriever()
__lowercase = retriever.tokenizer
__lowercase = np.array([0, 3] , dtype="""long""" )
__lowercase = tokenizer(["""Test question"""] ).input_ids
__lowercase = tokenizer(
["""the fourth"""] , add_special_tokens=__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase , return_attention_mask=__UpperCAmelCase , ).input_ids
__lowercase = config.reader_seq_len
__lowercase , __lowercase , __lowercase , __lowercase = retriever(
__UpperCAmelCase , __UpperCAmelCase , answer_ids=__UpperCAmelCase , max_length=__UpperCAmelCase , return_tensors="""np""" )
self.assertEqual(len(__UpperCAmelCase ) , 2 )
self.assertEqual(len(__UpperCAmelCase ) , 2 )
self.assertEqual(len(__UpperCAmelCase ) , 2 )
self.assertEqual(concat_inputs.input_ids.shape , (2, 1_0) )
self.assertEqual(concat_inputs.attention_mask.shape , (2, 1_0) )
self.assertEqual(concat_inputs.token_type_ids.shape , (2, 1_0) )
self.assertEqual(concat_inputs.special_tokens_mask.shape , (2, 1_0) )
self.assertEqual(
tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[0] ) , ["""[CLS]""", """test""", """question""", """[SEP]""", """this""", """is""", """the""", """first""", """record""", """[SEP]"""] , )
self.assertEqual(
tokenizer.convert_ids_to_tokens(concat_inputs.input_ids[1] ) , ["""[CLS]""", """test""", """question""", """[SEP]""", """this""", """is""", """the""", """fourth""", """record""", """[SEP]"""] , )
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = self.get_config()
__lowercase = self.get_dummy_retriever()
__lowercase = retriever.tokenizer
__lowercase = np.array([0, 3, 5] , dtype="""long""" )
__lowercase = tokenizer(["""Test question"""] ).input_ids
__lowercase = tokenizer(
["""the fourth""", """longer longer"""] , add_special_tokens=__UpperCAmelCase , return_token_type_ids=__UpperCAmelCase , return_attention_mask=__UpperCAmelCase , ).input_ids
__lowercase = config.reader_seq_len
__lowercase , __lowercase , __lowercase , __lowercase = retriever(
__UpperCAmelCase , __UpperCAmelCase , answer_ids=__UpperCAmelCase , max_length=__UpperCAmelCase , return_tensors="""np""" )
self.assertEqual([False, True, True] , __UpperCAmelCase )
self.assertEqual([[-1, -1, -1], [6, -1, -1], [6, 7, 8]] , __UpperCAmelCase )
self.assertEqual([[-1, -1, -1], [7, -1, -1], [7, 8, 9]] , __UpperCAmelCase )
def __magic_name__ ( self ):
"""simple docstring"""
__lowercase = self.get_dummy_retriever()
retriever.save_pretrained(os.path.join(self.tmpdirname , """realm_block_records""" ) )
# Test local path
__lowercase = retriever.from_pretrained(os.path.join(self.tmpdirname , """realm_block_records""" ) )
self.assertEqual(retriever.block_records[0] , B"""This is the first record""" )
# Test mocked remote path
with patch("""transformers.models.realm.retrieval_realm.hf_hub_download""" ) as mock_hf_hub_download:
__lowercase = os.path.join(
os.path.join(self.tmpdirname , """realm_block_records""" ) , _REALM_BLOCK_RECORDS_FILENAME )
__lowercase = RealmRetriever.from_pretrained("""google/realm-cc-news-pretrained-openqa""" )
self.assertEqual(retriever.block_records[0] , B"""This is the first record""" )
| 706
|
'''simple docstring'''
import numpy as np
from transformers import Pipeline
def lowercase__ ( __UpperCamelCase : str ):
'''simple docstring'''
__lowercase = np.max(__UpperCamelCase , axis=-1 , keepdims=__UpperCamelCase )
__lowercase = np.exp(outputs - maxes )
return shifted_exp / shifted_exp.sum(axis=-1 , keepdims=__UpperCamelCase )
class lowerCamelCase__( snake_case_ ):
def __magic_name__ ( self , **__UpperCAmelCase ):
"""simple docstring"""
__lowercase = {}
if "second_text" in kwargs:
__lowercase = kwargs["""second_text"""]
return preprocess_kwargs, {}, {}
def __magic_name__ ( self , __UpperCAmelCase , __UpperCAmelCase=None ):
"""simple docstring"""
return self.tokenizer(__UpperCAmelCase , text_pair=__UpperCAmelCase , return_tensors=self.framework )
def __magic_name__ ( self , __UpperCAmelCase ):
"""simple docstring"""
return self.model(**__UpperCAmelCase )
def __magic_name__ ( self , __UpperCAmelCase ):
"""simple docstring"""
__lowercase = model_outputs.logits[0].numpy()
__lowercase = softmax(__UpperCAmelCase )
__lowercase = np.argmax(__UpperCAmelCase )
__lowercase = self.model.config.idalabel[best_class]
__lowercase = probabilities[best_class].item()
__lowercase = logits.tolist()
return {"label": label, "score": score, "logits": logits}
| 339
| 0
|
"""simple docstring"""
from __future__ import annotations
import random
import unittest
from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTransfoXLForSequenceClassification,
TFTransfoXLLMHeadModel,
TFTransfoXLModel,
)
class snake_case_ :
def __init__( self , a_ , ):
a_ : List[str] = parent
a_ : Union[str, Any] = 1_3
a_ : int = 7
a_ : List[Any] = 3_0
a_ : List[str] = self.seq_length + self.mem_len
a_ : Tuple = 1_5
a_ : Any = True
a_ : List[str] = True
a_ : List[str] = 9_9
a_ : Union[str, Any] = [1_0, 5_0, 8_0]
a_ : Tuple = 3_2
a_ : str = 3_2
a_ : Dict = 4
a_ : Optional[int] = 8
a_ : str = 1_2_8
a_ : Optional[Any] = 2
a_ : int = 2
a_ : List[Any] = None
a_ : int = 1
a_ : Tuple = 0
a_ : Union[str, Any] = 3
a_ : Union[str, Any] = self.vocab_size - 1
a_ : int = 0.01
def snake_case_ ( self ):
a_ : List[str] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
a_ : List[str] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
a_ : Union[str, Any] = None
if self.use_labels:
a_ : Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
a_ : Dict = TransfoXLConfig(
vocab_size=self.vocab_size , mem_len=self.mem_len , clamp_len=self.clamp_len , cutoffs=self.cutoffs , d_model=self.hidden_size , d_embed=self.d_embed , n_head=self.num_attention_heads , d_head=self.d_head , d_inner=self.d_inner , div_val=self.div_val , n_layer=self.num_hidden_layers , eos_token_id=self.eos_token_id , pad_token_id=self.vocab_size - 1 , init_range=self.init_range , num_labels=self.num_labels , )
return (config, input_ids_a, input_ids_a, lm_labels)
def snake_case_ ( self ):
random.seed(self.seed )
tf.random.set_seed(self.seed )
def snake_case_ ( self , a_ , a_ , a_ , a_ ):
a_ : Tuple = TFTransfoXLModel(lowerCAmelCase__ )
a_ : Union[str, Any] = model(lowerCAmelCase__ ).to_tuple()
a_ : Optional[Any] = {"input_ids": input_ids_a, "mems": mems_a}
a_ : str = model(lowerCAmelCase__ ).to_tuple()
self.parent.assertEqual(hidden_states_a.shape , (self.batch_size, self.seq_length, self.hidden_size) )
self.parent.assertEqual(hidden_states_a.shape , (self.batch_size, self.seq_length, self.hidden_size) )
self.parent.assertListEqual(
[mem.shape for mem in mems_a] , [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers , )
self.parent.assertListEqual(
[mem.shape for mem in mems_a] , [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers , )
def snake_case_ ( self , a_ , a_ , a_ , a_ ):
a_ : Any = TFTransfoXLLMHeadModel(lowerCAmelCase__ )
a_ : int = model(lowerCAmelCase__ ).to_tuple()
a_ : int = {"input_ids": input_ids_a, "labels": lm_labels}
a_ : Tuple = model(lowerCAmelCase__ ).to_tuple()
a_ : Union[str, Any] = model([input_ids_a, mems_a] ).to_tuple()
a_ : Optional[int] = {"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}
a_ : Any = model(lowerCAmelCase__ ).to_tuple()
self.parent.assertEqual(lm_logits_a.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertListEqual(
[mem.shape for mem in mems_a] , [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers , )
self.parent.assertEqual(lm_logits_a.shape , (self.batch_size, self.seq_length, self.vocab_size) )
self.parent.assertListEqual(
[mem.shape for mem in mems_a] , [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers , )
def snake_case_ ( self , a_ , a_ , a_ , a_ ):
a_ : str = TFTransfoXLForSequenceClassification(lowerCAmelCase__ )
a_ : Union[str, Any] = model(lowerCAmelCase__ )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def snake_case_ ( self ):
a_ : str = self.prepare_config_and_inputs()
(a_) : List[Any] = config_and_inputs
a_ : Any = {"input_ids": input_ids_a}
return config, inputs_dict
@require_tf
class snake_case_ ( UpperCamelCase__ ,UpperCamelCase__ ,unittest.TestCase ):
__lowerCAmelCase = (
(TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
)
__lowerCAmelCase = () if is_tf_available() else ()
__lowerCAmelCase = (
{
"""feature-extraction""": TFTransfoXLModel,
"""text-classification""": TFTransfoXLForSequenceClassification,
"""text-generation""": TFTransfoXLLMHeadModel,
"""zero-shot""": TFTransfoXLForSequenceClassification,
}
if is_tf_available()
else {}
)
# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
__lowerCAmelCase = False
__lowerCAmelCase = False
__lowerCAmelCase = False
__lowerCAmelCase = False
def snake_case_ ( self , a_ , a_ , a_ , a_ , a_ ):
if pipeline_test_casse_name == "TextGenerationPipelineTests":
# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
# tokenizer.
return True
return False
def snake_case_ ( self ):
a_ : Any = TFTransfoXLModelTester(self )
a_ : List[Any] = ConfigTester(self , config_class=lowerCAmelCase__ , d_embed=3_7 )
def snake_case_ ( self ):
self.config_tester.run_common_tests()
def snake_case_ ( self ):
self.model_tester.set_seed()
a_ : Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_transfo_xl_model(*lowerCAmelCase__ )
def snake_case_ ( self ):
self.model_tester.set_seed()
a_ : Dict = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_transfo_xl_lm_head(*lowerCAmelCase__ )
def snake_case_ ( self ):
a_ : int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowerCAmelCase__ )
def snake_case_ ( self ):
a_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common()
a_ : List[str] = [TFTransfoXLForSequenceClassification]
for model_class in self.all_model_classes:
a_ : List[str] = model_class(lowerCAmelCase__ )
assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer )
if model_class in list_other_models_with_output_ebd:
a_ : Union[str, Any] = model.get_output_embeddings()
assert isinstance(lowerCAmelCase__ , tf.keras.layers.Layer )
a_ : Dict = model.get_bias()
assert name is None
else:
a_ : List[str] = model.get_output_embeddings()
assert x is None
a_ : Dict = model.get_bias()
assert name is None
def snake_case_ ( self ):
pass
@slow
def snake_case_ ( self ):
for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
a_ : Tuple = TFTransfoXLModel.from_pretrained(lowerCAmelCase__ )
self.assertIsNotNone(lowerCAmelCase__ )
@unittest.skip(reason="This model doesn't play well with fit() due to not returning a single loss." )
def snake_case_ ( self ):
pass
@require_tf
class snake_case_ ( unittest.TestCase ):
@unittest.skip("Skip test until #12651 is resolved." )
@slow
def snake_case_ ( self ):
a_ : Any = TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103" )
# fmt: off
a_ : Dict = tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0]] , dtype=tf.intaa ) # noqa: E231
# fmt: on
# In 1991 , the remains of Russian Tsar Nicholas II and his family
# ( except for Alexei and Maria ) are discovered .
# The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
# remainder of the story . 1883 Western Siberia ,
# a young Grigori Rasputin is asked by his father and a group of men to perform magic .
# Rasputin has a vision and denounces one of the men as a horse thief . Although his
# father initially slaps him for making such an accusation , Rasputin watches as the
# man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
# the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
# with people , even a bishop , begging for his blessing . <eod> </s> <eos>
# fmt: off
a_ : Any = [3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,0] # noqa: E231
# fmt: on
# In 1991, the remains of Russian Tsar Nicholas II and his family (
# except for Alexei and Maria ) are discovered. The voice of young son,
# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
# 1883 Western Siberia, a young Grigori Rasputin is asked by his father
# and a group of men to perform magic. Rasputin has a vision and
# denounces one of the men as a horse thief. Although his father initially
# slaps him for making such an accusation, Rasputin watches as the man
# is chased outside and beaten. Twenty years later, Rasputin sees a vision
# of the Virgin Mary, prompting him to become a priest.
# Rasputin quickly becomes famous, with people, even a bishop, begging for
# his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
# Nicholas II and his family were discovered. The voice of <unk> young son,
# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>
a_ : str = model.generate(lowerCAmelCase__ , max_length=2_0_0 , do_sample=lowerCAmelCase__ )
self.assertListEqual(output_ids[0].numpy().tolist() , lowerCAmelCase__ )
| 237
|
class __lowerCAmelCase :
def __init__( self , lowerCAmelCase__ , lowerCAmelCase__=None , lowerCAmelCase__=None ) -> Any:
'''simple docstring'''
a__ : Dict =data
a__ : str =previous
a__ : Any =next_node
def __str__( self ) -> str:
'''simple docstring'''
return F'''{self.data}'''
def _lowercase ( self ) -> int:
'''simple docstring'''
return self.data
def _lowercase ( self ) -> Any:
'''simple docstring'''
return self.next
def _lowercase ( self ) -> Optional[int]:
'''simple docstring'''
return self.previous
class __lowerCAmelCase :
def __init__( self , lowerCAmelCase__ ) -> Dict:
'''simple docstring'''
a__ : List[Any] =head
def __iter__( self ) -> Tuple:
'''simple docstring'''
return self
def _lowercase ( self ) -> int:
'''simple docstring'''
if not self.current:
raise StopIteration
else:
a__ : Union[str, Any] =self.current.get_data()
a__ : Dict =self.current.get_next()
return value
class __lowerCAmelCase :
def __init__( self ) -> int:
'''simple docstring'''
a__ : List[str] =None # First node in list
a__ : List[str] =None # Last node in list
def __str__( self ) -> Any:
'''simple docstring'''
a__ : List[str] =self.head
a__ : Dict =[]
while current is not None:
nodes.append(current.get_data() )
a__ : int =current.get_next()
return " ".join(str(lowerCAmelCase__ ) for node in nodes )
def __contains__( self , lowerCAmelCase__ ) -> Union[str, Any]:
'''simple docstring'''
a__ : Optional[int] =self.head
while current:
if current.get_data() == value:
return True
a__ : str =current.get_next()
return False
def __iter__( self ) -> List[Any]:
'''simple docstring'''
return LinkedListIterator(self.head )
def _lowercase ( self ) -> List[str]:
'''simple docstring'''
if self.head:
return self.head.get_data()
return None
def _lowercase ( self ) -> Any:
'''simple docstring'''
if self.tail:
return self.tail.get_data()
return None
def _lowercase ( self , lowerCAmelCase__ ) -> None:
'''simple docstring'''
if self.head is None:
a__ : Any =node
a__ : Dict =node
else:
self.insert_before_node(self.head , lowerCAmelCase__ )
def _lowercase ( self , lowerCAmelCase__ ) -> None:
'''simple docstring'''
if self.head is None:
self.set_head(lowerCAmelCase__ )
else:
self.insert_after_node(self.tail , lowerCAmelCase__ )
def _lowercase ( self , lowerCAmelCase__ ) -> None:
'''simple docstring'''
a__ : Optional[Any] =Node(lowerCAmelCase__ )
if self.head is None:
self.set_head(lowerCAmelCase__ )
else:
self.set_tail(lowerCAmelCase__ )
def _lowercase ( self , lowerCAmelCase__ , lowerCAmelCase__ ) -> None:
'''simple docstring'''
a__ : str =node
a__ : str =node.previous
if node.get_previous() is None:
a__ : Dict =node_to_insert
else:
a__ : Dict =node_to_insert
a__ : Union[str, Any] =node_to_insert
def _lowercase ( self , lowerCAmelCase__ , lowerCAmelCase__ ) -> None:
'''simple docstring'''
a__ : Any =node
a__ : int =node.next
if node.get_next() is None:
a__ : List[Any] =node_to_insert
else:
a__ : Optional[int] =node_to_insert
a__ : Dict =node_to_insert
def _lowercase ( self , lowerCAmelCase__ , lowerCAmelCase__ ) -> None:
'''simple docstring'''
a__ : Union[str, Any] =1
a__ : str =Node(lowerCAmelCase__ )
a__ : Optional[Any] =self.head
while node:
if current_position == position:
self.insert_before_node(lowerCAmelCase__ , lowerCAmelCase__ )
return
current_position += 1
a__ : Any =node.next
self.insert_after_node(self.tail , lowerCAmelCase__ )
def _lowercase ( self , lowerCAmelCase__ ) -> Node:
'''simple docstring'''
a__ : List[Any] =self.head
while node:
if node.get_data() == item:
return node
a__ : Any =node.get_next()
raise Exception("Node not found" )
def _lowercase ( self , lowerCAmelCase__ ) -> int:
'''simple docstring'''
if (node := self.get_node(lowerCAmelCase__ )) is not None:
if node == self.head:
a__ : List[Any] =self.head.get_next()
if node == self.tail:
a__ : Optional[int] =self.tail.get_previous()
self.remove_node_pointers(lowerCAmelCase__ )
@staticmethod
def _lowercase ( lowerCAmelCase__ ) -> None:
'''simple docstring'''
if node.get_next():
a__ : Optional[Any] =node.previous
if node.get_previous():
a__ : str =node.next
a__ : Any =None
a__ : int =None
def _lowercase ( self ) -> Dict:
'''simple docstring'''
return self.head is None
def _A ( ):
"""simple docstring"""
if __name__ == "__main__":
import doctest
doctest.testmod()
| 563
| 0
|
"""simple docstring"""
import inspect
import os
import unittest
import torch
import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment
class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ):
def __UpperCAmelCase ( self : int ):
lowerCamelCase__ = inspect.getfile(accelerate.test_utils )
lowerCamelCase__ = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_script.py"""] )
lowerCamelCase__ = os.path.sep.join(
mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_distributed_data_loop.py"""] )
lowerCamelCase__ = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_ops.py"""] )
@require_multi_gpu
def __UpperCAmelCase ( self : int ):
print(f"""Found {torch.cuda.device_count()} devices.""" )
lowerCamelCase__ = ["""torchrun""", f"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
with patch_environment(omp_num_threads=1 ):
execute_subprocess_async(SCREAMING_SNAKE_CASE_ , env=os.environ.copy() )
@require_multi_gpu
def __UpperCAmelCase ( self : Any ):
print(f"""Found {torch.cuda.device_count()} devices.""" )
lowerCamelCase__ = ["""torchrun""", f"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
print(f"""Command: {cmd}""" )
with patch_environment(omp_num_threads=1 ):
execute_subprocess_async(SCREAMING_SNAKE_CASE_ , env=os.environ.copy() )
@require_multi_gpu
def __UpperCAmelCase ( self : Dict ):
lowerCamelCase__ = ["""torchrun""", f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__ )]
with patch_environment(omp_num_threads=1 ):
execute_subprocess_async(SCREAMING_SNAKE_CASE_ , env=os.environ.copy() )
@require_multi_gpu
def __UpperCAmelCase ( self : Any ):
print(f"""Found {torch.cuda.device_count()} devices, using 2 devices only""" )
lowerCamelCase__ = ["""torchrun""", f"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
with patch_environment(omp_num_threads=1 , cuda_visible_devices="""0,1""" ):
execute_subprocess_async(SCREAMING_SNAKE_CASE_ , env=os.environ.copy() )
if __name__ == "__main__":
__magic_name__ = Accelerator()
__magic_name__ = (accelerator.state.process_index + 2, 10)
__magic_name__ = torch.randint(0, 10, shape).to(accelerator.device)
__magic_name__ = """"""
__magic_name__ = accelerator.pad_across_processes(tensor)
if tensora.shape[0] != accelerator.state.num_processes + 1:
error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
error_msg += "Tensors have different values."
if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
error_msg += "Padding was not done with the right value (0)."
__magic_name__ = accelerator.pad_across_processes(tensor, pad_first=True)
if tensora.shape[0] != accelerator.state.num_processes + 1:
error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
__magic_name__ = accelerator.state.num_processes - accelerator.state.process_index - 1
if not torch.equal(tensora[index:], tensor):
error_msg += "Tensors have different values."
if not torch.all(tensora[:index] == 0):
error_msg += "Padding was not done with the right value (0)."
# Raise error at the end to make sure we don't stop at the first failure.
if len(error_msg) > 0:
raise ValueError(error_msg)
| 716
|
"""simple docstring"""
from itertools import count
def _A ( __lowercase = 50 ):
"""simple docstring"""
lowerCamelCase__ = [1] * min_block_length
for n in count(__lowercase ):
fill_count_functions.append(1 )
for block_length in range(__lowercase , n + 1 ):
for block_start in range(n - block_length ):
fill_count_functions[n] += fill_count_functions[
n - block_start - block_length - 1
]
fill_count_functions[n] += 1
if fill_count_functions[n] > 100_0000:
break
return n
if __name__ == "__main__":
print(F'{solution() = }')
| 258
| 0
|
from __future__ import annotations
import pandas as pd
def _UpperCamelCase (a__ :list[int] , a__ :list[int] , a__ :int ):
"""simple docstring"""
UpperCamelCase__ = [0] * no_of_processes
UpperCamelCase__ = [0] * no_of_processes
# Copy the burst time into remaining_time[]
for i in range(a__ ):
UpperCamelCase__ = burst_time[i]
UpperCamelCase__ = 0
UpperCamelCase__ = 0
UpperCamelCase__ = 9_9999_9999
UpperCamelCase__ = 0
UpperCamelCase__ = False
# Process until all processes are completed
while complete != no_of_processes:
for j in range(a__ ):
if arrival_time[j] <= increment_time and remaining_time[j] > 0:
if remaining_time[j] < minm:
UpperCamelCase__ = remaining_time[j]
UpperCamelCase__ = j
UpperCamelCase__ = True
if not check:
increment_time += 1
continue
remaining_time[short] -= 1
UpperCamelCase__ = remaining_time[short]
if minm == 0:
UpperCamelCase__ = 9_9999_9999
if remaining_time[short] == 0:
complete += 1
UpperCamelCase__ = False
# Find finish time of current process
UpperCamelCase__ = increment_time + 1
# Calculate waiting time
UpperCamelCase__ = finish_time - arrival_time[short]
UpperCamelCase__ = finar - burst_time[short]
if waiting_time[short] < 0:
UpperCamelCase__ = 0
# Increment time
increment_time += 1
return waiting_time
def _UpperCamelCase (a__ :list[int] , a__ :int , a__ :list[int] ):
"""simple docstring"""
UpperCamelCase__ = [0] * no_of_processes
for i in range(a__ ):
UpperCamelCase__ = burst_time[i] + waiting_time[i]
return turn_around_time
def _UpperCamelCase (a__ :list[int] , a__ :list[int] , a__ :int ):
"""simple docstring"""
UpperCamelCase__ = 0
UpperCamelCase__ = 0
for i in range(a__ ):
UpperCamelCase__ = total_waiting_time + waiting_time[i]
UpperCamelCase__ = total_turn_around_time + turn_around_time[i]
print(f"""Average waiting time = {total_waiting_time / no_of_processes:.5f}""" )
print("""Average turn around time =""" , total_turn_around_time / no_of_processes )
if __name__ == "__main__":
print("Enter how many process you want to analyze")
UpperCamelCase__ = int(input())
UpperCamelCase__ = [0] * no_of_processes
UpperCamelCase__ = [0] * no_of_processes
UpperCamelCase__ = list(range(1, no_of_processes + 1))
for i in range(no_of_processes):
print("Enter the arrival time and burst time for process:--" + str(i + 1))
UpperCamelCase__ , UpperCamelCase__ = map(int, input().split())
UpperCamelCase__ = calculate_waitingtime(arrival_time, burst_time, no_of_processes)
UpperCamelCase__ = burst_time
UpperCamelCase__ = no_of_processes
UpperCamelCase__ = waiting_time
UpperCamelCase__ = calculate_turnaroundtime(bt, n, wt)
calculate_average_times(waiting_time, turn_around_time, no_of_processes)
UpperCamelCase__ = pd.DataFrame(
list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
columns=[
"Process",
"BurstTime",
"ArrivalTime",
"WaitingTime",
"TurnAroundTime",
],
)
# Printing the dataFrame
pd.set_option("display.max_rows", fcfs.shape[0] + 1)
print(fcfs)
| 619
|
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 __SCREAMING_SNAKE_CASE ( unittest.TestCase ):
snake_case : List[str] = MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING
def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ):
UpperCamelCase__ = hf_hub_download(
repo_id="""nateraw/video-demo""" , filename="""archery.mp4""" , repo_type="""dataset""" )
UpperCamelCase__ = VideoClassificationPipeline(model=__lowerCAmelCase , image_processor=__lowerCAmelCase , top_k=2 )
UpperCamelCase__ = [
example_video_filepath,
"""https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""",
]
return video_classifier, examples
def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase ):
for example in examples:
UpperCamelCase__ = video_classifier(__lowerCAmelCase )
self.assertEqual(
__lowerCAmelCase , [
{"""score""": ANY(__lowerCAmelCase ), """label""": ANY(__lowerCAmelCase )},
{"""score""": ANY(__lowerCAmelCase ), """label""": ANY(__lowerCAmelCase )},
] , )
@require_torch
def _lowerCamelCase ( self ):
UpperCamelCase__ = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification"""
UpperCamelCase__ = VideoMAEFeatureExtractor(
size={"""shortest_edge""": 10} , crop_size={"""height""": 10, """width""": 10} )
UpperCamelCase__ = pipeline(
"""video-classification""" , model=__lowerCAmelCase , feature_extractor=__lowerCAmelCase , frame_sampling_rate=4 )
UpperCamelCase__ = hf_hub_download(repo_id="""nateraw/video-demo""" , filename="""archery.mp4""" , repo_type="""dataset""" )
UpperCamelCase__ = video_classifier(__lowerCAmelCase , top_k=2 )
self.assertEqual(
nested_simplify(__lowerCAmelCase , decimals=4 ) , [{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}] , )
UpperCamelCase__ = video_classifier(
[
video_file_path,
video_file_path,
] , top_k=2 , )
self.assertEqual(
nested_simplify(__lowerCAmelCase , decimals=4 ) , [
[{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}],
[{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}],
] , )
@require_tf
def _lowerCamelCase ( self ):
pass
| 619
| 1
|
"""simple docstring"""
import warnings
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
class a ( UpperCAmelCase__ ):
UpperCamelCase : Tuple = ['image_processor', 'tokenizer']
UpperCamelCase : Union[str, Any] = 'CLIPImageProcessor'
UpperCamelCase : str = ('XLMRobertaTokenizer', 'XLMRobertaTokenizerFast')
def __init__( self : Union[str, Any] , lowerCAmelCase : Union[str, Any]=None , lowerCAmelCase : Optional[int]=None , **lowerCAmelCase : List[str] ) -> Dict:
'''simple docstring'''
SCREAMING_SNAKE_CASE_: List[str] =None
if "feature_extractor" in kwargs:
warnings.warn(
"""The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
""" instead.""" , lowerCAmelCase , )
SCREAMING_SNAKE_CASE_: Tuple =kwargs.pop("""feature_extractor""" )
SCREAMING_SNAKE_CASE_: Any =image_processor if image_processor is not None else feature_extractor
if image_processor is None:
raise ValueError("""You need to specify an `image_processor`.""" )
if tokenizer is None:
raise ValueError("""You need to specify a `tokenizer`.""" )
super().__init__(lowerCAmelCase , lowerCAmelCase )
def __call__( self : List[Any] , lowerCAmelCase : Optional[Any]=None , lowerCAmelCase : List[Any]=None , lowerCAmelCase : Union[str, Any]=None , **lowerCAmelCase : Optional[Any] ) -> Optional[int]:
'''simple docstring'''
if text is None and images is None:
raise ValueError("""You have to specify either text or images. Both cannot be none.""" )
if text is not None:
SCREAMING_SNAKE_CASE_: Optional[int] =self.tokenizer(lowerCAmelCase , return_tensors=lowerCAmelCase , **lowerCAmelCase )
if images is not None:
SCREAMING_SNAKE_CASE_: str =self.image_processor(lowerCAmelCase , return_tensors=lowerCAmelCase , **lowerCAmelCase )
if text is not None and images is not None:
SCREAMING_SNAKE_CASE_: Optional[Any] =image_features.pixel_values
return encoding
elif text is not None:
return encoding
else:
return BatchEncoding(data=dict(**lowerCAmelCase ) , tensor_type=lowerCAmelCase )
def lowerCamelCase__ ( self : List[Any] , *lowerCAmelCase : Tuple , **lowerCAmelCase : Tuple ) -> List[Any]:
'''simple docstring'''
return self.tokenizer.batch_decode(*lowerCAmelCase , **lowerCAmelCase )
def lowerCamelCase__ ( self : Dict , *lowerCAmelCase : Dict , **lowerCAmelCase : List[Any] ) -> int:
'''simple docstring'''
return self.tokenizer.decode(*lowerCAmelCase , **lowerCAmelCase )
@property
def lowerCamelCase__ ( self : Union[str, Any] ) -> str:
'''simple docstring'''
SCREAMING_SNAKE_CASE_: Optional[Any] =self.tokenizer.model_input_names
SCREAMING_SNAKE_CASE_: int =self.image_processor.model_input_names
return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names ) )
| 36
|
"""simple docstring"""
def __magic_name__ ( lowercase = 200_0000 ):
SCREAMING_SNAKE_CASE_: List[Any] =[0 for i in range(n + 1 )]
SCREAMING_SNAKE_CASE_: Union[str, Any] =1
SCREAMING_SNAKE_CASE_: Optional[Any] =1
for i in range(2 , int(n**0.5 ) + 1 ):
if primality_list[i] == 0:
for j in range(i * i , n + 1 , lowercase ):
SCREAMING_SNAKE_CASE_: Optional[int] =1
SCREAMING_SNAKE_CASE_: Dict =0
for i in range(lowercase ):
if primality_list[i] == 0:
sum_of_primes += i
return sum_of_primes
if __name__ == "__main__":
print(f"""{solution() = }""")
| 36
| 1
|
"""simple docstring"""
from typing import Optional, Union
import torch
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_mobilenet_va import MobileNetVaConfig
A_ : Tuple = logging.get_logger(__name__)
# General docstring
A_ : Dict = """MobileNetV1Config"""
# Base docstring
A_ : Union[str, Any] = """google/mobilenet_v1_1.0_224"""
A_ : str = [1, 1_024, 7, 7]
# Image classification docstring
A_ : str = """google/mobilenet_v1_1.0_224"""
A_ : List[Any] = """tabby, tabby cat"""
A_ : Dict = [
"""google/mobilenet_v1_1.0_224""",
"""google/mobilenet_v1_0.75_192""",
# See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
]
def A ( snake_case__ , snake_case__ , snake_case__=None ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ = {}
if isinstance(lowercase__ , lowercase__ ):
SCREAMING_SNAKE_CASE__ = model.mobilenet_va
else:
SCREAMING_SNAKE_CASE__ = model
SCREAMING_SNAKE_CASE__ = """MobilenetV1/Conv2d_0/"""
SCREAMING_SNAKE_CASE__ = backbone.conv_stem.convolution.weight
SCREAMING_SNAKE_CASE__ = backbone.conv_stem.normalization.bias
SCREAMING_SNAKE_CASE__ = backbone.conv_stem.normalization.weight
SCREAMING_SNAKE_CASE__ = backbone.conv_stem.normalization.running_mean
SCREAMING_SNAKE_CASE__ = backbone.conv_stem.normalization.running_var
for i in range(13 ):
SCREAMING_SNAKE_CASE__ = i + 1
SCREAMING_SNAKE_CASE__ = i * 2
SCREAMING_SNAKE_CASE__ = backbone.layer[pt_index]
SCREAMING_SNAKE_CASE__ = f"""MobilenetV1/Conv2d_{tf_index}_depthwise/"""
SCREAMING_SNAKE_CASE__ = pointer.convolution.weight
SCREAMING_SNAKE_CASE__ = pointer.normalization.bias
SCREAMING_SNAKE_CASE__ = pointer.normalization.weight
SCREAMING_SNAKE_CASE__ = pointer.normalization.running_mean
SCREAMING_SNAKE_CASE__ = pointer.normalization.running_var
SCREAMING_SNAKE_CASE__ = backbone.layer[pt_index + 1]
SCREAMING_SNAKE_CASE__ = f"""MobilenetV1/Conv2d_{tf_index}_pointwise/"""
SCREAMING_SNAKE_CASE__ = pointer.convolution.weight
SCREAMING_SNAKE_CASE__ = pointer.normalization.bias
SCREAMING_SNAKE_CASE__ = pointer.normalization.weight
SCREAMING_SNAKE_CASE__ = pointer.normalization.running_mean
SCREAMING_SNAKE_CASE__ = pointer.normalization.running_var
if isinstance(lowercase__ , lowercase__ ):
SCREAMING_SNAKE_CASE__ = """MobilenetV1/Logits/Conv2d_1c_1x1/"""
SCREAMING_SNAKE_CASE__ = model.classifier.weight
SCREAMING_SNAKE_CASE__ = model.classifier.bias
return tf_to_pt_map
def A ( snake_case__ , snake_case__ , snake_case__ ):
'''simple docstring'''
try:
import numpy as np
import tensorflow as tf
except ImportError:
logger.error(
"""Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see """
"""https://www.tensorflow.org/install/ for installation instructions.""" )
raise
# Load weights from TF model
SCREAMING_SNAKE_CASE__ = tf.train.list_variables(lowercase__ )
SCREAMING_SNAKE_CASE__ = {}
for name, shape in init_vars:
logger.info(f"""Loading TF weight {name} with shape {shape}""" )
SCREAMING_SNAKE_CASE__ = tf.train.load_variable(lowercase__ , lowercase__ )
SCREAMING_SNAKE_CASE__ = array
# Build TF to PyTorch weights loading map
SCREAMING_SNAKE_CASE__ = _build_tf_to_pytorch_map(lowercase__ , lowercase__ , lowercase__ )
for name, pointer in tf_to_pt_map.items():
logger.info(f"""Importing {name}""" )
if name not in tf_weights:
logger.info(f"""{name} not in tf pre-trained weights, skipping""" )
continue
SCREAMING_SNAKE_CASE__ = tf_weights[name]
if "depthwise_weights" in name:
logger.info("""Transposing depthwise""" )
SCREAMING_SNAKE_CASE__ = np.transpose(lowercase__ , (2, 3, 0, 1) )
elif "weights" in name:
logger.info("""Transposing""" )
if len(pointer.shape ) == 2: # copying into linear layer
SCREAMING_SNAKE_CASE__ = array.squeeze().transpose()
else:
SCREAMING_SNAKE_CASE__ = np.transpose(lowercase__ , (3, 2, 0, 1) )
if pointer.shape != array.shape:
raise ValueError(f"""Pointer shape {pointer.shape} and array shape {array.shape} mismatched""" )
logger.info(f"""Initialize PyTorch weight {name} {array.shape}""" )
SCREAMING_SNAKE_CASE__ = torch.from_numpy(lowercase__ )
tf_weights.pop(lowercase__ , lowercase__ )
tf_weights.pop(name + """/RMSProp""" , lowercase__ )
tf_weights.pop(name + """/RMSProp_1""" , lowercase__ )
tf_weights.pop(name + """/ExponentialMovingAverage""" , lowercase__ )
logger.info(f"""Weights not copied to PyTorch model: {", ".join(tf_weights.keys() )}""" )
return model
def A ( snake_case__ , snake_case__ ):
'''simple docstring'''
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = features.shape[-2:]
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = conv_layer.stride
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ = conv_layer.kernel_size
if in_height % stride_height == 0:
SCREAMING_SNAKE_CASE__ = max(kernel_height - stride_height , 0 )
else:
SCREAMING_SNAKE_CASE__ = max(kernel_height - (in_height % stride_height) , 0 )
if in_width % stride_width == 0:
SCREAMING_SNAKE_CASE__ = max(kernel_width - stride_width , 0 )
else:
SCREAMING_SNAKE_CASE__ = max(kernel_width - (in_width % stride_width) , 0 )
SCREAMING_SNAKE_CASE__ = pad_along_width // 2
SCREAMING_SNAKE_CASE__ = pad_along_width - pad_left
SCREAMING_SNAKE_CASE__ = pad_along_height // 2
SCREAMING_SNAKE_CASE__ = pad_along_height - pad_top
SCREAMING_SNAKE_CASE__ = (pad_left, pad_right, pad_top, pad_bottom)
return nn.functional.pad(lowercase__ , lowercase__ , """constant""" , 0.0 )
class lowerCamelCase (nn.Module ):
def __init__( self : Optional[Any] , __UpperCAmelCase : MobileNetVaConfig , __UpperCAmelCase : int , __UpperCAmelCase : int , __UpperCAmelCase : int , __UpperCAmelCase : Optional[int] = 1 , __UpperCAmelCase : Optional[int] = 1 , __UpperCAmelCase : bool = False , __UpperCAmelCase : Optional[bool] = True , __UpperCAmelCase : Optional[bool or str] = True , ) -> None:
super().__init__()
SCREAMING_SNAKE_CASE__ = config
if in_channels % groups != 0:
raise ValueError(F"""Input channels ({in_channels}) are not divisible by {groups} groups.""" )
if out_channels % groups != 0:
raise ValueError(F"""Output channels ({out_channels}) are not divisible by {groups} groups.""" )
SCREAMING_SNAKE_CASE__ = 0 if config.tf_padding else int((kernel_size - 1) / 2 )
SCREAMING_SNAKE_CASE__ = nn.Convad(
in_channels=_lowerCAmelCase , out_channels=_lowerCAmelCase , kernel_size=_lowerCAmelCase , stride=_lowerCAmelCase , padding=_lowerCAmelCase , groups=_lowerCAmelCase , bias=_lowerCAmelCase , padding_mode="""zeros""" , )
if use_normalization:
SCREAMING_SNAKE_CASE__ = nn.BatchNormad(
num_features=_lowerCAmelCase , eps=config.layer_norm_eps , momentum=0.9_997 , affine=_lowerCAmelCase , track_running_stats=_lowerCAmelCase , )
else:
SCREAMING_SNAKE_CASE__ = None
if use_activation:
if isinstance(_lowerCAmelCase , _lowerCAmelCase ):
SCREAMING_SNAKE_CASE__ = ACTaFN[use_activation]
elif isinstance(config.hidden_act , _lowerCAmelCase ):
SCREAMING_SNAKE_CASE__ = ACTaFN[config.hidden_act]
else:
SCREAMING_SNAKE_CASE__ = config.hidden_act
else:
SCREAMING_SNAKE_CASE__ = None
def SCREAMING_SNAKE_CASE ( self : Union[str, Any] , __UpperCAmelCase : torch.Tensor ) -> torch.Tensor:
if self.config.tf_padding:
SCREAMING_SNAKE_CASE__ = apply_tf_padding(_lowerCAmelCase , self.convolution )
SCREAMING_SNAKE_CASE__ = self.convolution(_lowerCAmelCase )
if self.normalization is not None:
SCREAMING_SNAKE_CASE__ = self.normalization(_lowerCAmelCase )
if self.activation is not None:
SCREAMING_SNAKE_CASE__ = self.activation(_lowerCAmelCase )
return features
class lowerCamelCase (__lowercase ):
lowerCamelCase__ : str = MobileNetVaConfig
lowerCamelCase__ : List[str] = load_tf_weights_in_mobilenet_va
lowerCamelCase__ : Any = 'mobilenet_v1'
lowerCamelCase__ : Optional[int] = 'pixel_values'
lowerCamelCase__ : Tuple = False
def SCREAMING_SNAKE_CASE ( self : Optional[int] , __UpperCAmelCase : Union[nn.Linear, nn.Convad] ) -> None:
if isinstance(_lowerCAmelCase , (nn.Linear, nn.Convad) ):
module.weight.data.normal_(mean=0.0 , std=self.config.initializer_range )
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(_lowerCAmelCase , nn.BatchNormad ):
module.bias.data.zero_()
module.weight.data.fill_(1.0 )
A_ : Union[str, Any] = R"""
This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
behavior.
Parameters:
config ([`MobileNetV1Config`]): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""
A_ : List[Any] = R"""
Args:
pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
[`MobileNetV1ImageProcessor.__call__`] for details.
output_hidden_states (`bool`, *optional*):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
more detail.
return_dict (`bool`, *optional*):
Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
'The bare MobileNetV1 model outputting raw hidden-states without any specific head on top.' ,__lowercase ,)
class lowerCamelCase (__lowercase ):
def __init__( self : str , __UpperCAmelCase : MobileNetVaConfig , __UpperCAmelCase : bool = True ) -> Any:
super().__init__(_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = config
SCREAMING_SNAKE_CASE__ = 3_2
SCREAMING_SNAKE_CASE__ = max(int(depth * config.depth_multiplier ) , config.min_depth )
SCREAMING_SNAKE_CASE__ = MobileNetVaConvLayer(
_lowerCAmelCase , in_channels=config.num_channels , out_channels=_lowerCAmelCase , kernel_size=3 , stride=2 , )
SCREAMING_SNAKE_CASE__ = [1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1]
SCREAMING_SNAKE_CASE__ = nn.ModuleList()
for i in range(1_3 ):
SCREAMING_SNAKE_CASE__ = out_channels
if strides[i] == 2 or i == 0:
depth *= 2
SCREAMING_SNAKE_CASE__ = max(int(depth * config.depth_multiplier ) , config.min_depth )
self.layer.append(
MobileNetVaConvLayer(
_lowerCAmelCase , in_channels=_lowerCAmelCase , out_channels=_lowerCAmelCase , kernel_size=3 , stride=strides[i] , groups=_lowerCAmelCase , ) )
self.layer.append(
MobileNetVaConvLayer(
_lowerCAmelCase , in_channels=_lowerCAmelCase , out_channels=_lowerCAmelCase , kernel_size=1 , ) )
SCREAMING_SNAKE_CASE__ = nn.AdaptiveAvgPoolad((1, 1) ) if add_pooling_layer else None
# Initialize weights and apply final processing
self.post_init()
def SCREAMING_SNAKE_CASE ( self : Union[str, Any] , __UpperCAmelCase : str ) -> List[str]:
raise NotImplementedError
@add_start_docstrings_to_model_forward(_lowerCAmelCase )
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC , output_type=_lowerCAmelCase , config_class=_CONFIG_FOR_DOC , modality="""vision""" , expected_output=_EXPECTED_OUTPUT_SHAPE , )
def SCREAMING_SNAKE_CASE ( self : Optional[int] , __UpperCAmelCase : Optional[torch.Tensor] = None , __UpperCAmelCase : Optional[bool] = None , __UpperCAmelCase : Optional[bool] = None , ) -> Union[tuple, BaseModelOutputWithPoolingAndNoAttention]:
SCREAMING_SNAKE_CASE__ = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
SCREAMING_SNAKE_CASE__ = return_dict if return_dict is not None else self.config.use_return_dict
if pixel_values is None:
raise ValueError("""You have to specify pixel_values""" )
SCREAMING_SNAKE_CASE__ = self.conv_stem(_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = () if output_hidden_states else None
for i, layer_module in enumerate(self.layer ):
SCREAMING_SNAKE_CASE__ = layer_module(_lowerCAmelCase )
if output_hidden_states:
SCREAMING_SNAKE_CASE__ = all_hidden_states + (hidden_states,)
SCREAMING_SNAKE_CASE__ = hidden_states
if self.pooler is not None:
SCREAMING_SNAKE_CASE__ = torch.flatten(self.pooler(_lowerCAmelCase ) , start_dim=1 )
else:
SCREAMING_SNAKE_CASE__ = None
if not return_dict:
return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None )
return BaseModelOutputWithPoolingAndNoAttention(
last_hidden_state=_lowerCAmelCase , pooler_output=_lowerCAmelCase , hidden_states=_lowerCAmelCase , )
@add_start_docstrings(
'\n MobileNetV1 model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n ImageNet.\n ' ,__lowercase ,)
class lowerCamelCase (__lowercase ):
def __init__( self : Dict , __UpperCAmelCase : MobileNetVaConfig ) -> None:
super().__init__(_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = config.num_labels
SCREAMING_SNAKE_CASE__ = MobileNetVaModel(_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = self.mobilenet_va.layer[-1].convolution.out_channels
# Classifier head
SCREAMING_SNAKE_CASE__ = nn.Dropout(config.classifier_dropout_prob , inplace=_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = nn.Linear(_lowerCAmelCase , config.num_labels ) if config.num_labels > 0 else nn.Identity()
# Initialize weights and apply final processing
self.post_init()
@add_start_docstrings_to_model_forward(_lowerCAmelCase )
@add_code_sample_docstrings(
checkpoint=_IMAGE_CLASS_CHECKPOINT , output_type=_lowerCAmelCase , config_class=_CONFIG_FOR_DOC , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT , )
def SCREAMING_SNAKE_CASE ( self : Any , __UpperCAmelCase : Optional[torch.Tensor] = None , __UpperCAmelCase : Optional[bool] = None , __UpperCAmelCase : Optional[torch.Tensor] = None , __UpperCAmelCase : Optional[bool] = None , ) -> Union[tuple, ImageClassifierOutputWithNoAttention]:
SCREAMING_SNAKE_CASE__ = return_dict if return_dict is not None else self.config.use_return_dict
SCREAMING_SNAKE_CASE__ = self.mobilenet_va(_lowerCAmelCase , output_hidden_states=_lowerCAmelCase , return_dict=_lowerCAmelCase )
SCREAMING_SNAKE_CASE__ = outputs.pooler_output if return_dict else outputs[1]
SCREAMING_SNAKE_CASE__ = self.classifier(self.dropout(_lowerCAmelCase ) )
SCREAMING_SNAKE_CASE__ = None
if labels is not None:
if self.config.problem_type is None:
if self.num_labels == 1:
SCREAMING_SNAKE_CASE__ = """regression"""
elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
SCREAMING_SNAKE_CASE__ = """single_label_classification"""
else:
SCREAMING_SNAKE_CASE__ = """multi_label_classification"""
if self.config.problem_type == "regression":
SCREAMING_SNAKE_CASE__ = MSELoss()
if self.num_labels == 1:
SCREAMING_SNAKE_CASE__ = loss_fct(logits.squeeze() , labels.squeeze() )
else:
SCREAMING_SNAKE_CASE__ = loss_fct(_lowerCAmelCase , _lowerCAmelCase )
elif self.config.problem_type == "single_label_classification":
SCREAMING_SNAKE_CASE__ = CrossEntropyLoss()
SCREAMING_SNAKE_CASE__ = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) )
elif self.config.problem_type == "multi_label_classification":
SCREAMING_SNAKE_CASE__ = BCEWithLogitsLoss()
SCREAMING_SNAKE_CASE__ = loss_fct(_lowerCAmelCase , _lowerCAmelCase )
if not return_dict:
SCREAMING_SNAKE_CASE__ = (logits,) + outputs[2:]
return ((loss,) + output) if loss is not None else output
return ImageClassifierOutputWithNoAttention(
loss=_lowerCAmelCase , logits=_lowerCAmelCase , hidden_states=outputs.hidden_states , )
| 196
|
import os
from itertools import chain
from random import randrange, shuffle
import pytest
from .sola import PokerHand
__lowercase : Any =(
"""4S 3H 2C 7S 5H""",
"""9D 8H 2C 6S 7H""",
"""2D 6D 9D TH 7D""",
"""TC 8C 2S JH 6C""",
"""JH 8S TH AH QH""",
"""TS KS 5S 9S AC""",
"""KD 6S 9D TH AD""",
"""KS 8D 4D 9S 4S""", # pair
"""8C 4S KH JS 4D""", # pair
"""QH 8H KD JH 8S""", # pair
"""KC 4H KS 2H 8D""", # pair
"""KD 4S KC 3H 8S""", # pair
"""AH 8S AS KC JH""", # pair
"""3H 4C 4H 3S 2H""", # 2 pairs
"""5S 5D 2C KH KH""", # 2 pairs
"""3C KH 5D 5S KH""", # 2 pairs
"""AS 3C KH AD KH""", # 2 pairs
"""7C 7S 3S 7H 5S""", # 3 of a kind
"""7C 7S KH 2H 7H""", # 3 of a kind
"""AC KH QH AH AS""", # 3 of a kind
"""2H 4D 3C AS 5S""", # straight (low ace)
"""3C 5C 4C 2C 6H""", # straight
"""6S 8S 7S 5H 9H""", # straight
"""JS QS 9H TS KH""", # straight
"""QC KH TS JS AH""", # straight (high ace)
"""8C 9C 5C 3C TC""", # flush
"""3S 8S 9S 5S KS""", # flush
"""4C 5C 9C 8C KC""", # flush
"""JH 8H AH KH QH""", # flush
"""3D 2H 3H 2C 2D""", # full house
"""2H 2C 3S 3H 3D""", # full house
"""KH KC 3S 3H 3D""", # full house
"""JC 6H JS JD JH""", # 4 of a kind
"""JC 7H JS JD JH""", # 4 of a kind
"""JC KH JS JD JH""", # 4 of a kind
"""2S AS 4S 5S 3S""", # straight flush (low ace)
"""2D 6D 3D 4D 5D""", # straight flush
"""5C 6C 3C 7C 4C""", # straight flush
"""JH 9H TH KH QH""", # straight flush
"""JH AH TH KH QH""", # royal flush (high ace straight flush)
)
__lowercase : Union[str, Any] =(
("""2H 3H 4H 5H 6H""", """KS AS TS QS JS""", """Loss"""),
("""2H 3H 4H 5H 6H""", """AS AD AC AH JD""", """Win"""),
("""AS AH 2H AD AC""", """JS JD JC JH 3D""", """Win"""),
("""2S AH 2H AS AC""", """JS JD JC JH AD""", """Loss"""),
("""2S AH 2H AS AC""", """2H 3H 5H 6H 7H""", """Win"""),
("""AS 3S 4S 8S 2S""", """2H 3H 5H 6H 7H""", """Win"""),
("""2H 3H 5H 6H 7H""", """2S 3H 4H 5S 6C""", """Win"""),
("""2S 3H 4H 5S 6C""", """3D 4C 5H 6H 2S""", """Tie"""),
("""2S 3H 4H 5S 6C""", """AH AC 5H 6H AS""", """Win"""),
("""2S 2H 4H 5S 4C""", """AH AC 5H 6H AS""", """Loss"""),
("""2S 2H 4H 5S 4C""", """AH AC 5H 6H 7S""", """Win"""),
("""6S AD 7H 4S AS""", """AH AC 5H 6H 7S""", """Loss"""),
("""2S AH 4H 5S KC""", """AH AC 5H 6H 7S""", """Loss"""),
("""2S 3H 6H 7S 9C""", """7H 3C TH 6H 9S""", """Loss"""),
("""4S 5H 6H TS AC""", """3S 5H 6H TS AC""", """Win"""),
("""2S AH 4H 5S 6C""", """AD 4C 5H 6H 2C""", """Tie"""),
("""AS AH 3H AD AC""", """AS AH 2H AD AC""", """Win"""),
("""AH AC 5H 5C QS""", """AH AC 5H 5C KS""", """Loss"""),
("""AH AC 5H 5C QS""", """KH KC 5H 5C QS""", """Win"""),
("""7C 7S KH 2H 7H""", """3C 3S AH 2H 3H""", """Win"""),
("""3C 3S AH 2H 3H""", """7C 7S KH 2H 7H""", """Loss"""),
("""6H 5H 4H 3H 2H""", """5H 4H 3H 2H AH""", """Win"""),
("""5H 4H 3H 2H AH""", """5H 4H 3H 2H AH""", """Tie"""),
("""5H 4H 3H 2H AH""", """6H 5H 4H 3H 2H""", """Loss"""),
("""AH AD KS KC AC""", """AH KD KH AC KC""", """Win"""),
("""2H 4D 3C AS 5S""", """2H 4D 3C 6S 5S""", """Loss"""),
("""2H 3S 3C 3H 2S""", """3S 3C 2S 2H 2D""", """Win"""),
("""4D 6D 5D 2D JH""", """3S 8S 3H TC KH""", """Loss"""),
("""4S 6C 8S 3S 7S""", """AD KS 2D 7D 7C""", """Loss"""),
("""6S 4C 7H 8C 3H""", """5H JC AH 9D 9C""", """Loss"""),
("""9D 9H JH TC QH""", """3C 2S JS 5C 7H""", """Win"""),
("""2H TC 8S AD 9S""", """4H TS 7H 2C 5C""", """Win"""),
("""9D 3S 2C 7S 7C""", """JC TD 3C TC 9H""", """Loss"""),
)
__lowercase : List[str] =(
("""2H 3H 4H 5H 6H""", True),
("""AS AH 2H AD AC""", False),
("""2H 3H 5H 6H 7H""", True),
("""KS AS TS QS JS""", True),
("""8H 9H QS JS TH""", False),
("""AS 3S 4S 8S 2S""", True),
)
__lowercase : str =(
("""2H 3H 4H 5H 6H""", True),
("""AS AH 2H AD AC""", False),
("""2H 3H 5H 6H 7H""", False),
("""KS AS TS QS JS""", True),
("""8H 9H QS JS TH""", True),
)
__lowercase : Union[str, Any] =(
("""2H 4D 3C AS 5S""", True, [5, 4, 3, 2, 14]),
("""2H 5D 3C AS 5S""", False, [14, 5, 5, 3, 2]),
("""JH QD KC AS TS""", False, [14, 13, 12, 11, 10]),
("""9D 3S 2C 7S 7C""", False, [9, 7, 7, 3, 2]),
)
__lowercase : str =(
("""JH AH TH KH QH""", 0),
("""JH 9H TH KH QH""", 0),
("""JC KH JS JD JH""", 7),
("""KH KC 3S 3H 3D""", 6),
("""8C 9C 5C 3C TC""", 0),
("""JS QS 9H TS KH""", 0),
("""7C 7S KH 2H 7H""", 3),
("""3C KH 5D 5S KH""", 2),
("""QH 8H KD JH 8S""", 1),
("""2D 6D 9D TH 7D""", 0),
)
__lowercase : int =(
("""JH AH TH KH QH""", 23),
("""JH 9H TH KH QH""", 22),
("""JC KH JS JD JH""", 21),
("""KH KC 3S 3H 3D""", 20),
("""8C 9C 5C 3C TC""", 19),
("""JS QS 9H TS KH""", 18),
("""7C 7S KH 2H 7H""", 17),
("""3C KH 5D 5S KH""", 16),
("""QH 8H KD JH 8S""", 15),
("""2D 6D 9D TH 7D""", 14),
)
def a__ ( ):
'''simple docstring'''
UpperCAmelCase_ , UpperCAmelCase_ =randrange(len(lowercase__ ) ), randrange(len(lowercase__ ) )
UpperCAmelCase_ =["Loss", "Tie", "Win"][(play >= oppo) + (play > oppo)]
UpperCAmelCase_ , UpperCAmelCase_ =SORTED_HANDS[play], SORTED_HANDS[oppo]
return hand, other, expected
def a__ ( lowercase__ = 1_0_0 ):
'''simple docstring'''
return (generate_random_hand() for _ in range(lowercase__ ))
@pytest.mark.parametrize("hand, expected" , lowercase__ )
def a__ ( lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ )._is_flush() == expected
@pytest.mark.parametrize("hand, expected" , lowercase__ )
def a__ ( lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ )._is_straight() == expected
@pytest.mark.parametrize("hand, expected, card_values" , lowercase__ )
def a__ ( lowercase__ , lowercase__ , lowercase__ ):
'''simple docstring'''
UpperCAmelCase_ =PokerHand(lowercase__ )
assert player._is_five_high_straight() == expected
assert player._card_values == card_values
@pytest.mark.parametrize("hand, expected" , lowercase__ )
def a__ ( lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ )._is_same_kind() == expected
@pytest.mark.parametrize("hand, expected" , lowercase__ )
def a__ ( lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ )._hand_type == expected
@pytest.mark.parametrize("hand, other, expected" , lowercase__ )
def a__ ( lowercase__ , lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ ).compare_with(PokerHand(lowercase__ ) ) == expected
@pytest.mark.parametrize("hand, other, expected" , generate_random_hands() )
def a__ ( lowercase__ , lowercase__ , lowercase__ ):
'''simple docstring'''
assert PokerHand(lowercase__ ).compare_with(PokerHand(lowercase__ ) ) == expected
def a__ ( ):
'''simple docstring'''
UpperCAmelCase_ =[PokerHand(lowercase__ ) for hand in SORTED_HANDS]
UpperCAmelCase_ =poker_hands.copy()
shuffle(lowercase__ )
UpperCAmelCase_ =chain(sorted(lowercase__ ) )
for index, hand in enumerate(lowercase__ ):
assert hand == poker_hands[index]
def a__ ( ):
'''simple docstring'''
UpperCAmelCase_ =[PokerHand("2D AC 3H 4H 5S" ), PokerHand("2S 3H 4H 5S 6C" )]
pokerhands.sort(reverse=lowercase__ )
assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"
def a__ ( ):
'''simple docstring'''
UpperCAmelCase_ =PokerHand("2C 4S AS 3D 5C" )
UpperCAmelCase_ =True
UpperCAmelCase_ =[5, 4, 3, 2, 1_4]
for _ in range(1_0 ):
assert pokerhand._is_five_high_straight() == expected
assert pokerhand._card_values == expected_card_values
def a__ ( ):
'''simple docstring'''
UpperCAmelCase_ =0
UpperCAmelCase_ =os.path.abspath(os.path.dirname(lowercase__ ) )
UpperCAmelCase_ =os.path.join(lowercase__ , "poker_hands.txt" )
with open(lowercase__ ) as file_hand:
for line in file_hand:
UpperCAmelCase_ =line[:1_4].strip()
UpperCAmelCase_ =line[1_5:].strip()
UpperCAmelCase_ , UpperCAmelCase_ =PokerHand(lowercase__ ), PokerHand(lowercase__ )
UpperCAmelCase_ =player.compare_with(lowercase__ )
if output == "Win":
answer += 1
assert answer == 3_7_6
| 54
| 0
|
"""simple docstring"""
import numpy as np
import torch
from torch.nn import CrossEntropyLoss
from transformers import AutoModelForCausalLM, AutoTokenizer
import datasets
from datasets import logging
UpperCAmelCase : str = "\\n\n"
UpperCAmelCase : Tuple = "\nPerplexity (PPL) is one of the most common metrics for evaluating language models.\nIt is defined as the exponentiated average negative log-likelihood of a sequence.\n\nFor more information, see https://huggingface.co/docs/transformers/perplexity\n"
UpperCAmelCase : int = "\nArgs:\n model_id (str): model used for calculating Perplexity\n NOTE: Perplexity can only be calculated for causal language models.\n This includes models such as gpt2, causal variations of bert,\n causal versions of t5, and more (the full list can be found\n in the AutoModelForCausalLM documentation here:\n https://huggingface.co/docs/transformers/master/en/model_doc/auto#transformers.AutoModelForCausalLM )\n\n input_texts (list of str): input text, each separate text snippet\n is one list entry.\n batch_size (int): the batch size to run texts through the model. Defaults to 16.\n add_start_token (bool): whether to add the start token to the texts,\n so the perplexity can include the probability of the first word. Defaults to True.\n device (str): device to run on, defaults to 'cuda' when available\nReturns:\n perplexity: dictionary containing the perplexity scores for the texts\n in the input list, as well as the mean perplexity. If one of the input texts is\n longer than the max input length of the model, then it is truncated to the\n max length for the perplexity computation.\nExamples:\n Example 1:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = [\"lorem ipsum\", \"Happy Birthday!\", \"Bienvenue\"]\n >>> results = perplexity.compute(model_id='gpt2',\n ... add_start_token=False,\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 78.22\n >>> print(round(results[\"perplexities\"][0], 2))\n 11.11\n\n Example 2:\n >>> perplexity = datasets.load_metric(\"perplexity\")\n >>> input_texts = datasets.load_dataset(\"wikitext\",\n ... \"wikitext-2-raw-v1\",\n ... split=\"test\")[\"text\"][:50] # doctest:+ELLIPSIS\n [...]\n >>> input_texts = [s for s in input_texts if s!='']\n >>> results = perplexity.compute(model_id='gpt2',\n ... input_texts=input_texts) # doctest:+ELLIPSIS\n >>> print(list(results.keys()))\n ['perplexities', 'mean_perplexity']\n >>> print(round(results[\"mean_perplexity\"], 2))\n 60.35\n >>> print(round(results[\"perplexities\"][0], 2))\n 81.12\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class SCREAMING_SNAKE_CASE__ ( datasets.Metric ):
def _UpperCAmelCase ( self : List[Any]):
"""simple docstring"""
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(
{
"""input_texts""": datasets.Value("""string"""),
}) , reference_urls=["""https://huggingface.co/docs/transformers/perplexity"""] , )
def _UpperCAmelCase ( self : Tuple , lowerCAmelCase_ : Optional[int] , lowerCAmelCase_ : Any , lowerCAmelCase_ : int = 1_6 , lowerCAmelCase_ : bool = True , lowerCAmelCase_ : Optional[int]=None):
"""simple docstring"""
if device is not None:
assert device in ["gpu", "cpu", "cuda"], "device should be either gpu or cpu."
if device == "gpu":
lowercase_ = """cuda"""
else:
lowercase_ = """cuda""" if torch.cuda.is_available() else """cpu"""
lowercase_ = AutoModelForCausalLM.from_pretrained(lowerCAmelCase_)
lowercase_ = model.to(lowerCAmelCase_)
lowercase_ = AutoTokenizer.from_pretrained(lowerCAmelCase_)
# if batch_size > 1 (which generally leads to padding being required), and
# if there is not an already assigned pad_token, assign an existing
# special token to also be the padding token
if tokenizer.pad_token is None and batch_size > 1:
lowercase_ = list(tokenizer.special_tokens_map_extended.values())
# check that the model already has at least one special token defined
assert (
len(lowerCAmelCase_) > 0
), "If batch_size > 1, model must have at least one special token to use for padding. Please use a different model or set batch_size=1."
# assign one of the special tokens to also be the pad token
tokenizer.add_special_tokens({"""pad_token""": existing_special_tokens[0]})
if add_start_token:
# leave room for <BOS> token to be added:
assert (
tokenizer.bos_token is not None
), "Input model must already have a BOS token if using add_start_token=True. Please use a different model, or set add_start_token=False"
lowercase_ = model.config.max_length - 1
else:
lowercase_ = model.config.max_length
lowercase_ = tokenizer(
lowerCAmelCase_ , add_special_tokens=lowerCAmelCase_ , padding=lowerCAmelCase_ , truncation=lowerCAmelCase_ , max_length=lowerCAmelCase_ , return_tensors="""pt""" , return_attention_mask=lowerCAmelCase_ , ).to(lowerCAmelCase_)
lowercase_ = encodings["""input_ids"""]
lowercase_ = encodings["""attention_mask"""]
# check that each input is long enough:
if add_start_token:
assert torch.all(torch.ge(attn_masks.sum(1) , 1)), "Each input text must be at least one token long."
else:
assert torch.all(
torch.ge(attn_masks.sum(1) , 2)), "When add_start_token=False, each input text must be at least two tokens long. Run with add_start_token=True if inputting strings of only one token, and remove all empty input strings."
lowercase_ = []
lowercase_ = CrossEntropyLoss(reduction="""none""")
for start_index in logging.tqdm(range(0 , len(lowerCAmelCase_) , lowerCAmelCase_)):
lowercase_ = min(start_index + batch_size , len(lowerCAmelCase_))
lowercase_ = encoded_texts[start_index:end_index]
lowercase_ = attn_masks[start_index:end_index]
if add_start_token:
lowercase_ = torch.tensor([[tokenizer.bos_token_id]] * encoded_batch.size(dim=0)).to(lowerCAmelCase_)
lowercase_ = torch.cat([bos_tokens_tensor, encoded_batch] , dim=1)
lowercase_ = torch.cat(
[torch.ones(bos_tokens_tensor.size() , dtype=torch.intaa).to(lowerCAmelCase_), attn_mask] , dim=1)
lowercase_ = encoded_batch
with torch.no_grad():
lowercase_ = model(lowerCAmelCase_ , attention_mask=lowerCAmelCase_).logits
lowercase_ = out_logits[..., :-1, :].contiguous()
lowercase_ = labels[..., 1:].contiguous()
lowercase_ = attn_mask[..., 1:].contiguous()
lowercase_ = torch.expa(
(loss_fct(shift_logits.transpose(1 , 2) , lowerCAmelCase_) * shift_attention_mask_batch).sum(1)
/ shift_attention_mask_batch.sum(1))
ppls += perplexity_batch.tolist()
return {"perplexities": ppls, "mean_perplexity": np.mean(lowerCAmelCase_)}
| 100
|
"""simple docstring"""
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
UpperCAmelCase : List[Any] = logging.get_logger(__name__)
UpperCAmelCase : List[Any] = "▁"
UpperCAmelCase : Union[str, Any] = {"vocab_file": "spiece.model"}
UpperCAmelCase : List[Any] = {
"vocab_file": {
"google/reformer-crime-and-punishment": (
"https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model"
)
}
}
UpperCAmelCase : Optional[Any] = {
"google/reformer-crime-and-punishment": 52_4288,
}
class SCREAMING_SNAKE_CASE__ ( __UpperCAmelCase ):
lowercase__ = VOCAB_FILES_NAMES
lowercase__ = PRETRAINED_VOCAB_FILES_MAP
lowercase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
lowercase__ = ["input_ids", "attention_mask"]
def __init__( self : int , lowerCAmelCase_ : Any , lowerCAmelCase_ : Dict="</s>" , lowerCAmelCase_ : Dict="<unk>" , lowerCAmelCase_ : Dict=[] , lowerCAmelCase_ : Optional[Dict[str, Any]] = None , **lowerCAmelCase_ : List[str] , ):
"""simple docstring"""
lowercase_ = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
eos_token=lowerCAmelCase_ , unk_token=lowerCAmelCase_ , additional_special_tokens=lowerCAmelCase_ , sp_model_kwargs=self.sp_model_kwargs , **lowerCAmelCase_ , )
lowercase_ = vocab_file
lowercase_ = spm.SentencePieceProcessor(**self.sp_model_kwargs)
self.sp_model.Load(lowerCAmelCase_)
@property
def _UpperCAmelCase ( self : List[Any]):
"""simple docstring"""
return self.sp_model.get_piece_size()
def _UpperCAmelCase ( self : Dict):
"""simple docstring"""
lowercase_ = {self.convert_ids_to_tokens(lowerCAmelCase_): i for i in range(self.vocab_size)}
vocab.update(self.added_tokens_encoder)
return vocab
def __getstate__( self : Union[str, Any]):
"""simple docstring"""
lowercase_ = self.__dict__.copy()
lowercase_ = None
return state
def __setstate__( self : Optional[Any] , lowerCAmelCase_ : int):
"""simple docstring"""
lowercase_ = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs"""):
lowercase_ = {}
lowercase_ = spm.SentencePieceProcessor(**self.sp_model_kwargs)
self.sp_model.Load(self.vocab_file)
def _UpperCAmelCase ( self : Union[str, Any] , lowerCAmelCase_ : str):
"""simple docstring"""
return self.sp_model.encode(lowerCAmelCase_ , out_type=lowerCAmelCase_)
def _UpperCAmelCase ( self : Tuple , lowerCAmelCase_ : List[str]):
"""simple docstring"""
return self.sp_model.piece_to_id(lowerCAmelCase_)
def _UpperCAmelCase ( self : str , lowerCAmelCase_ : Any):
"""simple docstring"""
if index < self.sp_model.get_piece_size():
lowercase_ = self.sp_model.IdToPiece(lowerCAmelCase_)
return token
def _UpperCAmelCase ( self : int , lowerCAmelCase_ : Any):
"""simple docstring"""
lowercase_ = []
lowercase_ = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(lowerCAmelCase_) + token
lowercase_ = []
else:
current_sub_tokens.append(lowerCAmelCase_)
out_string += self.sp_model.decode(lowerCAmelCase_)
return out_string.strip()
def _UpperCAmelCase ( self : Optional[int] , lowerCAmelCase_ : str , lowerCAmelCase_ : Optional[str] = None):
"""simple docstring"""
if not os.path.isdir(lowerCAmelCase_):
logger.error(F'''Vocabulary path ({save_directory}) should be a directory''')
return
lowercase_ = os.path.join(
lowerCAmelCase_ , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""])
if os.path.abspath(self.vocab_file) != os.path.abspath(lowerCAmelCase_) and os.path.isfile(self.vocab_file):
copyfile(self.vocab_file , lowerCAmelCase_)
elif not os.path.isfile(self.vocab_file):
with open(lowerCAmelCase_ , """wb""") as fi:
lowercase_ = self.sp_model.serialized_model_proto()
fi.write(lowerCAmelCase_)
return (out_vocab_file,)
| 100
| 1
|
import os
import pytest
from datasets import (
get_dataset_config_info,
get_dataset_config_names,
get_dataset_infos,
get_dataset_split_names,
inspect_dataset,
inspect_metric,
)
lowerCAmelCase_ = pytest.mark.integration
@pytest.mark.parametrize('''path''' , ['''paws''', '''csv'''] )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase ) -> List[str]:
"""simple docstring"""
inspect_dataset(_UpperCamelCase , _UpperCamelCase )
snake_case_ : Optional[Any] = path + '''.py'''
assert script_name in os.listdir(_UpperCamelCase )
assert "__pycache__" not in os.listdir(_UpperCamelCase )
@pytest.mark.filterwarnings('''ignore:inspect_metric is deprecated:FutureWarning''' )
@pytest.mark.filterwarnings('''ignore:metric_module_factory is deprecated:FutureWarning''' )
@pytest.mark.parametrize('''path''' , ['''accuracy'''] )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase ) -> Tuple:
"""simple docstring"""
inspect_metric(_UpperCamelCase , _UpperCamelCase )
snake_case_ : Any = path + '''.py'''
assert script_name in os.listdir(_UpperCamelCase )
assert "__pycache__" not in os.listdir(_UpperCamelCase )
@pytest.mark.parametrize(
'''path, config_name, expected_splits''' , [
('''squad''', '''plain_text''', ['''train''', '''validation''']),
('''dalle-mini/wit''', '''dalle-mini--wit''', ['''train''']),
('''paws''', '''labeled_final''', ['''train''', '''test''', '''validation''']),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Tuple:
"""simple docstring"""
snake_case_ : Dict = get_dataset_config_info(_UpperCamelCase , config_name=_UpperCamelCase )
assert info.config_name == config_name
assert list(info.splits.keys() ) == expected_splits
@pytest.mark.parametrize(
'''path, config_name, expected_exception''' , [
('''paws''', None, ValueError),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any:
"""simple docstring"""
with pytest.raises(_UpperCamelCase ):
get_dataset_config_info(_UpperCamelCase , config_name=_UpperCamelCase )
@pytest.mark.parametrize(
'''path, expected''' , [
('''squad''', '''plain_text'''),
('''acronym_identification''', '''default'''),
('''lhoestq/squad''', '''plain_text'''),
('''lhoestq/test''', '''default'''),
('''lhoestq/demo1''', '''lhoestq--demo1'''),
('''dalle-mini/wit''', '''dalle-mini--wit'''),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase ) -> Optional[Any]:
"""simple docstring"""
snake_case_ : List[str] = get_dataset_config_names(_UpperCamelCase )
assert expected in config_names
@pytest.mark.parametrize(
'''path, expected_configs, expected_splits_in_first_config''' , [
('''squad''', ['''plain_text'''], ['''train''', '''validation''']),
('''dalle-mini/wit''', ['''dalle-mini--wit'''], ['''train''']),
('''paws''', ['''labeled_final''', '''labeled_swap''', '''unlabeled_final'''], ['''train''', '''test''', '''validation''']),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> str:
"""simple docstring"""
snake_case_ : Dict = get_dataset_infos(_UpperCamelCase )
assert list(infos.keys() ) == expected_configs
snake_case_ : List[str] = expected_configs[0]
assert expected_config in infos
snake_case_ : int = infos[expected_config]
assert info.config_name == expected_config
assert list(info.splits.keys() ) == expected_splits_in_first_config
@pytest.mark.parametrize(
'''path, expected_config, expected_splits''' , [
('''squad''', '''plain_text''', ['''train''', '''validation''']),
('''dalle-mini/wit''', '''dalle-mini--wit''', ['''train''']),
('''paws''', '''labeled_final''', ['''train''', '''test''', '''validation''']),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> int:
"""simple docstring"""
snake_case_ : List[str] = get_dataset_infos(_UpperCamelCase )
assert expected_config in infos
snake_case_ : List[str] = infos[expected_config]
assert info.config_name == expected_config
assert list(info.splits.keys() ) == expected_splits
@pytest.mark.parametrize(
'''path, config_name, expected_exception''' , [
('''paws''', None, ValueError),
] , )
def lowerCamelCase_ ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Any:
"""simple docstring"""
with pytest.raises(_UpperCamelCase ):
get_dataset_split_names(_UpperCamelCase , config_name=_UpperCamelCase )
| 60
|
'''simple docstring'''
def __a ( A__ , A__ ) -> int:
return int((input_a, input_a).count(0 ) == 0 )
def __a ( ) -> None:
assert and_gate(0 , 0 ) == 0
assert and_gate(0 , 1 ) == 0
assert and_gate(1 , 0 ) == 0
assert and_gate(1 , 1 ) == 1
if __name__ == "__main__":
test_and_gate()
print(and_gate(1, 0))
print(and_gate(0, 0))
print(and_gate(0, 1))
print(and_gate(1, 1))
| 649
| 0
|
import argparse
import json
from pathlib import Path
import torch
import torchaudio
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
from transformers.utils import logging
logging.set_verbosity_info()
__a = logging.get_logger(__name__)
def _UpperCamelCase ( lowerCAmelCase_ ) ->str:
UpperCAmelCase = ASTConfig()
if "10-10" in model_name:
pass
elif "speech-commands" in model_name:
UpperCAmelCase = 1_2_8
elif "12-12" in model_name:
UpperCAmelCase = 1_2
UpperCAmelCase = 1_2
elif "14-14" in model_name:
UpperCAmelCase = 1_4
UpperCAmelCase = 1_4
elif "16-16" in model_name:
UpperCAmelCase = 1_6
UpperCAmelCase = 1_6
else:
raise ValueError("""Model not supported""" )
UpperCAmelCase = """huggingface/label-files"""
if "speech-commands" in model_name:
UpperCAmelCase = 3_5
UpperCAmelCase = """speech-commands-v2-id2label.json"""
else:
UpperCAmelCase = 5_2_7
UpperCAmelCase = """audioset-id2label.json"""
UpperCAmelCase = json.load(open(hf_hub_download(lowerCAmelCase_ , lowerCAmelCase_ , repo_type="""dataset""" ) , """r""" ) )
UpperCAmelCase = {int(lowerCAmelCase_ ): v for k, v in idalabel.items()}
UpperCAmelCase = idalabel
UpperCAmelCase = {v: k for k, v in idalabel.items()}
return config
def _UpperCamelCase ( lowerCAmelCase_ ) ->Any:
if "module.v" in name:
UpperCAmelCase = name.replace("""module.v""" , """audio_spectrogram_transformer""" )
if "cls_token" in name:
UpperCAmelCase = name.replace("""cls_token""" , """embeddings.cls_token""" )
if "dist_token" in name:
UpperCAmelCase = name.replace("""dist_token""" , """embeddings.distillation_token""" )
if "pos_embed" in name:
UpperCAmelCase = name.replace("""pos_embed""" , """embeddings.position_embeddings""" )
if "patch_embed.proj" in name:
UpperCAmelCase = name.replace("""patch_embed.proj""" , """embeddings.patch_embeddings.projection""" )
# transformer blocks
if "blocks" in name:
UpperCAmelCase = name.replace("""blocks""" , """encoder.layer""" )
if "attn.proj" in name:
UpperCAmelCase = name.replace("""attn.proj""" , """attention.output.dense""" )
if "attn" in name:
UpperCAmelCase = name.replace("""attn""" , """attention.self""" )
if "norm1" in name:
UpperCAmelCase = name.replace("""norm1""" , """layernorm_before""" )
if "norm2" in name:
UpperCAmelCase = name.replace("""norm2""" , """layernorm_after""" )
if "mlp.fc1" in name:
UpperCAmelCase = name.replace("""mlp.fc1""" , """intermediate.dense""" )
if "mlp.fc2" in name:
UpperCAmelCase = name.replace("""mlp.fc2""" , """output.dense""" )
# final layernorm
if "audio_spectrogram_transformer.norm" in name:
UpperCAmelCase = name.replace("""audio_spectrogram_transformer.norm""" , """audio_spectrogram_transformer.layernorm""" )
# classifier head
if "module.mlp_head.0" in name:
UpperCAmelCase = name.replace("""module.mlp_head.0""" , """classifier.layernorm""" )
if "module.mlp_head.1" in name:
UpperCAmelCase = name.replace("""module.mlp_head.1""" , """classifier.dense""" )
return name
def _UpperCamelCase ( lowerCAmelCase_ , lowerCAmelCase_ ) ->str:
for key in orig_state_dict.copy().keys():
UpperCAmelCase = orig_state_dict.pop(lowerCAmelCase_ )
if "qkv" in key:
UpperCAmelCase = key.split(""".""" )
UpperCAmelCase = int(key_split[3] )
UpperCAmelCase = config.hidden_size
if "weight" in key:
UpperCAmelCase = val[:dim, :]
UpperCAmelCase = val[dim : dim * 2, :]
UpperCAmelCase = val[-dim:, :]
else:
UpperCAmelCase = val[:dim]
UpperCAmelCase = val[dim : dim * 2]
UpperCAmelCase = val[-dim:]
else:
UpperCAmelCase = val
return orig_state_dict
def _UpperCamelCase ( lowerCAmelCase_ ) ->Optional[int]:
UpperCAmelCase = [
"""module.v.head.weight""",
"""module.v.head.bias""",
"""module.v.head_dist.weight""",
"""module.v.head_dist.bias""",
]
for k in ignore_keys:
state_dict.pop(lowerCAmelCase_ , lowerCAmelCase_ )
@torch.no_grad()
def _UpperCamelCase ( lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_=False ) ->Optional[int]:
UpperCAmelCase = get_audio_spectrogram_transformer_config(lowerCAmelCase_ )
UpperCAmelCase = {
"""ast-finetuned-audioset-10-10-0.4593""": (
"""https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1"""
),
"""ast-finetuned-audioset-10-10-0.450""": (
"""https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1"""
),
"""ast-finetuned-audioset-10-10-0.448""": (
"""https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1"""
),
"""ast-finetuned-audioset-10-10-0.448-v2""": (
"""https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1"""
),
"""ast-finetuned-audioset-12-12-0.447""": (
"""https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1"""
),
"""ast-finetuned-audioset-14-14-0.443""": (
"""https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1"""
),
"""ast-finetuned-audioset-16-16-0.442""": (
"""https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1"""
),
"""ast-finetuned-speech-commands-v2""": (
"""https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1"""
),
}
# load original state_dict
UpperCAmelCase = model_name_to_url[model_name]
UpperCAmelCase = torch.hub.load_state_dict_from_url(lowerCAmelCase_ , map_location="""cpu""" )
# remove some keys
remove_keys(lowerCAmelCase_ )
# rename some keys
UpperCAmelCase = convert_state_dict(lowerCAmelCase_ , lowerCAmelCase_ )
# load 🤗 model
UpperCAmelCase = ASTForAudioClassification(lowerCAmelCase_ )
model.eval()
model.load_state_dict(lowerCAmelCase_ )
# verify outputs on dummy input
# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
UpperCAmelCase = -4.267_7393 if """speech-commands""" not in model_name else -6.84_5978
UpperCAmelCase = 4.568_9974 if """speech-commands""" not in model_name else 5.565_4526
UpperCAmelCase = 1_0_2_4 if """speech-commands""" not in model_name else 1_2_8
UpperCAmelCase = ASTFeatureExtractor(mean=lowerCAmelCase_ , std=lowerCAmelCase_ , max_length=lowerCAmelCase_ )
if "speech-commands" in model_name:
UpperCAmelCase = load_dataset("""speech_commands""" , """v0.02""" , split="""validation""" )
UpperCAmelCase = dataset[0]["""audio"""]["""array"""]
else:
UpperCAmelCase = hf_hub_download(
repo_id="""nielsr/audio-spectogram-transformer-checkpoint""" , filename="""sample_audio.flac""" , repo_type="""dataset""" , )
UpperCAmelCase , UpperCAmelCase = torchaudio.load(lowerCAmelCase_ )
UpperCAmelCase = waveform.squeeze().numpy()
UpperCAmelCase = feature_extractor(lowerCAmelCase_ , sampling_rate=1_6_0_0_0 , return_tensors="""pt""" )
# forward pass
UpperCAmelCase = model(**lowerCAmelCase_ )
UpperCAmelCase = outputs.logits
if model_name == "ast-finetuned-audioset-10-10-0.4593":
UpperCAmelCase = torch.tensor([-0.8760, -7.0042, -8.6602] )
elif model_name == "ast-finetuned-audioset-10-10-0.450":
UpperCAmelCase = torch.tensor([-1.1986, -7.0903, -8.2718] )
elif model_name == "ast-finetuned-audioset-10-10-0.448":
UpperCAmelCase = torch.tensor([-2.6128, -8.0080, -9.4344] )
elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
UpperCAmelCase = torch.tensor([-1.5080, -7.4534, -8.8917] )
elif model_name == "ast-finetuned-audioset-12-12-0.447":
UpperCAmelCase = torch.tensor([-0.5050, -6.5833, -8.0843] )
elif model_name == "ast-finetuned-audioset-14-14-0.443":
UpperCAmelCase = torch.tensor([-0.3826, -7.0336, -8.2413] )
elif model_name == "ast-finetuned-audioset-16-16-0.442":
UpperCAmelCase = torch.tensor([-1.2113, -6.9101, -8.3470] )
elif model_name == "ast-finetuned-speech-commands-v2":
UpperCAmelCase = torch.tensor([6.1589, -8.0566, -8.7984] )
else:
raise ValueError("""Unknown model name""" )
if not torch.allclose(logits[0, :3] , lowerCAmelCase_ , atol=1e-4 ):
raise ValueError("""Logits don't match""" )
print("""Looks ok!""" )
if pytorch_dump_folder_path is not None:
Path(lowerCAmelCase_ ).mkdir(exist_ok=lowerCAmelCase_ )
print(F"""Saving model {model_name} to {pytorch_dump_folder_path}""" )
model.save_pretrained(lowerCAmelCase_ )
print(F"""Saving feature extractor to {pytorch_dump_folder_path}""" )
feature_extractor.save_pretrained(lowerCAmelCase_ )
if push_to_hub:
print("""Pushing model and feature extractor to the hub...""" )
model.push_to_hub(F"""MIT/{model_name}""" )
feature_extractor.push_to_hub(F"""MIT/{model_name}""" )
if __name__ == "__main__":
__a = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
"""--model_name""",
default="""ast-finetuned-audioset-10-10-0.4593""",
type=str,
help="""Name of the Audio Spectrogram Transformer model you'd like to convert.""",
)
parser.add_argument(
"""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
)
parser.add_argument(
"""--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
)
__a = parser.parse_args()
convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
| 627
|
from math import isqrt
def _UpperCamelCase ( lowerCAmelCase_ ) ->bool:
return all(number % divisor != 0 for divisor in range(2 , isqrt(lowerCAmelCase_ ) + 1 ) )
def _UpperCamelCase ( lowerCAmelCase_ = 1_0**6 ) ->int:
UpperCAmelCase = 0
UpperCAmelCase = 1
UpperCAmelCase = 7
while prime_candidate < max_prime:
primes_count += is_prime(lowerCAmelCase_ )
cube_index += 1
prime_candidate += 6 * cube_index
return primes_count
if __name__ == "__main__":
print(F"""{solution() = }""")
| 627
| 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
UpperCAmelCase_ = """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 SCREAMING_SNAKE_CASE_ ( _snake_case :str , _snake_case :Union[str, Any]=None ) -> Any:
require_version(deps[pkg] , _snake_case )
| 2
|
"""simple docstring"""
from __future__ import annotations
import os
from collections.abc import Mapping
a : Optional[Any] = tuple[int, int]
class lowercase:
def __init__( self , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) -> None:
"""simple docstring"""
a__ = vertices
a__ = {
(min(__SCREAMING_SNAKE_CASE ), max(__SCREAMING_SNAKE_CASE )): weight for edge, weight in edges.items()
}
def lowercase__ ( self , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) -> None:
"""simple docstring"""
self.vertices.add(edge[0] )
self.vertices.add(edge[1] )
a__ = weight
def lowercase__ ( self ) -> Graph:
"""simple docstring"""
a__ = Graph({min(self.vertices )} , {} )
a__ = 42
a__ = 42
a__ = 42
a__ = 42
while len(subgraph.vertices ) < len(self.vertices ):
a__ = max(self.edges.values() ) + 1
for edge, weight in self.edges.items():
if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices):
if weight < min_weight:
a__ = edge
a__ = weight
subgraph.add_edge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )
return subgraph
def __magic_name__ ( UpperCamelCase : str = "p107_network.txt" ) -> int:
a__ = os.path.abspath(os.path.dirname(UpperCamelCase ) )
a__ = os.path.join(UpperCamelCase , UpperCamelCase )
a__ = {}
a__ = 42
a__ = 42
a__ = 42
with open(UpperCamelCase ) as f:
a__ = f.read().strip().split('\n' )
a__ = [line.split(',' ) for line in data]
for edgea in range(1 , len(UpperCamelCase ) ):
for edgea in range(UpperCamelCase ):
if adjaceny_matrix[edgea][edgea] != "-":
a__ = int(adjaceny_matrix[edgea][edgea] )
a__ = Graph(set(range(len(UpperCamelCase ) ) ) , UpperCamelCase )
a__ = graph.prims_algorithm()
a__ = sum(graph.edges.values() )
a__ = sum(subgraph.edges.values() )
return initial_total - optimal_total
if __name__ == "__main__":
print(F'''{solution() = }''')
| 273
| 0
|
# This script creates a super tiny model that is useful inside tests, when we just want to test that
# the machinery works, without needing to the check the quality of the outcomes.
#
# This version creates a tiny vocab first, and then a tiny model - so the outcome is truly tiny -
# all files ~60KB. As compared to taking a full-size model, reducing to the minimum its layers and
# emb dimensions, but keeping the full vocab + merges files, leading to ~3MB in total for all files.
# The latter is done by `fsmt-make-super-tiny-model.py`.
#
# It will be used then as "stas/tiny-wmt19-en-ru"
from pathlib import Path
import json
import tempfile
from transformers import FSMTTokenizer, FSMTConfig, FSMTForConditionalGeneration
from transformers.models.fsmt.tokenization_fsmt import VOCAB_FILES_NAMES
a_ :Dict = 'tiny-wmt19-en-ru'
# Build
# borrowed from a test
a_ :Tuple = [
'l',
'o',
'w',
'e',
'r',
's',
't',
'i',
'd',
'n',
'w</w>',
'r</w>',
't</w>',
'lo',
'low',
'er</w>',
'low</w>',
'lowest</w>',
'newer</w>',
'wider</w>',
'<unk>',
]
a_ :Optional[int] = dict(zip(vocab, range(len(vocab))))
a_ :Optional[int] = ['l o 123', 'lo w 1456', 'e r</w> 1789', '']
with tempfile.TemporaryDirectory() as tmpdirname:
a_ :Optional[int] = Path(tmpdirname)
a_ :Tuple = build_dir / VOCAB_FILES_NAMES['src_vocab_file']
a_ :Any = build_dir / VOCAB_FILES_NAMES['tgt_vocab_file']
a_ :Union[str, Any] = build_dir / VOCAB_FILES_NAMES['merges_file']
with open(src_vocab_file, 'w') as fp:
fp.write(json.dumps(vocab_tokens))
with open(tgt_vocab_file, 'w') as fp:
fp.write(json.dumps(vocab_tokens))
with open(merges_file, 'w') as fp:
fp.write('\n'.join(merges))
a_ :Tuple = FSMTTokenizer(
langs=['en', 'ru'],
src_vocab_size=len(vocab),
tgt_vocab_size=len(vocab),
src_vocab_file=src_vocab_file,
tgt_vocab_file=tgt_vocab_file,
merges_file=merges_file,
)
a_ :int = FSMTConfig(
langs=['ru', 'en'],
src_vocab_size=10_00,
tgt_vocab_size=10_00,
d_model=4,
encoder_layers=1,
decoder_layers=1,
encoder_ffn_dim=4,
decoder_ffn_dim=4,
encoder_attention_heads=1,
decoder_attention_heads=1,
)
a_ :Any = FSMTForConditionalGeneration(config)
print(F'''num of params {tiny_model.num_parameters()}''')
# Test
a_ :List[Any] = tokenizer(['Making tiny model'], return_tensors='pt')
a_ :int = tiny_model(**batch)
print('test output:', len(outputs.logits[0]))
# Save
tiny_model.half() # makes it smaller
tiny_model.save_pretrained(mname_tiny)
tokenizer.save_pretrained(mname_tiny)
print(F'''Generated {mname_tiny}''')
# Upload
# transformers-cli upload tiny-wmt19-en-ru
| 715
|
import argparse
import json
import os
import fairseq
import torch
from torch import nn
from transformers import (
SpeechaTextaConfig,
SpeechaTextaForCausalLM,
SpeechaTextaTokenizer,
SpeechEncoderDecoderConfig,
SpeechEncoderDecoderModel,
WavaVecaConfig,
WavaVecaFeatureExtractor,
WavaVecaModel,
logging,
)
logging.set_verbosity_info()
a_ :int = logging.get_logger(__name__)
a_ :Optional[int] = {
'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',
}
a_ :str = [
'lm_head',
'quantizer.weight_proj',
'quantizer.codevectors',
'project_q',
'project_hid',
]
def a ( A__ , A__ , A__ , A__ , A__ ) -> str:
'''simple docstring'''
for attribute in key.split('''.''' ):
SCREAMING_SNAKE_CASE__ : Optional[int] = getattr(A__ , A__ )
if weight_type is not None:
SCREAMING_SNAKE_CASE__ : str = getattr(A__ , A__ ).shape
else:
SCREAMING_SNAKE_CASE__ : int = 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":
SCREAMING_SNAKE_CASE__ : Dict = value
elif weight_type == "weight_g":
SCREAMING_SNAKE_CASE__ : List[str] = value
elif weight_type == "weight_v":
SCREAMING_SNAKE_CASE__ : List[str] = value
elif weight_type == "bias":
SCREAMING_SNAKE_CASE__ : Union[str, Any] = value
else:
SCREAMING_SNAKE_CASE__ : Any = value
logger.info(f"""{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.""" )
def a ( A__ , A__ ) -> Tuple:
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : List[Any] = []
SCREAMING_SNAKE_CASE__ : Tuple = fairseq_model.state_dict()
SCREAMING_SNAKE_CASE__ : List[Any] = hf_model.feature_extractor
# if encoder has different dim to decoder -> use proj_weight
SCREAMING_SNAKE_CASE__ : Tuple = None
for name, value in fairseq_dict.items():
SCREAMING_SNAKE_CASE__ : int = False
if "conv_layers" in name:
load_conv_layer(
A__ , A__ , A__ , A__ , hf_model.config.feat_extract_norm == '''group''' , )
SCREAMING_SNAKE_CASE__ : Optional[int] = True
elif name.split('''.''' )[0] == "proj":
SCREAMING_SNAKE_CASE__ : Any = fairseq_model.proj
SCREAMING_SNAKE_CASE__ : List[Any] = True
else:
for key, mapped_key in MAPPING.items():
if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]:
SCREAMING_SNAKE_CASE__ : int = True
if "*" in mapped_key:
SCREAMING_SNAKE_CASE__ : Tuple = name.split(A__ )[0].split('''.''' )[-2]
SCREAMING_SNAKE_CASE__ : str = mapped_key.replace('''*''' , A__ )
if "weight_g" in name:
SCREAMING_SNAKE_CASE__ : Union[str, Any] = '''weight_g'''
elif "weight_v" in name:
SCREAMING_SNAKE_CASE__ : Optional[Any] = '''weight_v'''
elif "bias" in name:
SCREAMING_SNAKE_CASE__ : str = '''bias'''
elif "weight" in name:
SCREAMING_SNAKE_CASE__ : Tuple = '''weight'''
else:
SCREAMING_SNAKE_CASE__ : int = None
set_recursively(A__ , A__ , A__ , A__ , A__ )
continue
if not is_used:
unused_weights.append(A__ )
logger.warning(f"""Unused weights: {unused_weights}""" )
return proj_weight
def a ( A__ , A__ , A__ , A__ , A__ ) -> Dict:
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Tuple = full_name.split('''conv_layers.''' )[-1]
SCREAMING_SNAKE_CASE__ : Optional[Any] = name.split('''.''' )
SCREAMING_SNAKE_CASE__ : Dict = int(items[0] )
SCREAMING_SNAKE_CASE__ : Optional[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."""
)
SCREAMING_SNAKE_CASE__ : Tuple = 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."""
)
SCREAMING_SNAKE_CASE__ : 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."
)
SCREAMING_SNAKE_CASE__ : Union[str, 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."""
)
SCREAMING_SNAKE_CASE__ : Optional[int] = value
logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" )
else:
unused_weights.append(A__ )
def a ( A__ ) -> Union[str, Any]:
'''simple docstring'''
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : int = emb.weight.shape
SCREAMING_SNAKE_CASE__ : Dict = nn.Linear(A__ , A__ , bias=A__ )
SCREAMING_SNAKE_CASE__ : Tuple = emb.weight.data
return lin_layer
def a ( A__ ) -> List[Any]:
'''simple docstring'''
with open(A__ , '''r''' , encoding='''utf-8''' ) as f:
SCREAMING_SNAKE_CASE__ : Dict = f.readlines()
SCREAMING_SNAKE_CASE__ : List[str] = [line.split(''' ''' )[0] for line in lines]
SCREAMING_SNAKE_CASE__ : int = len(A__ )
SCREAMING_SNAKE_CASE__ : str = {
'''<s>''': 0,
'''<pad>''': 1,
'''</s>''': 2,
'''<unk>''': 3,
}
vocab_dict.update(dict(zip(A__ , range(4 , num_words + 4 ) ) ) )
return vocab_dict
@torch.no_grad()
def a ( A__ , A__ , A__ , A__ , A__ , A__ , A__ , ) -> List[str]:
'''simple docstring'''
SCREAMING_SNAKE_CASE__ : Any = WavaVecaConfig.from_pretrained(A__ )
SCREAMING_SNAKE_CASE__ : Dict = SpeechaTextaConfig.from_pretrained(
A__ , vocab_size=A__ , decoder_layers=A__ , do_stable_layer_norm=A__ )
SCREAMING_SNAKE_CASE__ : Optional[int] = WavaVecaFeatureExtractor(
feature_size=1 , sampling_rate=1_6_0_0_0 , padding_value=0 , do_normalize=A__ , return_attention_mask=A__ , )
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : int = fairseq.checkpoint_utils.load_model_ensemble_and_task(
[checkpoint_path] , arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} )
SCREAMING_SNAKE_CASE__ : int = model[0].eval()
# set weights for wav2vec2 encoder
SCREAMING_SNAKE_CASE__ : int = WavaVecaModel(A__ )
SCREAMING_SNAKE_CASE__ : int = recursively_load_weights_wavaveca(model.encoder , A__ )
SCREAMING_SNAKE_CASE__ : List[Any] = SpeechaTextaForCausalLM(A__ )
SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Tuple = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() , strict=A__ )
# set output linear layer
unexpected_keys.remove('''embed_out''' )
SCREAMING_SNAKE_CASE__ : Union[str, Any] = nn.Parameter(model.decoder.embed_out.detach() )
# layer norm is init to identity matrix so leaving it is fine
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}""" )
SCREAMING_SNAKE_CASE__ : Optional[int] = SpeechEncoderDecoderModel(encoder=A__ , decoder=A__ )
SCREAMING_SNAKE_CASE__ : Dict = False
# add projection layer
SCREAMING_SNAKE_CASE__ : Optional[int] = nn.Parameter(projection_layer.weight )
SCREAMING_SNAKE_CASE__ : Optional[Any] = nn.Parameter(projection_layer.bias )
SCREAMING_SNAKE_CASE__ : List[str] = create_vocab_dict(A__ )
with open(os.path.join(A__ , '''vocab.json''' ) , '''w''' ) as fp:
json.dump(A__ , A__ )
SCREAMING_SNAKE_CASE__ : Union[str, Any] = SpeechaTextaTokenizer(os.path.join(A__ , '''vocab.json''' ) )
tokenizer.save_pretrained(A__ )
SCREAMING_SNAKE_CASE__ : List[str] = hf_wavavec.config.to_dict()
SCREAMING_SNAKE_CASE__ : Tuple = tokenizer.pad_token_id
SCREAMING_SNAKE_CASE__ : Optional[Any] = tokenizer.bos_token_id
SCREAMING_SNAKE_CASE__ : str = tokenizer.eos_token_id
SCREAMING_SNAKE_CASE__ : List[str] = '''speech_to_text_2'''
SCREAMING_SNAKE_CASE__ : Optional[int] = '''wav2vec2'''
SCREAMING_SNAKE_CASE__ : Optional[Any] = SpeechEncoderDecoderConfig.from_dict(A__ )
hf_wavavec.save_pretrained(A__ )
feature_extractor.save_pretrained(A__ )
if __name__ == "__main__":
a_ :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('--dict_path', default=None, type=str, help='Path to dict of fine-tuned model')
parser.add_argument(
'--encoder_config_path',
default='facebook/wav2vec2-large-lv60',
type=str,
help='Path to hf encoder wav2vec2 checkpoint config',
)
parser.add_argument(
'--decoder_config_path',
default='facebook/s2t-small-mustc-en-fr-st',
type=str,
help='Path to hf decoder s2t checkpoint config',
)
parser.add_argument('--vocab_size', default=1_02_24, type=int, help='Vocab size of decoder')
parser.add_argument('--num_decoder_layers', default=7, type=int, help='Number of decoder layers')
a_ :List[str] = parser.parse_args()
convert_wavaveca_checkpoint(
args.checkpoint_path,
args.pytorch_dump_folder_path,
args.dict_path,
encoder_config_path=args.encoder_config_path,
decoder_config_path=args.decoder_config_path,
vocab_size=args.vocab_size,
num_decoder_layers=args.num_decoder_layers,
)
| 250
| 0
|
import unittest
from transformers.utils.backbone_utils import (
BackboneMixin,
get_aligned_output_features_output_indices,
verify_out_features_out_indices,
)
class SCREAMING_SNAKE_CASE ( unittest.TestCase ):
"""simple docstring"""
def SCREAMING_SNAKE_CASE ( self : List[str] ) -> Tuple:
"""simple docstring"""
__lowerCAmelCase : Any = ["""a""", """b""", """c"""]
# Defaults to last layer if both are None
__lowerCAmelCase ,__lowerCAmelCase : List[Any] = get_aligned_output_features_output_indices(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase )
self.assertEqual(lowerCAmelCase , ["""c"""] )
self.assertEqual(lowerCAmelCase , [2] )
# Out indices set to match out features
__lowerCAmelCase ,__lowerCAmelCase : Any = get_aligned_output_features_output_indices(["""a""", """c"""] , lowerCAmelCase , lowerCAmelCase )
self.assertEqual(lowerCAmelCase , ["""a""", """c"""] )
self.assertEqual(lowerCAmelCase , [0, 2] )
# Out features set to match out indices
__lowerCAmelCase ,__lowerCAmelCase : List[str] = get_aligned_output_features_output_indices(lowerCAmelCase , [0, 2] , lowerCAmelCase )
self.assertEqual(lowerCAmelCase , ["""a""", """c"""] )
self.assertEqual(lowerCAmelCase , [0, 2] )
# Out features selected from negative indices
__lowerCAmelCase ,__lowerCAmelCase : Tuple = get_aligned_output_features_output_indices(lowerCAmelCase , [-3, -1] , lowerCAmelCase )
self.assertEqual(lowerCAmelCase , ["""a""", """c"""] )
self.assertEqual(lowerCAmelCase , [-3, -1] )
def SCREAMING_SNAKE_CASE ( self : Optional[Any] ) -> Tuple:
"""simple docstring"""
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(["""a""", """b"""] , (0, 1) , lowerCAmelCase )
# Out features must be a list
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(("""a""", """b""") , (0, 1) , ["""a""", """b"""] )
# Out features must be a subset of stage names
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(["""a""", """b"""] , (0, 1) , ["""a"""] )
# Out indices must be a list or tuple
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(lowerCAmelCase , 0 , ["""a""", """b"""] )
# Out indices must be a subset of stage names
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(lowerCAmelCase , (0, 1) , ["""a"""] )
# Out features and out indices must be the same length
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(["""a""", """b"""] , (0,) , ["""a""", """b""", """c"""] )
# Out features should match out indices
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(["""a""", """b"""] , (0, 2) , ["""a""", """b""", """c"""] )
# Out features and out indices should be in order
with self.assertRaises(lowerCAmelCase ):
verify_out_features_out_indices(["""b""", """a"""] , (0, 1) , ["""a""", """b"""] )
# Check passes with valid inputs
verify_out_features_out_indices(["""a""", """b""", """d"""] , (0, 1, -1) , ["""a""", """b""", """c""", """d"""] )
def SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Optional[Any]:
"""simple docstring"""
__lowerCAmelCase : List[Any] = BackboneMixin()
__lowerCAmelCase : List[str] = ["""a""", """b""", """c"""]
__lowerCAmelCase : int = ["""a""", """c"""]
__lowerCAmelCase : List[Any] = [0, 2]
# Check that the output features and indices are set correctly
self.assertEqual(backbone.out_features , ["""a""", """c"""] )
self.assertEqual(backbone.out_indices , [0, 2] )
# Check out features and indices are updated correctly
__lowerCAmelCase : Optional[int] = ["""a""", """b"""]
self.assertEqual(backbone.out_features , ["""a""", """b"""] )
self.assertEqual(backbone.out_indices , [0, 1] )
__lowerCAmelCase : Union[str, Any] = [-3, -1]
self.assertEqual(backbone.out_features , ["""a""", """c"""] )
self.assertEqual(backbone.out_indices , [-3, -1] )
| 651
|
from typing import TYPE_CHECKING
from ...utils import _LazyModule
__UpperCAmelCase = {"""tokenization_wav2vec2_phoneme""": ["""Wav2Vec2PhonemeCTCTokenizer"""]}
if TYPE_CHECKING:
from .tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizer
else:
import sys
__UpperCAmelCase = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 651
| 1
|
import webbrowser
from sys import argv
from urllib.parse import parse_qs, quote
import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent
if __name__ == "__main__":
UpperCamelCase__ = "%20".join(argv[1:]) if len(argv) > 1 else quote(str(input("Search: ")))
print("Googling.....")
UpperCamelCase__ = f"""https://www.google.com/search?q={query}&num=100"""
UpperCamelCase__ = requests.get(
url,
headers={"User-Agent": str(UserAgent().random)},
)
try:
UpperCamelCase__ = (
BeautifulSoup(res.text, "html.parser")
.find("div", attrs={"class": "yuRUbf"})
.find("a")
.get("href")
)
except AttributeError:
UpperCamelCase__ = parse_qs(
BeautifulSoup(res.text, "html.parser")
.find("div", attrs={"class": "kCrYT"})
.find("a")
.get("href")
)["url"][0]
webbrowser.open(link)
| 708
|
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
UpperCamelCase__ = "▁"
UpperCamelCase__ = {"vocab_file": "spiece.model"}
UpperCamelCase__ = {
"vocab_file": {"google/pegasus-xsum": "https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"}
}
UpperCamelCase__ = {
"google/pegasus-xsum": 512,
}
UpperCamelCase__ = logging.get_logger(__name__)
class __SCREAMING_SNAKE_CASE ( _a ):
snake_case : Union[str, Any] = VOCAB_FILES_NAMES
snake_case : str = VOCAB_FILES_NAMES
snake_case : Any = PRETRAINED_VOCAB_FILES_MAP
snake_case : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
snake_case : Optional[int] = ["""input_ids""", """attention_mask"""]
def __init__( self , __lowerCAmelCase , __lowerCAmelCase="<pad>" , __lowerCAmelCase="</s>" , __lowerCAmelCase="<unk>" , __lowerCAmelCase="<mask_2>" , __lowerCAmelCase="<mask_1>" , __lowerCAmelCase=None , __lowerCAmelCase=103 , __lowerCAmelCase = None , **__lowerCAmelCase , ):
UpperCamelCase__ = offset
if additional_special_tokens is not None:
if not isinstance(__lowerCAmelCase , __lowerCAmelCase ):
raise TypeError(
f"""additional_special_tokens should be of type {type(__lowerCAmelCase )}, but is"""
f""" {type(__lowerCAmelCase )}""" )
UpperCamelCase__ = (
([mask_token_sent] + additional_special_tokens)
if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
else additional_special_tokens
)
# fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
additional_special_tokens_extended += [
f"""<unk_{i}>""" for i in range(len(__lowerCAmelCase ) , self.offset - 1 )
]
if len(set(__lowerCAmelCase ) ) != len(__lowerCAmelCase ):
raise ValueError(
"""Please make sure that the provided additional_special_tokens do not contain an incorrectly"""
f""" shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.""" )
UpperCamelCase__ = additional_special_tokens_extended
else:
UpperCamelCase__ = [mask_token_sent] if mask_token_sent is not None else []
additional_special_tokens += [f"""<unk_{i}>""" for i in range(2 , self.offset )]
UpperCamelCase__ = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
eos_token=__lowerCAmelCase , unk_token=__lowerCAmelCase , mask_token=__lowerCAmelCase , pad_token=__lowerCAmelCase , mask_token_sent=__lowerCAmelCase , offset=__lowerCAmelCase , additional_special_tokens=__lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **__lowerCAmelCase , )
UpperCamelCase__ = mask_token_sent
UpperCamelCase__ = vocab_file
UpperCamelCase__ = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(__lowerCAmelCase )
# add special tokens to encoder dict
UpperCamelCase__ = {
0: self.pad_token,
1: self.eos_token,
}
if self.mask_token_sent is not None:
self.encoder.update(
{
2: self.mask_token_sent,
3: self.mask_token,
} )
if self.offset > 0:
# entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
# mask_token_sent is already added to list -> so start at 1
self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1 , self.offset - 1 )} )
UpperCamelCase__ = {v: k for k, v in self.encoder.items()}
@property
def _lowerCamelCase ( self ):
return len(self.sp_model ) + self.offset
def _lowerCamelCase ( self ):
UpperCamelCase__ = {self.convert_ids_to_tokens(__lowerCAmelCase ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __getstate__( self ):
UpperCamelCase__ = self.__dict__.copy()
UpperCamelCase__ = None
return state
def __setstate__( self , __lowerCAmelCase ):
UpperCamelCase__ = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs""" ):
UpperCamelCase__ = {}
UpperCamelCase__ = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def _lowerCamelCase ( self , __lowerCAmelCase ):
return self.sp_model.encode(__lowerCAmelCase , out_type=__lowerCAmelCase )
def _lowerCamelCase ( self , __lowerCAmelCase ):
if token in self.decoder:
return self.decoder[token]
elif token in self.added_tokens_decoder:
return self.added_tokens_decoder[token]
UpperCamelCase__ = self.sp_model.piece_to_id(__lowerCAmelCase )
return sp_id + self.offset
def _lowerCamelCase ( self , __lowerCAmelCase ):
if index in self.encoder:
return self.encoder[index]
elif index in self.added_tokens_encoder:
return self.added_tokens_encoder[index]
else:
UpperCamelCase__ = self.sp_model.IdToPiece(index - self.offset )
return token
def _lowerCamelCase ( self , __lowerCAmelCase ):
UpperCamelCase__ = []
UpperCamelCase__ = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(__lowerCAmelCase ) + token
UpperCamelCase__ = []
else:
current_sub_tokens.append(__lowerCAmelCase )
out_string += self.sp_model.decode(__lowerCAmelCase )
return out_string.strip()
def _lowerCamelCase ( self , __lowerCAmelCase=False ):
return 1
def _lowerCamelCase ( self , __lowerCAmelCase ):
UpperCamelCase__ = set(self.all_special_ids ) # call it once instead of inside list comp
all_special_ids.remove(self.unk_token_id ) # <unk> is only sometimes special
return [1 if x in all_special_ids else 0 for x in seq]
def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase = None , __lowerCAmelCase = False ):
if already_has_special_tokens:
return self._special_token_mask(__lowerCAmelCase )
elif token_ids_a is None:
return self._special_token_mask(__lowerCAmelCase ) + [1]
else:
return self._special_token_mask(token_ids_a + token_ids_a ) + [1]
def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase=None ):
if token_ids_a is None:
return token_ids_a + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_a + token_ids_a + [self.eos_token_id]
def _lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase = None ):
if not os.path.isdir(__lowerCAmelCase ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
UpperCamelCase__ = os.path.join(
__lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(__lowerCAmelCase ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , __lowerCAmelCase )
elif not os.path.isfile(self.vocab_file ):
with open(__lowerCAmelCase , """wb""" ) as fi:
UpperCamelCase__ = self.sp_model.serialized_model_proto()
fi.write(__lowerCAmelCase )
return (out_vocab_file,)
| 548
| 0
|
import math
def _SCREAMING_SNAKE_CASE ( SCREAMING_SNAKE_CASE :str ) -> bool:
if 1 < number < 4:
# 2 and 3 are primes
return True
elif number < 2 or number % 2 == 0 or number % 3 == 0:
# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
return False
# All primes number are in format of 6k +/- 1
for i in range(5 , int(math.sqrt(__SCREAMING_SNAKE_CASE ) + 1 ) , 6 ):
if number % i == 0 or number % (i + 2) == 0:
return False
return True
def _SCREAMING_SNAKE_CASE ( SCREAMING_SNAKE_CASE :Union[str, Any] = 0.1 ) -> int:
__lowerCAmelCase : Optional[int] = 3
__lowerCAmelCase : Dict = 3
while primes / (2 * j - 1) >= ratio:
for i in range(j * j + j + 1 , (j + 2) * (j + 2) , j + 1 ):
primes += is_prime(__SCREAMING_SNAKE_CASE )
j += 2
return j
if __name__ == "__main__":
import doctest
doctest.testmod()
| 504
|
"""simple docstring"""
import mpmath # for roots of unity
import numpy as np
class _snake_case :
"""simple docstring"""
def __init__( self : Any , _A : Optional[int]=None , _A : int=None):
"""simple docstring"""
_SCREAMING_SNAKE_CASE : Optional[int] = list(poly_a or [0])[:]
_SCREAMING_SNAKE_CASE : Optional[Any] = list(poly_b or [0])[:]
# Remove leading zero coefficients
while self.polyA[-1] == 0:
self.polyA.pop()
_SCREAMING_SNAKE_CASE : Optional[int] = len(self.polyA)
while self.polyB[-1] == 0:
self.polyB.pop()
_SCREAMING_SNAKE_CASE : str = len(self.polyB)
# Add 0 to make lengths equal a power of 2
_SCREAMING_SNAKE_CASE : Optional[Any] = int(
2 ** np.ceil(np.loga(len(self.polyA) + len(self.polyB) - 1)))
while len(self.polyA) < self.c_max_length:
self.polyA.append(0)
while len(self.polyB) < self.c_max_length:
self.polyB.append(0)
# A complex root used for the fourier transform
_SCREAMING_SNAKE_CASE : Optional[Any] = complex(mpmath.root(x=1 , n=self.c_max_length , k=1))
# The product
_SCREAMING_SNAKE_CASE : List[Any] = self.__multiply()
def _lowerCAmelCase ( self : List[str] , _A : Dict):
"""simple docstring"""
_SCREAMING_SNAKE_CASE : Union[str, Any] = [[x] for x in self.polyA] if which == """A""" else [[x] for x in self.polyB]
# Corner case
if len(_A) <= 1:
return dft[0]
#
_SCREAMING_SNAKE_CASE : int = self.c_max_length // 2
while next_ncol > 0:
_SCREAMING_SNAKE_CASE : Union[str, Any] = [[] for i in range(_A)]
_SCREAMING_SNAKE_CASE : Any = self.root**next_ncol
# First half of next step
_SCREAMING_SNAKE_CASE : Union[str, Any] = 1
for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(_A):
new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j])
current_root *= root
# Second half of next step
_SCREAMING_SNAKE_CASE : Optional[int] = 1
for j in range(self.c_max_length // (next_ncol * 2)):
for i in range(_A):
new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j])
current_root *= root
# Update
_SCREAMING_SNAKE_CASE : Optional[int] = new_dft
_SCREAMING_SNAKE_CASE : List[str] = next_ncol // 2
return dft[0]
def _lowerCAmelCase ( self : Any):
"""simple docstring"""
_SCREAMING_SNAKE_CASE : Tuple = self.__dft("""A""")
_SCREAMING_SNAKE_CASE : Any = self.__dft("""B""")
_SCREAMING_SNAKE_CASE : List[Any] = [[dft_a[i] * dft_b[i] for i in range(self.c_max_length)]]
del dft_a
del dft_b
# Corner Case
if len(inverce_c[0]) <= 1:
return inverce_c[0]
# Inverse DFT
_SCREAMING_SNAKE_CASE : Any = 2
while next_ncol <= self.c_max_length:
_SCREAMING_SNAKE_CASE : int = [[] for i in range(_A)]
_SCREAMING_SNAKE_CASE : List[str] = self.root ** (next_ncol // 2)
_SCREAMING_SNAKE_CASE : Union[str, Any] = 1
# First half of next step
for j in range(self.c_max_length // next_ncol):
for i in range(next_ncol // 2):
# Even positions
new_inverse_c[i].append(
(
inverce_c[i][j]
+ inverce_c[i][j + self.c_max_length // next_ncol]
)
/ 2)
# Odd positions
new_inverse_c[i + next_ncol // 2].append(
(
inverce_c[i][j]
- inverce_c[i][j + self.c_max_length // next_ncol]
)
/ (2 * current_root))
current_root *= root
# Update
_SCREAMING_SNAKE_CASE : str = new_inverse_c
next_ncol *= 2
# Unpack
_SCREAMING_SNAKE_CASE : List[Any] = [round(x[0].real , 8) + round(x[0].imag , 8) * 1j for x in inverce_c]
# Remove leading 0's
while inverce_c[-1] == 0:
inverce_c.pop()
return inverce_c
def __str__( self : List[Any]):
"""simple docstring"""
_SCREAMING_SNAKE_CASE : Union[str, Any] = """A = """ + """ + """.join(
f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyA[: self.len_A]))
_SCREAMING_SNAKE_CASE : Optional[int] = """B = """ + """ + """.join(
f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyB[: self.len_B]))
_SCREAMING_SNAKE_CASE : Tuple = """A*B = """ + """ + """.join(
f"""{coef}*x^{i}""" for coef, i in enumerate(self.product))
return f"""{a}\n{b}\n{c}"""
# Unit tests
if __name__ == "__main__":
import doctest
doctest.testmod()
| 338
| 0
|
import unittest
import torch
from torch import nn
from diffusers.models.activations import get_activation
class _lowerCamelCase( unittest.TestCase ):
def UpperCamelCase ( self) -> Dict:
"""simple docstring"""
_lowercase : int = get_activation('swish')
self.assertIsInstance(__snake_case, nn.SiLU)
self.assertEqual(act(torch.tensor(-1_00, dtype=torch.floataa)).item(), 0)
self.assertNotEqual(act(torch.tensor(-1, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(0, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(20, dtype=torch.floataa)).item(), 20)
def UpperCamelCase ( self) -> str:
"""simple docstring"""
_lowercase : Optional[Any] = get_activation('silu')
self.assertIsInstance(__snake_case, nn.SiLU)
self.assertEqual(act(torch.tensor(-1_00, dtype=torch.floataa)).item(), 0)
self.assertNotEqual(act(torch.tensor(-1, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(0, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(20, dtype=torch.floataa)).item(), 20)
def UpperCamelCase ( self) -> Optional[Any]:
"""simple docstring"""
_lowercase : Dict = get_activation('mish')
self.assertIsInstance(__snake_case, nn.Mish)
self.assertEqual(act(torch.tensor(-2_00, dtype=torch.floataa)).item(), 0)
self.assertNotEqual(act(torch.tensor(-1, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(0, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(20, dtype=torch.floataa)).item(), 20)
def UpperCamelCase ( self) -> int:
"""simple docstring"""
_lowercase : Union[str, Any] = get_activation('gelu')
self.assertIsInstance(__snake_case, nn.GELU)
self.assertEqual(act(torch.tensor(-1_00, dtype=torch.floataa)).item(), 0)
self.assertNotEqual(act(torch.tensor(-1, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(0, dtype=torch.floataa)).item(), 0)
self.assertEqual(act(torch.tensor(20, dtype=torch.floataa)).item(), 20)
| 705
|
import unittest
from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
if is_torch_available():
import torch
from transformers import (
MraForMaskedLM,
MraForMultipleChoice,
MraForQuestionAnswering,
MraForSequenceClassification,
MraForTokenClassification,
MraModel,
)
from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST
class _lowerCamelCase:
def __init__( self, lowerCamelCase, lowerCamelCase=2, lowerCamelCase=8, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=16, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=36, lowerCamelCase="gelu", lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, ) -> Dict:
"""simple docstring"""
_lowercase : Union[str, Any] = parent
_lowercase : List[str] = batch_size
_lowercase : Dict = seq_length
_lowercase : List[str] = is_training
_lowercase : Any = use_input_mask
_lowercase : Any = use_token_type_ids
_lowercase : Optional[int] = use_labels
_lowercase : str = vocab_size
_lowercase : str = hidden_size
_lowercase : str = num_hidden_layers
_lowercase : List[Any] = num_attention_heads
_lowercase : Union[str, Any] = intermediate_size
_lowercase : Tuple = hidden_act
_lowercase : Optional[int] = hidden_dropout_prob
_lowercase : Optional[Any] = attention_probs_dropout_prob
_lowercase : int = max_position_embeddings
_lowercase : str = type_vocab_size
_lowercase : Tuple = type_sequence_label_size
_lowercase : Optional[Any] = initializer_range
_lowercase : Dict = num_labels
_lowercase : Dict = num_choices
_lowercase : int = scope
def UpperCamelCase ( self) -> Tuple:
"""simple docstring"""
_lowercase : str = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
_lowercase : List[Any] = None
if self.use_input_mask:
_lowercase : List[str] = random_attention_mask([self.batch_size, self.seq_length])
_lowercase : List[Any] = None
if self.use_token_type_ids:
_lowercase : Dict = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size)
_lowercase : Optional[Any] = None
_lowercase : Optional[int] = None
_lowercase : Dict = None
if self.use_labels:
_lowercase : Tuple = ids_tensor([self.batch_size], self.type_sequence_label_size)
_lowercase : Tuple = ids_tensor([self.batch_size, self.seq_length], self.num_labels)
_lowercase : Tuple = ids_tensor([self.batch_size], self.num_choices)
_lowercase : Optional[int] = self.get_config()
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def UpperCamelCase ( self) -> int:
"""simple docstring"""
return MraConfig(
vocab_size=self.vocab_size, hidden_size=self.hidden_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, type_vocab_size=self.type_vocab_size, is_decoder=lowerCamelCase, initializer_range=self.initializer_range, )
def UpperCamelCase ( self) -> Union[str, Any]:
"""simple docstring"""
_lowercase : Any = self.get_config()
_lowercase : List[str] = 3_00
return config
def UpperCamelCase ( self) -> int:
"""simple docstring"""
(
(
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) ,
) : List[str] = self.prepare_config_and_inputs()
_lowercase : Tuple = True
_lowercase : Any = floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
_lowercase : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length], vocab_size=2)
return (
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
encoder_hidden_states,
encoder_attention_mask,
)
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]:
"""simple docstring"""
_lowercase : Dict = MraModel(config=lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : Dict = model(lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase)
_lowercase : Optional[Any] = model(lowerCamelCase, token_type_ids=lowerCamelCase)
_lowercase : Tuple = model(lowerCamelCase)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> Optional[Any]:
"""simple docstring"""
_lowercase : int = True
_lowercase : List[Any] = MraModel(lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : Tuple = model(
lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, encoder_hidden_states=lowerCamelCase, encoder_attention_mask=lowerCamelCase, )
_lowercase : Union[str, Any] = model(
lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, encoder_hidden_states=lowerCamelCase, )
_lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase)
self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[str]:
"""simple docstring"""
_lowercase : Optional[Any] = MraForMaskedLM(config=lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : int = model(lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, labels=lowerCamelCase)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any:
"""simple docstring"""
_lowercase : Optional[Any] = MraForQuestionAnswering(config=lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : Union[str, Any] = model(
lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase, )
self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length))
self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str:
"""simple docstring"""
_lowercase : str = self.num_labels
_lowercase : List[Any] = MraForSequenceClassification(lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : Optional[int] = model(lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, labels=lowerCamelCase)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str:
"""simple docstring"""
_lowercase : Optional[Any] = self.num_labels
_lowercase : str = MraForTokenClassification(config=lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : Optional[int] = model(lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, labels=lowerCamelCase)
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels))
def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int:
"""simple docstring"""
_lowercase : Any = self.num_choices
_lowercase : Optional[Any] = MraForMultipleChoice(config=lowerCamelCase)
model.to(lowerCamelCase)
model.eval()
_lowercase : List[Any] = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous()
_lowercase : str = token_type_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous()
_lowercase : Dict = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous()
_lowercase : Dict = model(
lowerCamelCase, attention_mask=lowerCamelCase, token_type_ids=lowerCamelCase, labels=lowerCamelCase, )
self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices))
def UpperCamelCase ( self) -> Dict:
"""simple docstring"""
_lowercase : List[Any] = self.prepare_config_and_inputs()
(
(
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) ,
) : Tuple = config_and_inputs
_lowercase : Optional[Any] = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
return config, inputs_dict
@require_torch
class _lowerCamelCase( _a, unittest.TestCase ):
lowercase_ : Optional[int] = (
(
MraModel,
MraForMaskedLM,
MraForMultipleChoice,
MraForQuestionAnswering,
MraForSequenceClassification,
MraForTokenClassification,
)
if is_torch_available()
else ()
)
lowercase_ : Optional[int] = False
lowercase_ : Optional[int] = False
lowercase_ : int = False
lowercase_ : Optional[Any] = False
lowercase_ : Any = ()
def UpperCamelCase ( self) -> Optional[Any]:
"""simple docstring"""
_lowercase : List[str] = MraModelTester(self)
_lowercase : Any = ConfigTester(self, config_class=lowerCamelCase, hidden_size=37)
def UpperCamelCase ( self) -> int:
"""simple docstring"""
self.config_tester.run_common_tests()
def UpperCamelCase ( self) -> int:
"""simple docstring"""
_lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowerCamelCase)
def UpperCamelCase ( self) -> List[Any]:
"""simple docstring"""
_lowercase : Tuple = self.model_tester.prepare_config_and_inputs()
for type in ["absolute", "relative_key", "relative_key_query"]:
_lowercase : Optional[int] = type
self.model_tester.create_and_check_model(*lowerCamelCase)
def UpperCamelCase ( self) -> List[Any]:
"""simple docstring"""
_lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase)
def UpperCamelCase ( self) -> List[str]:
"""simple docstring"""
_lowercase : int = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase)
def UpperCamelCase ( self) -> Any:
"""simple docstring"""
_lowercase : Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*lowerCamelCase)
def UpperCamelCase ( self) -> Tuple:
"""simple docstring"""
_lowercase : List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase)
def UpperCamelCase ( self) -> Tuple:
"""simple docstring"""
_lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*lowerCamelCase)
@slow
def UpperCamelCase ( self) -> str:
"""simple docstring"""
for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
_lowercase : List[str] = MraModel.from_pretrained(lowerCamelCase)
self.assertIsNotNone(lowerCamelCase)
@unittest.skip(reason='MRA does not output attentions')
def UpperCamelCase ( self) -> Tuple:
"""simple docstring"""
return
@require_torch
class _lowerCamelCase( unittest.TestCase ):
@slow
def UpperCamelCase ( self) -> List[str]:
"""simple docstring"""
_lowercase : Dict = MraModel.from_pretrained('uw-madison/mra-base-512-4')
_lowercase : Any = torch.arange(2_56).unsqueeze(0)
with torch.no_grad():
_lowercase : str = model(lowerCamelCase)[0]
_lowercase : Union[str, Any] = torch.Size((1, 2_56, 7_68))
self.assertEqual(output.shape, lowerCamelCase)
_lowercase : Dict = torch.tensor(
[[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]])
self.assertTrue(torch.allclose(output[:, :3, :3], lowerCamelCase, atol=1E-4))
@slow
def UpperCamelCase ( self) -> List[str]:
"""simple docstring"""
_lowercase : List[str] = MraForMaskedLM.from_pretrained('uw-madison/mra-base-512-4')
_lowercase : Optional[int] = torch.arange(2_56).unsqueeze(0)
with torch.no_grad():
_lowercase : str = model(lowerCamelCase)[0]
_lowercase : Union[str, Any] = 5_02_65
_lowercase : int = torch.Size((1, 2_56, vocab_size))
self.assertEqual(output.shape, lowerCamelCase)
_lowercase : Optional[Any] = torch.tensor(
[[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]])
self.assertTrue(torch.allclose(output[:, :3, :3], lowerCamelCase, atol=1E-4))
@slow
def UpperCamelCase ( self) -> str:
"""simple docstring"""
_lowercase : Any = MraForMaskedLM.from_pretrained('uw-madison/mra-base-4096-8-d3')
_lowercase : Optional[int] = torch.arange(40_96).unsqueeze(0)
with torch.no_grad():
_lowercase : str = model(lowerCamelCase)[0]
_lowercase : Optional[Any] = 5_02_65
_lowercase : Union[str, Any] = torch.Size((1, 40_96, vocab_size))
self.assertEqual(output.shape, lowerCamelCase)
_lowercase : Any = torch.tensor(
[[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]])
self.assertTrue(torch.allclose(output[:, :3, :3], lowerCamelCase, atol=1E-4))
| 354
| 0
|
'''simple docstring'''
import math
A = 10
A = 7
A = BALLS_PER_COLOUR * NUM_COLOURS
def SCREAMING_SNAKE_CASE ( lowerCAmelCase__ : int = 20) -> str:
'''simple docstring'''
_lowercase : Union[str, Any] = math.comb(lowerCAmelCase__ , lowerCAmelCase__)
_lowercase : Tuple = math.comb(NUM_BALLS - BALLS_PER_COLOUR , lowerCAmelCase__)
_lowercase : List[str] = NUM_COLOURS * (1 - missing_colour / total)
return F'''{result:.9f}'''
if __name__ == "__main__":
print(solution(20))
| 125
|
'''simple docstring'''
import gc
import random
import unittest
import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
from diffusers import (
AutoencoderKL,
DiffusionPipeline,
EulerDiscreteScheduler,
StableDiffusionXLImgaImgPipeline,
UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
from ..pipeline_params import (
IMAGE_TO_IMAGE_IMAGE_PARAMS,
TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin
enable_full_determinism()
class __SCREAMING_SNAKE_CASE ( lowerCAmelCase__ , lowerCAmelCase__ , unittest.TestCase ):
'''simple docstring'''
lowerCAmelCase__ : List[str] = StableDiffusionXLImgaImgPipeline
lowerCAmelCase__ : str = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"}
lowerCAmelCase__ : List[str] = PipelineTesterMixin.required_optional_params - {"latents"}
lowerCAmelCase__ : List[str] = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
lowerCAmelCase__ : int = IMAGE_TO_IMAGE_IMAGE_PARAMS
lowerCAmelCase__ : int = IMAGE_TO_IMAGE_IMAGE_PARAMS
def _lowerCamelCase ( self : str ) -> Union[str, Any]:
torch.manual_seed(0 )
_lowercase : int = UNetaDConditionModel(
block_out_channels=(32, 64) ,layers_per_block=2 ,sample_size=32 ,in_channels=4 ,out_channels=4 ,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') ,up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') ,attention_head_dim=(2, 4) ,use_linear_projection=UpperCamelCase ,addition_embed_type='text_time' ,addition_time_embed_dim=8 ,transformer_layers_per_block=(1, 2) ,projection_class_embeddings_input_dim=80 ,cross_attention_dim=64 ,)
_lowercase : List[Any] = EulerDiscreteScheduler(
beta_start=0.0_0_0_8_5 ,beta_end=0.0_1_2 ,steps_offset=1 ,beta_schedule='scaled_linear' ,timestep_spacing='leading' ,)
torch.manual_seed(0 )
_lowercase : int = AutoencoderKL(
block_out_channels=[32, 64] ,in_channels=3 ,out_channels=3 ,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] ,up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] ,latent_channels=4 ,sample_size=128 ,)
torch.manual_seed(0 )
_lowercase : int = CLIPTextConfig(
bos_token_id=0 ,eos_token_id=2 ,hidden_size=32 ,intermediate_size=37 ,layer_norm_eps=1e-05 ,num_attention_heads=4 ,num_hidden_layers=5 ,pad_token_id=1 ,vocab_size=1000 ,hidden_act='gelu' ,projection_dim=32 ,)
_lowercase : Optional[int] = CLIPTextModel(UpperCamelCase )
_lowercase : Optional[Any] = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ,local_files_only=UpperCamelCase )
_lowercase : Optional[int] = CLIPTextModelWithProjection(UpperCamelCase )
_lowercase : Union[str, Any] = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ,local_files_only=UpperCamelCase )
_lowercase : Tuple = {
'unet': unet,
'scheduler': scheduler,
'vae': vae,
'text_encoder': text_encoder,
'tokenizer': tokenizer,
'text_encoder_2': text_encoder_a,
'tokenizer_2': tokenizer_a,
# "safety_checker": None,
# "feature_extractor": None,
}
return components
def _lowerCamelCase ( self : Union[str, Any] ,UpperCamelCase : Union[str, Any] ,UpperCamelCase : Tuple=0 ) -> str:
_lowercase : Union[str, Any] = floats_tensor((1, 3, 32, 32) ,rng=random.Random(UpperCamelCase ) ).to(UpperCamelCase )
_lowercase : Optional[int] = image / 2 + 0.5
if str(UpperCamelCase ).startswith('mps' ):
_lowercase : List[Any] = torch.manual_seed(UpperCamelCase )
else:
_lowercase : Union[str, Any] = torch.Generator(device=UpperCamelCase ).manual_seed(UpperCamelCase )
_lowercase : List[Any] = {
'prompt': 'A painting of a squirrel eating a burger',
'image': image,
'generator': generator,
'num_inference_steps': 2,
'guidance_scale': 5.0,
'output_type': 'numpy',
'strength': 0.7_5,
}
return inputs
def _lowerCamelCase ( self : List[Any] ) -> Any:
_lowercase : Dict = 'cpu' # ensure determinism for the device-dependent torch.Generator
_lowercase : int = self.get_dummy_components()
_lowercase : Dict = StableDiffusionXLImgaImgPipeline(**UpperCamelCase )
_lowercase : Optional[Any] = sd_pipe.to(UpperCamelCase )
sd_pipe.set_progress_bar_config(disable=UpperCamelCase )
_lowercase : Union[str, Any] = self.get_dummy_inputs(UpperCamelCase )
_lowercase : Optional[int] = sd_pipe(**UpperCamelCase ).images
_lowercase : Any = image[0, -3:, -3:, -1]
assert image.shape == (1, 32, 32, 3)
_lowercase : Optional[int] = np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
def _lowerCamelCase ( self : Tuple ) -> List[Any]:
super().test_attention_slicing_forward_pass(expected_max_diff=3e-3 )
def _lowerCamelCase ( self : List[Any] ) -> List[Any]:
super().test_inference_batch_single_identical(expected_max_diff=3e-3 )
def _lowerCamelCase ( self : List[Any] ) -> List[str]:
pass
def _lowerCamelCase ( self : List[Any] ) -> List[Any]:
_lowercase : Optional[Any] = self.get_dummy_components()
_lowercase : List[Any] = StableDiffusionXLImgaImgPipeline(**UpperCamelCase )
_lowercase : int = sd_pipe.to(UpperCamelCase )
_lowercase : Any = sd_pipe.to(UpperCamelCase )
sd_pipe.set_progress_bar_config(disable=UpperCamelCase )
# forward without prompt embeds
_lowercase : List[str] = self.get_dummy_inputs(UpperCamelCase )
_lowercase : Optional[int] = 3 * ['this is a negative prompt']
_lowercase : Optional[int] = negative_prompt
_lowercase : List[Any] = 3 * [inputs['prompt']]
_lowercase : Union[str, Any] = sd_pipe(**UpperCamelCase )
_lowercase : Union[str, Any] = output.images[0, -3:, -3:, -1]
# forward with prompt embeds
_lowercase : Tuple = self.get_dummy_inputs(UpperCamelCase )
_lowercase : Optional[Any] = 3 * ['this is a negative prompt']
_lowercase : str = 3 * [inputs.pop('prompt' )]
(
(
_lowercase
) , (
_lowercase
) , (
_lowercase
) , (
_lowercase
) ,
) : Optional[Any] = sd_pipe.encode_prompt(UpperCamelCase ,negative_prompt=UpperCamelCase )
_lowercase : List[str] = sd_pipe(
**UpperCamelCase ,prompt_embeds=UpperCamelCase ,negative_prompt_embeds=UpperCamelCase ,pooled_prompt_embeds=UpperCamelCase ,negative_pooled_prompt_embeds=UpperCamelCase ,)
_lowercase : List[Any] = output.images[0, -3:, -3:, -1]
# make sure that it's equal
assert np.abs(image_slice_a.flatten() - image_slice_a.flatten() ).max() < 1e-4
@slow
@require_torch_gpu
class __SCREAMING_SNAKE_CASE ( unittest.TestCase ):
'''simple docstring'''
def _lowerCamelCase ( self : Dict ) -> Optional[int]:
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def _lowerCamelCase ( self : Tuple ,UpperCamelCase : str ,UpperCamelCase : List[str]="cpu" ,UpperCamelCase : str=torch.floataa ,UpperCamelCase : int=0 ) -> Any:
_lowercase : Optional[int] = torch.Generator(device=UpperCamelCase ).manual_seed(UpperCamelCase )
_lowercase : Tuple = np.random.RandomState(UpperCamelCase ).standard_normal((1, 4, 64, 64) )
_lowercase : str = torch.from_numpy(UpperCamelCase ).to(device=UpperCamelCase ,dtype=UpperCamelCase )
_lowercase : str = {
'prompt': 'a photograph of an astronaut riding a horse',
'latents': latents,
'generator': generator,
'num_inference_steps': 3,
'guidance_scale': 7.5,
'output_type': 'numpy',
}
return inputs
def _lowerCamelCase ( self : Optional[Any] ) -> Tuple:
_lowercase : Dict = DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base' )
pipe.to(UpperCamelCase )
pipe.set_progress_bar_config(disable=UpperCamelCase )
_lowercase : int = self.get_inputs(UpperCamelCase )
_lowercase : str = pipe(**UpperCamelCase ).images
_lowercase : Any = image[0, -3:, -3:, -1].flatten()
assert image.shape == (1, 512, 512, 3)
_lowercase : Dict = np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6] )
assert np.abs(image_slice - expected_slice ).max() < 7e-3
| 125
| 1
|
"""simple docstring"""
from __future__ import annotations
def a_ ( _lowerCAmelCase : list[float] ):
'''simple docstring'''
lowercase__ : str = 0.0_0
lowercase__ : int = 0
for resistor in resistors:
if resistor <= 0:
lowercase__ : Optional[Any] = f"""Resistor at index {index} has a negative or zero value!"""
raise ValueError(_lowerCAmelCase )
first_sum += 1 / float(_lowerCAmelCase )
index += 1
return 1 / first_sum
def a_ ( _lowerCAmelCase : list[float] ):
'''simple docstring'''
lowercase__ : str = 0.0_0
lowercase__ : Any = 0
for resistor in resistors:
sum_r += resistor
if resistor < 0:
lowercase__ : int = f"""Resistor at index {index} has a negative value!"""
raise ValueError(_lowerCAmelCase )
index += 1
return sum_r
if __name__ == "__main__":
import doctest
doctest.testmod()
| 645
|
"""simple docstring"""
import copy
import inspect
import unittest
import numpy as np
from huggingface_hub import hf_hub_download
from transformers import VideoMAEConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from torch import nn
from transformers import (
MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
VideoMAEForPreTraining,
VideoMAEForVideoClassification,
VideoMAEModel,
)
from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
from transformers import VideoMAEImageProcessor
class UpperCAmelCase_ :
def __init__( self , a , a=1_3 , a=1_0 , a=3 , a=2 , a=2 , a=2 , a=True , a=True , a=3_2 , a=5 , a=4 , a=3_7 , a="gelu" , a=0.1 , a=0.1 , a=1_0 , a=0.02 , a=0.9 , a=None , ) -> Optional[Any]:
lowercase__ : str = parent
lowercase__ : int = batch_size
lowercase__ : Union[str, Any] = image_size
lowercase__ : Optional[Any] = num_channels
lowercase__ : Dict = patch_size
lowercase__ : Tuple = tubelet_size
lowercase__ : Optional[int] = num_frames
lowercase__ : Optional[int] = is_training
lowercase__ : int = use_labels
lowercase__ : Optional[int] = hidden_size
lowercase__ : Union[str, Any] = num_hidden_layers
lowercase__ : Optional[int] = num_attention_heads
lowercase__ : Any = intermediate_size
lowercase__ : str = hidden_act
lowercase__ : List[Any] = hidden_dropout_prob
lowercase__ : str = attention_probs_dropout_prob
lowercase__ : Union[str, Any] = type_sequence_label_size
lowercase__ : List[Any] = initializer_range
lowercase__ : str = mask_ratio
lowercase__ : Optional[Any] = scope
# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
lowercase__ : Optional[Any] = (image_size // patch_size) ** 2
lowercase__ : str = (num_frames // tubelet_size) * self.num_patches_per_frame
# use this variable to define bool_masked_pos
lowercase__ : str = int(mask_ratio * self.seq_length )
def _UpperCAmelCase ( self ) -> Tuple:
lowercase__ : int = floats_tensor(
[self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size] )
lowercase__ : int = None
if self.use_labels:
lowercase__ : Optional[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size )
lowercase__ : Dict = self.get_config()
return config, pixel_values, labels
def _UpperCAmelCase ( self ) -> Tuple:
return VideoMAEConfig(
image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , num_frames=self.num_frames , tubelet_size=self.tubelet_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=a , initializer_range=self.initializer_range , )
def _UpperCAmelCase ( self , a , a , a ) -> Optional[int]:
lowercase__ : Dict = VideoMAEModel(config=a )
model.to(a )
model.eval()
lowercase__ : Tuple = model(a )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def _UpperCAmelCase ( self , a , a , a ) -> Union[str, Any]:
lowercase__ : str = VideoMAEForPreTraining(a )
model.to(a )
model.eval()
# important: each video needs to have the same number of masked patches
# hence we define a single mask, which we then repeat for each example in the batch
lowercase__ : Any = torch.ones((self.num_masks,) )
lowercase__ : str = torch.cat([mask, torch.zeros(self.seq_length - mask.size(0 ) )] )
lowercase__ : Optional[int] = mask.expand(self.batch_size , -1 ).bool()
lowercase__ : str = model(a , a )
# model only returns predictions for masked patches
lowercase__ : str = mask.sum().item()
lowercase__ : int = 3 * self.tubelet_size * self.patch_size**2
self.parent.assertEqual(result.logits.shape , (self.batch_size, num_masked_patches, decoder_num_labels) )
def _UpperCAmelCase ( self ) -> str:
lowercase__ : Dict = self.prepare_config_and_inputs()
lowercase__ , lowercase__ , lowercase__ : Union[str, Any] = config_and_inputs
lowercase__ : List[str] = {'pixel_values': pixel_values}
return config, inputs_dict
@require_torch
class UpperCAmelCase_ ( _a , _a , unittest.TestCase):
lowerCamelCase__ : Tuple = (
(VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
)
lowerCamelCase__ : Optional[int] = (
{"feature-extraction": VideoMAEModel, "video-classification": VideoMAEForVideoClassification}
if is_torch_available()
else {}
)
lowerCamelCase__ : Any = False
lowerCamelCase__ : Any = False
lowerCamelCase__ : Union[str, Any] = False
lowerCamelCase__ : str = False
def _UpperCAmelCase ( self ) -> Tuple:
lowercase__ : Optional[Any] = VideoMAEModelTester(self )
lowercase__ : Optional[Any] = ConfigTester(self , config_class=a , has_text_modality=a , hidden_size=3_7 )
def _UpperCAmelCase ( self , a , a , a=False ) -> Optional[int]:
lowercase__ : Union[str, Any] = copy.deepcopy(a )
if model_class == VideoMAEForPreTraining:
# important: each video needs to have the same number of masked patches
# hence we define a single mask, which we then repeat for each example in the batch
lowercase__ : Optional[Any] = torch.ones((self.model_tester.num_masks,) )
lowercase__ : Any = torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0 ) )] )
lowercase__ : Any = mask.expand(self.model_tester.batch_size , -1 ).bool()
lowercase__ : Union[str, Any] = bool_masked_pos.to(a )
if return_labels:
if model_class in [
*get_values(a ),
]:
lowercase__ : Dict = torch.zeros(
self.model_tester.batch_size , dtype=torch.long , device=a )
return inputs_dict
def _UpperCAmelCase ( self ) -> Tuple:
self.config_tester.run_common_tests()
@unittest.skip(reason='VideoMAE does not use inputs_embeds' )
def _UpperCAmelCase ( self ) -> Dict:
pass
def _UpperCAmelCase ( self ) -> List[Any]:
lowercase__ , lowercase__ : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase__ : int = model_class(a )
self.assertIsInstance(model.get_input_embeddings() , (nn.Module) )
lowercase__ : int = model.get_output_embeddings()
self.assertTrue(x is None or isinstance(a , nn.Linear ) )
def _UpperCAmelCase ( self ) -> Optional[int]:
lowercase__ , lowercase__ : Any = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase__ : List[str] = model_class(a )
lowercase__ : int = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
lowercase__ : Optional[Any] = [*signature.parameters.keys()]
lowercase__ : int = ['pixel_values']
self.assertListEqual(arg_names[:1] , a )
def _UpperCAmelCase ( self ) -> Optional[Any]:
lowercase__ : List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*a )
def _UpperCAmelCase ( self ) -> Tuple:
lowercase__ : Union[str, Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_pretraining(*a )
@slow
def _UpperCAmelCase ( self ) -> str:
for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
lowercase__ : List[Any] = VideoMAEModel.from_pretrained(a )
self.assertIsNotNone(a )
def _UpperCAmelCase ( self ) -> Optional[Any]:
if not self.has_attentions:
pass
else:
lowercase__ , lowercase__ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common()
lowercase__ : str = True
for model_class in self.all_model_classes:
lowercase__ : Union[str, Any] = self.model_tester.seq_length - self.model_tester.num_masks
lowercase__ : Any = (
num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
)
lowercase__ : Optional[Any] = True
lowercase__ : int = False
lowercase__ : Any = True
lowercase__ : List[str] = model_class(a )
model.to(a )
model.eval()
with torch.no_grad():
lowercase__ : Optional[int] = model(**self._prepare_for_class(a , a ) )
lowercase__ : Dict = outputs.attentions
self.assertEqual(len(a ) , self.model_tester.num_hidden_layers )
# check that output_attentions also work using config
del inputs_dict["output_attentions"]
lowercase__ : str = True
lowercase__ : List[str] = model_class(a )
model.to(a )
model.eval()
with torch.no_grad():
lowercase__ : List[Any] = model(**self._prepare_for_class(a , a ) )
lowercase__ : Optional[Any] = outputs.attentions
self.assertEqual(len(a ) , self.model_tester.num_hidden_layers )
self.assertListEqual(
list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , )
lowercase__ : List[str] = len(a )
# Check attention is always last and order is fine
lowercase__ : Optional[int] = True
lowercase__ : List[str] = True
lowercase__ : int = model_class(a )
model.to(a )
model.eval()
with torch.no_grad():
lowercase__ : List[str] = model(**self._prepare_for_class(a , a ) )
self.assertEqual(out_len + 1 , len(a ) )
lowercase__ : int = outputs.attentions
self.assertEqual(len(a ) , self.model_tester.num_hidden_layers )
self.assertListEqual(
list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , )
def _UpperCAmelCase ( self ) -> Optional[int]:
def check_hidden_states_output(a , a , a ):
lowercase__ : Optional[int] = model_class(a )
model.to(a )
model.eval()
with torch.no_grad():
lowercase__ : Optional[Any] = model(**self._prepare_for_class(a , a ) )
lowercase__ : Optional[int] = outputs.hidden_states
lowercase__ : List[Any] = self.model_tester.num_hidden_layers + 1
self.assertEqual(len(a ) , a )
lowercase__ : Optional[Any] = self.model_tester.seq_length - self.model_tester.num_masks
lowercase__ : Union[str, Any] = num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
self.assertListEqual(
list(hidden_states[0].shape[-2:] ) , [seq_length, self.model_tester.hidden_size] , )
lowercase__ , lowercase__ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
lowercase__ : Tuple = True
check_hidden_states_output(a , a , a )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
lowercase__ : Union[str, Any] = True
check_hidden_states_output(a , a , a )
@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' )
def _UpperCAmelCase ( self ) -> List[Any]:
pass
def a_ ( ):
'''simple docstring'''
lowercase__ : int = hf_hub_download(
repo_id='hf-internal-testing/spaghetti-video' , filename='eating_spaghetti.npy' , repo_type='dataset' )
lowercase__ : str = np.load(_lowerCAmelCase )
return list(_lowerCAmelCase )
@require_torch
@require_vision
class UpperCAmelCase_ ( unittest.TestCase):
@cached_property
def _UpperCAmelCase ( self ) -> Optional[Any]:
# logits were tested with a different mean and std, so we use the same here
return (
VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] , image_std=[0.5, 0.5, 0.5] )
if is_vision_available()
else None
)
@slow
def _UpperCAmelCase ( self ) -> int:
lowercase__ : Dict = VideoMAEForVideoClassification.from_pretrained('MCG-NJU/videomae-base-finetuned-kinetics' ).to(
a )
lowercase__ : str = self.default_image_processor
lowercase__ : List[str] = prepare_video()
lowercase__ : int = image_processor(a , return_tensors='pt' ).to(a )
# forward pass
with torch.no_grad():
lowercase__ : Union[str, Any] = model(**a )
# verify the logits
lowercase__ : str = torch.Size((1, 4_0_0) )
self.assertEqual(outputs.logits.shape , a )
lowercase__ : List[Any] = torch.tensor([0.3_669, -0.0_688, -0.2_421] ).to(a )
self.assertTrue(torch.allclose(outputs.logits[0, :3] , a , atol=1e-4 ) )
@slow
def _UpperCAmelCase ( self ) -> List[str]:
lowercase__ : Optional[int] = VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short' ).to(a )
lowercase__ : Optional[Any] = self.default_image_processor
lowercase__ : List[str] = prepare_video()
lowercase__ : str = image_processor(a , return_tensors='pt' ).to(a )
# add boolean mask, indicating which patches to mask
lowercase__ : Union[str, Any] = hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos' , filename='bool_masked_pos.pt' )
lowercase__ : str = torch.load(a )
# forward pass
with torch.no_grad():
lowercase__ : List[Any] = model(**a )
# verify the logits
lowercase__ : Dict = torch.Size([1, 1_4_0_8, 1_5_3_6] )
lowercase__ : List[str] = torch.tensor(
[[0.7_994, 0.9_612, 0.8_508], [0.7_401, 0.8_958, 0.8_302], [0.5_862, 0.7_468, 0.7_325]] , device=a )
self.assertEqual(outputs.logits.shape , a )
self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , a , atol=1e-4 ) )
# verify the loss (`config.norm_pix_loss` = `True`)
lowercase__ : List[Any] = torch.tensor([0.5_142] , device=a )
self.assertTrue(torch.allclose(outputs.loss , a , atol=1e-4 ) )
# verify the loss (`config.norm_pix_loss` = `False`)
lowercase__ : Tuple = VideoMAEForPreTraining.from_pretrained('MCG-NJU/videomae-base-short' , norm_pix_loss=a ).to(
a )
with torch.no_grad():
lowercase__ : Any = model(**a )
lowercase__ : List[Any] = torch.tensor(torch.tensor([0.6_469] ) , device=a )
self.assertTrue(torch.allclose(outputs.loss , a , atol=1e-4 ) )
| 645
| 1
|
"""simple docstring"""
import torch
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss
from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.bert.modeling_bert import (
BERT_INPUTS_DOCSTRING,
BERT_START_DOCSTRING,
BertEmbeddings,
BertLayer,
BertPooler,
BertPreTrainedModel,
)
def lowercase (_snake_case ) -> Dict:
'''simple docstring'''
__UpperCamelCase = torch.exp(_UpperCamelCase )
__UpperCamelCase = torch.sum(_UpperCamelCase ,dim=1 ) # sum of exp(x_i)
__UpperCamelCase = torch.sum(x * exp_x ,dim=1 ) # sum of x_i * exp(x_i)
return torch.log(_UpperCamelCase ) - B / A
class __UpperCAmelCase ( nn.Module ):
"""simple docstring"""
def __init__( self : Dict , A_ : str )-> Tuple:
super().__init__()
__UpperCamelCase = config.output_attentions
__UpperCamelCase = config.output_hidden_states
__UpperCamelCase = nn.ModuleList([BertLayer(A_ ) for _ in range(config.num_hidden_layers )] )
__UpperCamelCase = nn.ModuleList([BertHighway(A_ ) for _ in range(config.num_hidden_layers )] )
__UpperCamelCase = [-1 for _ in range(config.num_hidden_layers )]
def A ( self : Optional[Any] , A_ : List[Any] )-> Optional[int]:
if (type(A_ ) is float) or (type(A_ ) is int):
for i in range(len(self.early_exit_entropy ) ):
__UpperCamelCase = x
else:
__UpperCamelCase = x
def A ( self : Dict , A_ : int )-> Any:
__UpperCamelCase = pooler.state_dict()
for highway in self.highway:
for name, param in highway.pooler.state_dict().items():
param.copy_(loaded_model[name] )
def A ( self : List[str] , A_ : List[Any] , A_ : Tuple=None , A_ : List[str]=None , A_ : Any=None , A_ : List[Any]=None , )-> Tuple:
__UpperCamelCase = ()
__UpperCamelCase = ()
__UpperCamelCase = ()
for i, layer_module in enumerate(self.layer ):
if self.output_hidden_states:
__UpperCamelCase = all_hidden_states + (hidden_states,)
__UpperCamelCase = layer_module(
A_ , A_ , head_mask[i] , A_ , A_ )
__UpperCamelCase = layer_outputs[0]
if self.output_attentions:
__UpperCamelCase = all_attentions + (layer_outputs[1],)
__UpperCamelCase = (hidden_states,)
if self.output_hidden_states:
__UpperCamelCase = current_outputs + (all_hidden_states,)
if self.output_attentions:
__UpperCamelCase = current_outputs + (all_attentions,)
__UpperCamelCase = self.highway[i](A_ )
# logits, pooled_output
if not self.training:
__UpperCamelCase = highway_exit[0]
__UpperCamelCase = entropy(A_ )
__UpperCamelCase = highway_exit + (highway_entropy,) # logits, hidden_states(?), entropy
__UpperCamelCase = all_highway_exits + (highway_exit,)
if highway_entropy < self.early_exit_entropy[i]:
__UpperCamelCase = (highway_logits,) + current_outputs[1:] + (all_highway_exits,)
raise HighwayException(A_ , i + 1 )
else:
__UpperCamelCase = all_highway_exits + (highway_exit,)
# Add last layer
if self.output_hidden_states:
__UpperCamelCase = all_hidden_states + (hidden_states,)
__UpperCamelCase = (hidden_states,)
if self.output_hidden_states:
__UpperCamelCase = outputs + (all_hidden_states,)
if self.output_attentions:
__UpperCamelCase = outputs + (all_attentions,)
__UpperCamelCase = outputs + (all_highway_exits,)
return outputs # last-layer hidden state, (all hidden states), (all attentions), all highway exits
@add_start_docstrings(
'The Bert Model transformer with early exiting (DeeBERT). ' , _a , )
class __UpperCAmelCase ( _a ):
"""simple docstring"""
def __init__( self : Dict , A_ : str )-> int:
super().__init__(A_ )
__UpperCamelCase = config
__UpperCamelCase = BertEmbeddings(A_ )
__UpperCamelCase = DeeBertEncoder(A_ )
__UpperCamelCase = BertPooler(A_ )
self.init_weights()
def A ( self : List[Any] )-> str:
self.encoder.init_highway_pooler(self.pooler )
def A ( self : Optional[int] )-> Dict:
return self.embeddings.word_embeddings
def A ( self : Dict , A_ : Union[str, Any] )-> Tuple:
__UpperCamelCase = value
def A ( self : Optional[Any] , A_ : Optional[Any] )-> Dict:
for layer, heads in heads_to_prune.items():
self.encoder.layer[layer].attention.prune_heads(A_ )
@add_start_docstrings_to_model_forward(A_ )
def A ( self : List[Any] , A_ : Tuple=None , A_ : Tuple=None , A_ : str=None , A_ : List[Any]=None , A_ : List[str]=None , A_ : Dict=None , A_ : str=None , A_ : Dict=None , )-> List[Any]:
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time" )
elif input_ids is not None:
__UpperCamelCase = input_ids.size()
elif inputs_embeds is not None:
__UpperCamelCase = inputs_embeds.size()[:-1]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds" )
__UpperCamelCase = input_ids.device if input_ids is not None else inputs_embeds.device
if attention_mask is None:
__UpperCamelCase = torch.ones(A_ , device=A_ )
if encoder_attention_mask is None:
__UpperCamelCase = torch.ones(A_ , device=A_ )
if token_type_ids is None:
__UpperCamelCase = torch.zeros(A_ , dtype=torch.long , device=A_ )
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
# ourselves in which case we just need to make it broadcastable to all heads.
__UpperCamelCase = self.get_extended_attention_mask(A_ , A_ , A_ )
# If a 2D ou 3D attention mask is provided for the cross-attention
# we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
if encoder_attention_mask.dim() == 3:
__UpperCamelCase = encoder_attention_mask[:, None, :, :]
if encoder_attention_mask.dim() == 2:
__UpperCamelCase = encoder_attention_mask[:, None, None, :]
__UpperCamelCase = encoder_extended_attention_mask.to(
dtype=next(self.parameters() ).dtype ) # fp16 compatibility
__UpperCamelCase = (1.0 - encoder_extended_attention_mask) * -1_00_00.0
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
__UpperCamelCase = self.get_head_mask(A_ , self.config.num_hidden_layers )
__UpperCamelCase = self.embeddings(
input_ids=A_ , position_ids=A_ , token_type_ids=A_ , inputs_embeds=A_ )
__UpperCamelCase = self.encoder(
A_ , attention_mask=A_ , head_mask=A_ , encoder_hidden_states=A_ , encoder_attention_mask=A_ , )
__UpperCamelCase = encoder_outputs[0]
__UpperCamelCase = self.pooler(A_ )
__UpperCamelCase = (
sequence_output,
pooled_output,
) + encoder_outputs[
1:
] # add hidden_states and attentions if they are here
return outputs # sequence_output, pooled_output, (hidden_states), (attentions), highway exits
class __UpperCAmelCase ( _a ):
"""simple docstring"""
def __init__( self : str , A_ : List[Any] , A_ : List[str] )-> Tuple:
__UpperCamelCase = message
__UpperCamelCase = exit_layer # start from 1!
class __UpperCAmelCase ( nn.Module ):
"""simple docstring"""
def __init__( self : Tuple , A_ : List[str] )-> List[str]:
super().__init__()
__UpperCamelCase = BertPooler(A_ )
__UpperCamelCase = nn.Dropout(config.hidden_dropout_prob )
__UpperCamelCase = nn.Linear(config.hidden_size , config.num_labels )
def A ( self : Dict , A_ : Dict )-> Optional[int]:
__UpperCamelCase = encoder_outputs[0]
__UpperCamelCase = self.pooler(A_ )
# "return" pooler_output
# BertModel
__UpperCamelCase = (pooler_input, pooler_output) + encoder_outputs[1:]
# "return" bmodel_output
# Dropout and classification
__UpperCamelCase = bmodel_output[1]
__UpperCamelCase = self.dropout(A_ )
__UpperCamelCase = self.classifier(A_ )
return logits, pooled_output
@add_start_docstrings(
'Bert Model (with early exiting - DeeBERT) with a classifier on top,\n also takes care of multi-layer training. ' , _a , )
class __UpperCAmelCase ( _a ):
"""simple docstring"""
def __init__( self : str , A_ : List[str] )-> int:
super().__init__(A_ )
__UpperCamelCase = config.num_labels
__UpperCamelCase = config.num_hidden_layers
__UpperCamelCase = DeeBertModel(A_ )
__UpperCamelCase = nn.Dropout(config.hidden_dropout_prob )
__UpperCamelCase = nn.Linear(config.hidden_size , self.config.num_labels )
self.init_weights()
@add_start_docstrings_to_model_forward(A_ )
def A ( self : Optional[Any] , A_ : Dict=None , A_ : Tuple=None , A_ : Optional[Any]=None , A_ : Optional[Any]=None , A_ : Tuple=None , A_ : Optional[int]=None , A_ : Optional[Any]=None , A_ : Optional[int]=-1 , A_ : Optional[int]=False , )-> Optional[int]:
__UpperCamelCase = self.num_layers
try:
__UpperCamelCase = self.bert(
A_ , attention_mask=A_ , token_type_ids=A_ , position_ids=A_ , head_mask=A_ , inputs_embeds=A_ , )
# sequence_output, pooled_output, (hidden_states), (attentions), highway exits
__UpperCamelCase = outputs[1]
__UpperCamelCase = self.dropout(A_ )
__UpperCamelCase = self.classifier(A_ )
__UpperCamelCase = (logits,) + outputs[2:] # add hidden states and attention if they are here
except HighwayException as e:
__UpperCamelCase = e.message
__UpperCamelCase = e.exit_layer
__UpperCamelCase = outputs[0]
if not self.training:
__UpperCamelCase = entropy(A_ )
__UpperCamelCase = []
__UpperCamelCase = []
if labels is not None:
if self.num_labels == 1:
# We are doing regression
__UpperCamelCase = MSELoss()
__UpperCamelCase = loss_fct(logits.view(-1 ) , labels.view(-1 ) )
else:
__UpperCamelCase = CrossEntropyLoss()
__UpperCamelCase = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) )
# work with highway exits
__UpperCamelCase = []
for highway_exit in outputs[-1]:
__UpperCamelCase = highway_exit[0]
if not self.training:
highway_logits_all.append(A_ )
highway_entropy.append(highway_exit[2] )
if self.num_labels == 1:
# We are doing regression
__UpperCamelCase = MSELoss()
__UpperCamelCase = loss_fct(highway_logits.view(-1 ) , labels.view(-1 ) )
else:
__UpperCamelCase = CrossEntropyLoss()
__UpperCamelCase = loss_fct(highway_logits.view(-1 , self.num_labels ) , labels.view(-1 ) )
highway_losses.append(A_ )
if train_highway:
__UpperCamelCase = (sum(highway_losses[:-1] ),) + outputs
# exclude the final highway, of course
else:
__UpperCamelCase = (loss,) + outputs
if not self.training:
__UpperCamelCase = outputs + ((original_entropy, highway_entropy), exit_layer)
if output_layer >= 0:
__UpperCamelCase = (
(outputs[0],) + (highway_logits_all[output_layer],) + outputs[2:]
) # use the highway of the last layer
return outputs # (loss), logits, (hidden_states), (attentions), (highway_exits)
| 505
|
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
lowerCAmelCase_ = {
'''configuration_xmod''': [
'''XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP''',
'''XmodConfig''',
'''XmodOnnxConfig''',
],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase_ = [
'''XMOD_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''XmodForCausalLM''',
'''XmodForMaskedLM''',
'''XmodForMultipleChoice''',
'''XmodForQuestionAnswering''',
'''XmodForSequenceClassification''',
'''XmodForTokenClassification''',
'''XmodModel''',
'''XmodPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_xmod import (
XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
XmodForCausalLM,
XmodForMaskedLM,
XmodForMultipleChoice,
XmodForQuestionAnswering,
XmodForSequenceClassification,
XmodForTokenClassification,
XmodModel,
XmodPreTrainedModel,
)
else:
import sys
lowerCAmelCase_ = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 60
| 0
|
import argparse
import json
from pathlib import Path
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import (
BertTokenizer,
ViltConfig,
ViltForImageAndTextRetrieval,
ViltForImagesAndTextClassification,
ViltForMaskedLM,
ViltForQuestionAnswering,
ViltImageProcessor,
ViltProcessor,
)
from transformers.utils import logging
logging.set_verbosity_info()
UpperCAmelCase_ = logging.get_logger(__name__)
def UpperCAmelCase ( A__ , A__=False , A__=False , A__=False ) -> Union[str, Any]:
_snake_case : Tuple = []
for i in range(config.num_hidden_layers ):
# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
rename_keys.append((f'''transformer.blocks.{i}.norm1.weight''', f'''vilt.encoder.layer.{i}.layernorm_before.weight''') )
rename_keys.append((f'''transformer.blocks.{i}.norm1.bias''', f'''vilt.encoder.layer.{i}.layernorm_before.bias''') )
rename_keys.append(
(f'''transformer.blocks.{i}.attn.proj.weight''', f'''vilt.encoder.layer.{i}.attention.output.dense.weight''') )
rename_keys.append(
(f'''transformer.blocks.{i}.attn.proj.bias''', f'''vilt.encoder.layer.{i}.attention.output.dense.bias''') )
rename_keys.append((f'''transformer.blocks.{i}.norm2.weight''', f'''vilt.encoder.layer.{i}.layernorm_after.weight''') )
rename_keys.append((f'''transformer.blocks.{i}.norm2.bias''', f'''vilt.encoder.layer.{i}.layernorm_after.bias''') )
rename_keys.append(
(f'''transformer.blocks.{i}.mlp.fc1.weight''', f'''vilt.encoder.layer.{i}.intermediate.dense.weight''') )
rename_keys.append((f'''transformer.blocks.{i}.mlp.fc1.bias''', f'''vilt.encoder.layer.{i}.intermediate.dense.bias''') )
rename_keys.append((f'''transformer.blocks.{i}.mlp.fc2.weight''', f'''vilt.encoder.layer.{i}.output.dense.weight''') )
rename_keys.append((f'''transformer.blocks.{i}.mlp.fc2.bias''', f'''vilt.encoder.layer.{i}.output.dense.bias''') )
# embeddings
rename_keys.extend(
[
# text embeddings
("""text_embeddings.word_embeddings.weight""", """vilt.embeddings.text_embeddings.word_embeddings.weight"""),
(
"""text_embeddings.position_embeddings.weight""",
"""vilt.embeddings.text_embeddings.position_embeddings.weight""",
),
("""text_embeddings.position_ids""", """vilt.embeddings.text_embeddings.position_ids"""),
(
"""text_embeddings.token_type_embeddings.weight""",
"""vilt.embeddings.text_embeddings.token_type_embeddings.weight""",
),
("""text_embeddings.LayerNorm.weight""", """vilt.embeddings.text_embeddings.LayerNorm.weight"""),
("""text_embeddings.LayerNorm.bias""", """vilt.embeddings.text_embeddings.LayerNorm.bias"""),
# patch embeddings
("""transformer.cls_token""", """vilt.embeddings.cls_token"""),
("""transformer.patch_embed.proj.weight""", """vilt.embeddings.patch_embeddings.projection.weight"""),
("""transformer.patch_embed.proj.bias""", """vilt.embeddings.patch_embeddings.projection.bias"""),
("""transformer.pos_embed""", """vilt.embeddings.position_embeddings"""),
# token type embeddings
("""token_type_embeddings.weight""", """vilt.embeddings.token_type_embeddings.weight"""),
] )
# final layernorm + pooler
rename_keys.extend(
[
("""transformer.norm.weight""", """vilt.layernorm.weight"""),
("""transformer.norm.bias""", """vilt.layernorm.bias"""),
("""pooler.dense.weight""", """vilt.pooler.dense.weight"""),
("""pooler.dense.bias""", """vilt.pooler.dense.bias"""),
] )
# classifier head(s)
if vqa_model:
# classification head
rename_keys.extend(
[
("""vqa_classifier.0.weight""", """classifier.0.weight"""),
("""vqa_classifier.0.bias""", """classifier.0.bias"""),
("""vqa_classifier.1.weight""", """classifier.1.weight"""),
("""vqa_classifier.1.bias""", """classifier.1.bias"""),
("""vqa_classifier.3.weight""", """classifier.3.weight"""),
("""vqa_classifier.3.bias""", """classifier.3.bias"""),
] )
elif nlvr_model:
# classification head
rename_keys.extend(
[
("""nlvr2_classifier.0.weight""", """classifier.0.weight"""),
("""nlvr2_classifier.0.bias""", """classifier.0.bias"""),
("""nlvr2_classifier.1.weight""", """classifier.1.weight"""),
("""nlvr2_classifier.1.bias""", """classifier.1.bias"""),
("""nlvr2_classifier.3.weight""", """classifier.3.weight"""),
("""nlvr2_classifier.3.bias""", """classifier.3.bias"""),
] )
else:
pass
return rename_keys
def UpperCAmelCase ( A__ , A__ ) -> List[str]:
for i in range(config.num_hidden_layers ):
_snake_case : Optional[Any] = """vilt."""
# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
_snake_case : Optional[int] = state_dict.pop(f'''transformer.blocks.{i}.attn.qkv.weight''' )
_snake_case : Union[str, Any] = state_dict.pop(f'''transformer.blocks.{i}.attn.qkv.bias''' )
# next, add query, keys and values (in that order) to the state dict
_snake_case : Any = in_proj_weight[
: config.hidden_size, :
]
_snake_case : Any = in_proj_bias[: config.hidden_size]
_snake_case : str = in_proj_weight[
config.hidden_size : config.hidden_size * 2, :
]
_snake_case : List[Any] = in_proj_bias[
config.hidden_size : config.hidden_size * 2
]
_snake_case : Union[str, Any] = in_proj_weight[
-config.hidden_size :, :
]
_snake_case : Dict = in_proj_bias[-config.hidden_size :]
def UpperCAmelCase ( A__ ) -> Union[str, Any]:
_snake_case : Any = ["""head.weight""", """head.bias"""]
for k in ignore_keys:
state_dict.pop(A__ , A__ )
def UpperCAmelCase ( A__ , A__ , A__ ) -> int:
_snake_case : int = dct.pop(A__ )
_snake_case : Tuple = val
@torch.no_grad()
def UpperCAmelCase ( A__ , A__ ) -> Union[str, Any]:
_snake_case : List[str] = ViltConfig(image_size=3_84 , patch_size=32 , tie_word_embeddings=A__ )
_snake_case : Tuple = False
_snake_case : Optional[Any] = False
_snake_case : Optional[Any] = False
_snake_case : int = False
if "vqa" in checkpoint_url:
_snake_case : List[str] = True
_snake_case : Any = 31_29
_snake_case : Dict = """huggingface/label-files"""
_snake_case : Any = """vqa2-id2label.json"""
_snake_case : Union[str, Any] = json.load(open(hf_hub_download(A__ , A__ , repo_type="""dataset""" ) , """r""" ) )
_snake_case : Optional[Any] = {int(A__ ): v for k, v in idalabel.items()}
_snake_case : int = idalabel
_snake_case : Tuple = {v: k for k, v in idalabel.items()}
_snake_case : List[Any] = ViltForQuestionAnswering(A__ )
elif "nlvr" in checkpoint_url:
_snake_case : Dict = True
_snake_case : Tuple = 2
_snake_case : Tuple = {0: """False""", 1: """True"""}
_snake_case : Union[str, Any] = {v: k for k, v in config.idalabel.items()}
_snake_case : str = 3
_snake_case : List[str] = ViltForImagesAndTextClassification(A__ )
elif "irtr" in checkpoint_url:
_snake_case : Dict = True
_snake_case : Optional[int] = ViltForImageAndTextRetrieval(A__ )
elif "mlm_itm" in checkpoint_url:
_snake_case : List[str] = True
_snake_case : Union[str, Any] = ViltForMaskedLM(A__ )
else:
raise ValueError("""Unknown model type""" )
# load state_dict of original model, remove and rename some keys
_snake_case : Optional[int] = torch.hub.load_state_dict_from_url(A__ , map_location="""cpu""" )["""state_dict"""]
_snake_case : Tuple = create_rename_keys(A__ , A__ , A__ , A__ )
for src, dest in rename_keys:
rename_key(A__ , A__ , A__ )
read_in_q_k_v(A__ , A__ )
if mlm_model or irtr_model:
_snake_case : str = ["""itm_score.fc.weight""", """itm_score.fc.bias"""]
for k in ignore_keys:
state_dict.pop(A__ , A__ )
# load state dict into HuggingFace model
model.eval()
if mlm_model:
_snake_case , _snake_case : Union[str, Any] = model.load_state_dict(A__ , strict=A__ )
assert missing_keys == ["mlm_score.decoder.bias"]
else:
model.load_state_dict(A__ )
# Define processor
_snake_case : Union[str, Any] = ViltImageProcessor(size=3_84 )
_snake_case : Optional[Any] = BertTokenizer.from_pretrained("""bert-base-uncased""" )
_snake_case : Optional[Any] = ViltProcessor(A__ , A__ )
# Forward pass on example inputs (image + text)
if nlvr_model:
_snake_case : Any = Image.open(requests.get("""https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg""" , stream=A__ ).raw )
_snake_case : Optional[int] = Image.open(requests.get("""https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg""" , stream=A__ ).raw )
_snake_case : Union[str, Any] = (
"""The left image contains twice the number of dogs as the right image, and at least two dogs in total are"""
""" standing."""
)
_snake_case : Union[str, Any] = processor(A__ , A__ , return_tensors="""pt""" )
_snake_case : Optional[int] = processor(A__ , A__ , return_tensors="""pt""" )
_snake_case : Union[str, Any] = model(
input_ids=encoding_a.input_ids , pixel_values=encoding_a.pixel_values , pixel_values_a=encoding_a.pixel_values , )
else:
_snake_case : Any = Image.open(requests.get("""http://images.cocodataset.org/val2017/000000039769.jpg""" , stream=A__ ).raw )
if mlm_model:
_snake_case : Union[str, Any] = """a bunch of [MASK] laying on a [MASK]."""
else:
_snake_case : Tuple = """How many cats are there?"""
_snake_case : List[Any] = processor(A__ , A__ , return_tensors="""pt""" )
_snake_case : Tuple = model(**A__ )
# Verify outputs
if mlm_model:
_snake_case : List[Any] = torch.Size([1, 11, 3_05_22] )
_snake_case : int = torch.tensor([-12.5061, -12.5123, -12.5174] )
assert outputs.logits.shape == expected_shape
assert torch.allclose(outputs.logits[0, 0, :3] , A__ , atol=1E-4 )
# verify masked token prediction equals "cats"
_snake_case : Union[str, Any] = outputs.logits[0, 4, :].argmax(-1 ).item()
assert tokenizer.decode([predicted_id] ) == "cats"
elif vqa_model:
_snake_case : Optional[Any] = torch.Size([1, 31_29] )
_snake_case : Any = torch.tensor([-15.9495, -18.1472, -10.3041] )
assert torch.allclose(outputs.logits[0, :3] , A__ , atol=1E-4 )
assert outputs.logits.shape == expected_shape
assert torch.allclose(outputs.logits[0, 0, :3] , A__ , atol=1E-4 )
# verify vqa prediction equals "2"
_snake_case : Tuple = outputs.logits.argmax(-1 ).item()
assert model.config.idalabel[predicted_idx] == "2"
elif nlvr_model:
_snake_case : Any = torch.Size([1, 2] )
_snake_case : Optional[Any] = torch.tensor([-2.8721, 2.1291] )
assert torch.allclose(outputs.logits[0, :3] , A__ , atol=1E-4 )
assert outputs.logits.shape == expected_shape
Path(A__ ).mkdir(exist_ok=A__ )
print(f'''Saving model and processor to {pytorch_dump_folder_path}''' )
model.save_pretrained(A__ )
processor.save_pretrained(A__ )
if __name__ == "__main__":
UpperCAmelCase_ = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--checkpoint_url''',
default='''https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt''',
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.'''
)
UpperCAmelCase_ = parser.parse_args()
convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
| 519
|
from typing import Optional, Union
import torch
from torch import nn
from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin
class __SCREAMING_SNAKE_CASE ( lowercase__ , lowercase__ ):
"""simple docstring"""
@register_to_config
def __init__( self , SCREAMING_SNAKE_CASE__ = 7_68 , ):
"""simple docstring"""
super().__init__()
_snake_case : Optional[Any] = nn.Parameter(torch.zeros(1 , SCREAMING_SNAKE_CASE__ ) )
_snake_case : Optional[Any] = nn.Parameter(torch.ones(1 , SCREAMING_SNAKE_CASE__ ) )
def __lowerCamelCase( self , SCREAMING_SNAKE_CASE__ = None , SCREAMING_SNAKE_CASE__ = None , ):
"""simple docstring"""
_snake_case : Dict = nn.Parameter(self.mean.to(SCREAMING_SNAKE_CASE__ ).to(SCREAMING_SNAKE_CASE__ ) )
_snake_case : List[Any] = nn.Parameter(self.std.to(SCREAMING_SNAKE_CASE__ ).to(SCREAMING_SNAKE_CASE__ ) )
return self
def __lowerCamelCase( self , SCREAMING_SNAKE_CASE__ ):
"""simple docstring"""
_snake_case : int = (embeds - self.mean) * 1.0 / self.std
return embeds
def __lowerCamelCase( self , SCREAMING_SNAKE_CASE__ ):
"""simple docstring"""
_snake_case : Optional[Any] = (embeds * self.std) + self.mean
return embeds
| 519
| 1
|
"""simple docstring"""
import argparse
import hashlib # hashlib is only used inside the Test class
import struct
class SCREAMING_SNAKE_CASE__ :
"""simple docstring"""
def __init__( self , snake_case__ ):
"""simple docstring"""
lowerCAmelCase : Dict = data
lowerCAmelCase : List[str] = [0x67_452_301, 0xef_cda_b89, 0x98_bad_cfe, 0x10_325_476, 0xc3_d2e_1f0]
@staticmethod
def lowercase__ ( snake_case__ , snake_case__ ):
"""simple docstring"""
return ((n << b) | (n >> (32 - b))) & 0xff_fff_fff
def lowercase__ ( self ):
"""simple docstring"""
lowerCAmelCase : Any = B"\x80" + B"\x00" * (63 - (len(self.data ) + 8) % 64)
lowerCAmelCase : Tuple = self.data + padding + struct.pack(">Q" , 8 * len(self.data ) )
return padded_data
def lowercase__ ( self ):
"""simple docstring"""
return [
self.padded_data[i : i + 64] for i in range(0 , len(self.padded_data ) , 64 )
]
def lowercase__ ( self , snake_case__ ):
"""simple docstring"""
lowerCAmelCase : Optional[Any] = list(struct.unpack(">16L" , a__ ) ) + [0] * 64
for i in range(16 , 80 ):
lowerCAmelCase : Any = self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) , 1 )
return w
def lowercase__ ( self ):
"""simple docstring"""
lowerCAmelCase : Union[str, Any] = self.padding()
lowerCAmelCase : List[str] = self.split_blocks()
for block in self.blocks:
lowerCAmelCase : int = self.expand_block(a__ )
lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase : Any = self.h
for i in range(0 , 80 ):
if 0 <= i < 20:
lowerCAmelCase : Tuple = (b & c) | ((~b) & d)
lowerCAmelCase : Dict = 0x5a_827_999
elif 20 <= i < 40:
lowerCAmelCase : Any = b ^ c ^ d
lowerCAmelCase : Optional[Any] = 0x6e_d9e_ba1
elif 40 <= i < 60:
lowerCAmelCase : Union[str, Any] = (b & c) | (b & d) | (c & d)
lowerCAmelCase : Dict = 0x8f_1bb_cdc
elif 60 <= i < 80:
lowerCAmelCase : Dict = b ^ c ^ d
lowerCAmelCase : str = 0xca_62c_1d6
lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase : Any = (
self.rotate(a__ , 5 ) + f + e + k + expanded_block[i] & 0xff_fff_fff,
a,
self.rotate(a__ , 30 ),
c,
d,
)
lowerCAmelCase : int = (
self.h[0] + a & 0xff_fff_fff,
self.h[1] + b & 0xff_fff_fff,
self.h[2] + c & 0xff_fff_fff,
self.h[3] + d & 0xff_fff_fff,
self.h[4] + e & 0xff_fff_fff,
)
return ("{:08x}" * 5).format(*self.h )
def a__ ( ):
'''simple docstring'''
lowerCAmelCase : List[Any] = B"Test String"
assert SHAaHash(UpperCamelCase__ ).final_hash() == hashlib.shaa(UpperCamelCase__ ).hexdigest() # noqa: S324
def a__ ( ):
'''simple docstring'''
lowerCAmelCase : List[Any] = argparse.ArgumentParser(description="Process some strings or files" )
parser.add_argument(
"--string" , dest="input_string" , default="Hello World!! Welcome to Cryptography" , help="Hash the string" , )
parser.add_argument("--file" , dest="input_file" , help="Hash contents of a file" )
lowerCAmelCase : List[str] = parser.parse_args()
lowerCAmelCase : Any = args.input_string
# In any case hash input should be a bytestring
if args.input_file:
with open(args.input_file , "rb" ) as f:
lowerCAmelCase : List[Any] = f.read()
else:
lowerCAmelCase : Tuple = bytes(UpperCamelCase__ , "utf-8" )
print(SHAaHash(UpperCamelCase__ ).final_hash() )
if __name__ == "__main__":
main()
import doctest
doctest.testmod()
| 645
|
import argparse
import torch
from transformers import BlenderbotConfig, BlenderbotForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
_lowercase : List[str] = logging.get_logger(__name__)
_lowercase : int = [
["attention", "attn"],
["encoder_attention", "encoder_attn"],
["q_lin", "q_proj"],
["k_lin", "k_proj"],
["v_lin", "v_proj"],
["out_lin", "out_proj"],
["norm_embeddings", "layernorm_embedding"],
["position_embeddings", "embed_positions"],
["embeddings", "embed_tokens"],
["ffn.lin", "fc"],
]
def _lowerCAmelCase ( UpperCamelCase__: str ) -> int:
"""simple docstring"""
if k == "embeddings.weight":
return "shared.weight"
for parlai_name, hf_name in PATTERNS:
A = k.replace(UpperCamelCase__ , UpperCamelCase__ )
if k.startswith("""encoder""" ):
A = k.replace(""".attn""" , """.self_attn""" )
A = k.replace("""norm1""" , """self_attn_layer_norm""" )
A = k.replace("""norm2""" , """final_layer_norm""" )
elif k.startswith("""decoder""" ):
A = k.replace("""norm1""" , """self_attn_layer_norm""" )
A = k.replace("""norm2""" , """encoder_attn_layer_norm""" )
A = k.replace("""norm3""" , """final_layer_norm""" )
return k
def _lowerCAmelCase ( UpperCamelCase__: Tuple ) -> str:
"""simple docstring"""
A = [
"""model.encoder.layernorm_embedding.weight""",
"""model.encoder.layernorm_embedding.bias""",
"""model.decoder.layernorm_embedding.weight""",
"""model.decoder.layernorm_embedding.bias""",
]
for k in keys:
A = sd.pop(UpperCamelCase__ )
A = k.replace("""layernorm_embedding""" , """layer_norm""" )
assert new_k not in sd
A = v
_lowercase : List[Any] = ["START"]
@torch.no_grad()
def _lowerCAmelCase ( UpperCamelCase__: List[Any] , UpperCamelCase__: Any , UpperCamelCase__: Optional[int] ) -> int:
"""simple docstring"""
A = torch.load(UpperCamelCase__ , map_location="""cpu""" )
A = model["""model"""]
A = BlenderbotConfig.from_json_file(UpperCamelCase__ )
A = BlenderbotForConditionalGeneration(UpperCamelCase__ )
A = m.model.state_dict().keys()
A = []
A = {}
for k, v in sd.items():
if k in IGNORE_KEYS:
continue
A = rename_state_dict_key(UpperCamelCase__ )
if new_k not in valid_keys:
failures.append([k, new_k] )
else:
A = v
if cfg.normalize_before: # Blenderbot-3B checkpoints. Rename layernorm_embedding -> layer_norm
rename_layernorm_keys(UpperCamelCase__ )
m.model.load_state_dict(UpperCamelCase__ , strict=UpperCamelCase__ )
m.half()
m.save_pretrained(UpperCamelCase__ )
if __name__ == "__main__":
_lowercase : str = argparse.ArgumentParser()
# Required parameters
parser.add_argument("--src_path", type=str, help="like blenderbot-model.bin")
parser.add_argument("--save_dir", default="hf_blenderbot", type=str, help="Where to save converted model.")
parser.add_argument(
"--hf_config_json", default="blenderbot-3b-config.json", type=str, help="Path to config to use"
)
_lowercase : List[str] = parser.parse_args()
convert_parlai_checkpoint(args.src_path, args.save_dir, args.hf_config_json)
| 641
| 0
|
"""simple docstring"""
import os
import tempfile
import unittest
import numpy as np
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax, slow
if is_flax_available():
import jax
import jax.numpy as jnp
from flax.jax_utils import replicate
from flax.training.common_utils import shard
from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline
@require_flax
class snake_case__ ( unittest.TestCase ):
def a__ ( self ):
with tempfile.TemporaryDirectory() as tmpdirname:
# pipeline has Flax weights
__a = FlaxDiffusionPipeline.from_pretrained(
"hf-internal-testing/tiny-stable-diffusion-pipe" , safety_checker=lowerCamelCase , cache_dir=lowerCamelCase )
__a = [t[-1] for t in os.walk(os.path.join(lowerCamelCase , os.listdir(lowerCamelCase )[0] , "snapshots" ) )]
__a = [item for sublist in all_root_files for item in sublist]
# None of the downloaded files should be a PyTorch file even if we have some here:
# https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
assert not any(f.endswith(".bin" ) for f in files )
@slow
@require_flax
class snake_case__ ( unittest.TestCase ):
def a__ ( self ):
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"hf-internal-testing/tiny-stable-diffusion-pipe" , safety_checker=lowerCamelCase )
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.random.PRNGKey(0 )
__a = 4
__a = jax.device_count()
__a = num_samples * [prompt]
__a = pipeline.prepare_inputs(lowerCamelCase )
# shard inputs and rng
__a = replicate(lowerCamelCase )
__a = jax.random.split(lowerCamelCase , lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 64, 64, 3)
if jax.device_count() == 8:
assert np.abs(np.abs(images[0, 0, :2, :2, -2:] , dtype=np.floataa ).sum() - 4.151_4745 ) < 1E-3
assert np.abs(np.abs(lowerCamelCase , dtype=np.floataa ).sum() - 4_9947.875 ) < 5E-1
__a = pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:] ) ) )
assert len(lowerCamelCase ) == num_samples
def a__ ( self ):
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="flax" , safety_checker=lowerCamelCase )
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.random.PRNGKey(0 )
__a = 50
__a = jax.device_count()
__a = num_samples * [prompt]
__a = pipeline.prepare_inputs(lowerCamelCase )
# shard inputs and rng
__a = replicate(lowerCamelCase )
__a = jax.random.split(lowerCamelCase , lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 512, 512, 3)
if jax.device_count() == 8:
assert np.abs((np.abs(images[0, 0, :2, :2, -2:] , dtype=np.floataa ).sum() - 0.0565_2401) ) < 1E-3
assert np.abs((np.abs(lowerCamelCase , dtype=np.floataa ).sum() - 238_3808.2) ) < 5E-1
def a__ ( self ):
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="bf16" , dtype=jnp.bfloataa , safety_checker=lowerCamelCase )
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.random.PRNGKey(0 )
__a = 50
__a = jax.device_count()
__a = num_samples * [prompt]
__a = pipeline.prepare_inputs(lowerCamelCase )
# shard inputs and rng
__a = replicate(lowerCamelCase )
__a = jax.random.split(lowerCamelCase , lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 512, 512, 3)
if jax.device_count() == 8:
assert np.abs((np.abs(images[0, 0, :2, :2, -2:] , dtype=np.floataa ).sum() - 0.0400_3906) ) < 1E-3
assert np.abs((np.abs(lowerCamelCase , dtype=np.floataa ).sum() - 237_3516.75) ) < 5E-1
def a__ ( self ):
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="bf16" , dtype=jnp.bfloataa )
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.random.PRNGKey(0 )
__a = 50
__a = jax.device_count()
__a = num_samples * [prompt]
__a = pipeline.prepare_inputs(lowerCamelCase )
# shard inputs and rng
__a = replicate(lowerCamelCase )
__a = jax.random.split(lowerCamelCase , lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 512, 512, 3)
if jax.device_count() == 8:
assert np.abs((np.abs(images[0, 0, :2, :2, -2:] , dtype=np.floataa ).sum() - 0.0400_3906) ) < 1E-3
assert np.abs((np.abs(lowerCamelCase , dtype=np.floataa ).sum() - 237_3516.75) ) < 5E-1
def a__ ( self ):
__a = FlaxDDIMScheduler(
beta_start=0.0_0085 , beta_end=0.012 , beta_schedule="scaled_linear" , set_alpha_to_one=lowerCamelCase , steps_offset=1 , )
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="bf16" , dtype=jnp.bfloataa , scheduler=lowerCamelCase , safety_checker=lowerCamelCase , )
__a = scheduler.create_state()
__a = scheduler_state
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.random.PRNGKey(0 )
__a = 50
__a = jax.device_count()
__a = num_samples * [prompt]
__a = pipeline.prepare_inputs(lowerCamelCase )
# shard inputs and rng
__a = replicate(lowerCamelCase )
__a = jax.random.split(lowerCamelCase , lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 512, 512, 3)
if jax.device_count() == 8:
assert np.abs((np.abs(images[0, 0, :2, :2, -2:] , dtype=np.floataa ).sum() - 0.0_4504_3945) ) < 1E-3
assert np.abs((np.abs(lowerCamelCase , dtype=np.floataa ).sum() - 234_7693.5) ) < 5E-1
def a__ ( self ):
__a = (
"A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of"
" field, close up, split lighting, cinematic"
)
__a = jax.device_count()
__a = num_samples * [prompt]
__a = jax.random.split(jax.random.PRNGKey(0 ) , lowerCamelCase )
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="bf16" , dtype=jnp.bfloataa , safety_checker=lowerCamelCase , )
__a = replicate(lowerCamelCase )
__a = pipeline.prepare_inputs(lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images.shape == (num_samples, 1, 512, 512, 3)
__a = images[2, 0, 256, 10:17, 1]
# With memory efficient attention
__a , __a = FlaxStableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4" , revision="bf16" , dtype=jnp.bfloataa , safety_checker=lowerCamelCase , use_memory_efficient_attention=lowerCamelCase , )
__a = replicate(lowerCamelCase )
__a = pipeline.prepare_inputs(lowerCamelCase )
__a = shard(lowerCamelCase )
__a = pipeline(lowerCamelCase , lowerCamelCase , lowerCamelCase , jit=lowerCamelCase ).images
assert images_eff.shape == (num_samples, 1, 512, 512, 3)
__a = images[2, 0, 256, 10:17, 1]
# I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
# over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
assert abs(slice_eff - slice ).max() < 1E-2
| 67
|
"""simple docstring"""
SCREAMING_SNAKE_CASE__:Any = """Alexander Joslin"""
import operator as op
from .stack import Stack
def _lowerCamelCase( a ):
__a = {"*": op.mul, "/": op.truediv, "+": op.add, "-": op.sub}
__a = Stack()
__a = Stack()
for i in equation:
if i.isdigit():
# RULE 1
operand_stack.push(int(a ) )
elif i in operators:
# RULE 2
operator_stack.push(a )
elif i == ")":
# RULE 4
__a = operator_stack.peek()
operator_stack.pop()
__a = operand_stack.peek()
operand_stack.pop()
__a = operand_stack.peek()
operand_stack.pop()
__a = operators[opr](a , a )
operand_stack.push(a )
# RULE 5
return operand_stack.peek()
if __name__ == "__main__":
SCREAMING_SNAKE_CASE__:Tuple = """(5 + ((4 * 2) * (2 + 3)))"""
# answer = 45
print(F'''{equation} = {dijkstras_two_stack_algorithm(equation)}''')
| 67
| 1
|
# this script reports modified .py files under the desired list of top-level sub-dirs passed as a list of arguments, e.g.:
# python ./utils/get_modified_files.py utils src tests examples
#
# it uses git to find the forking point and which files were modified - i.e. files not under git won't be considered
# since the output of this script is fed into Makefile commands it doesn't print a newline after the results
import re
import subprocess
import sys
UpperCamelCase__ =subprocess.check_output('git merge-base main HEAD'.split()).decode('utf-8')
UpperCamelCase__ =subprocess.check_output(f"git diff --name-only {fork_point_sha}".split()).decode('utf-8').split()
UpperCamelCase__ ='|'.join(sys.argv[1:])
UpperCamelCase__ =re.compile(Rf"^({joined_dirs}).*?\.py$")
UpperCamelCase__ =[x for x in modified_files if regex.match(x)]
print(' '.join(relevant_modified_files), end='')
| 249
|
import requests
from bsa import BeautifulSoup
def lowerCamelCase__ (__lowerCamelCase = "AAPL" ):
_SCREAMING_SNAKE_CASE : Dict = f"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
_SCREAMING_SNAKE_CASE : str = BeautifulSoup(requests.get(__lowerCamelCase ).text, "html.parser" )
_SCREAMING_SNAKE_CASE : Union[str, Any] = "My(6px) Pos(r) smartphone_Mt(6px)"
return soup.find("div", class_=class_ ).find("span" ).text
if __name__ == "__main__":
for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
print(f"Current {symbol:<4} stock price is {stock_price(symbol):>8}")
| 249
| 1
|
'''simple docstring'''
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
_snake_case : int = logging.get_logger(__name__)
_snake_case : Dict = {
'google/mobilenet_v1_1.0_224': 'https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json',
'google/mobilenet_v1_0.75_192': 'https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json',
# See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}
class A ( _a ):
lowercase_ = 'mobilenet_v1'
def __init__( self : Union[str, Any] , lowerCAmelCase_ : Union[str, Any]=3 , lowerCAmelCase_ : int=2_24 , lowerCAmelCase_ : List[str]=1.0 , lowerCAmelCase_ : Optional[int]=8 , lowerCAmelCase_ : int="relu6" , lowerCAmelCase_ : List[Any]=True , lowerCAmelCase_ : Optional[Any]=0.9_9_9 , lowerCAmelCase_ : Optional[Any]=0.0_2 , lowerCAmelCase_ : str=0.0_0_1 , **lowerCAmelCase_ : Any , ) -> Dict:
"""simple docstring"""
super().__init__(**lowerCAmelCase_ )
if depth_multiplier <= 0:
raise ValueError('''depth_multiplier must be greater than zero.''' )
_a = num_channels
_a = image_size
_a = depth_multiplier
_a = min_depth
_a = hidden_act
_a = tf_padding
_a = classifier_dropout_prob
_a = initializer_range
_a = layer_norm_eps
class A ( _a ):
lowercase_ = version.parse('1.11' )
@property
def __lowerCAmelCase ( self : Union[str, Any] ) -> Mapping[str, Mapping[int, str]]:
"""simple docstring"""
return OrderedDict([('''pixel_values''', {0: '''batch'''})] )
@property
def __lowerCAmelCase ( self : int ) -> Mapping[str, Mapping[int, str]]:
"""simple docstring"""
if self.task == "image-classification":
return OrderedDict([('''logits''', {0: '''batch'''})] )
else:
return OrderedDict([('''last_hidden_state''', {0: '''batch'''}), ('''pooler_output''', {0: '''batch'''})] )
@property
def __lowerCAmelCase ( self : List[Any] ) -> float:
"""simple docstring"""
return 1e-4
| 377
|
'''simple docstring'''
import argparse
import os
import numpy as np
import tensorflow as tf
import torch
from transformers import BertModel
def snake_case_ (UpperCamelCase : BertModel , UpperCamelCase : str , UpperCamelCase : str ):
'''simple docstring'''
_a = ('''dense.weight''', '''attention.self.query''', '''attention.self.key''', '''attention.self.value''')
_a = (
('''layer.''', '''layer_'''),
('''word_embeddings.weight''', '''word_embeddings'''),
('''position_embeddings.weight''', '''position_embeddings'''),
('''token_type_embeddings.weight''', '''token_type_embeddings'''),
('''.''', '''/'''),
('''LayerNorm/weight''', '''LayerNorm/gamma'''),
('''LayerNorm/bias''', '''LayerNorm/beta'''),
('''weight''', '''kernel'''),
)
if not os.path.isdir(UpperCamelCase ):
os.makedirs(UpperCamelCase )
_a = model.state_dict()
def to_tf_var_name(UpperCamelCase : str ):
for patt, repl in iter(UpperCamelCase ):
_a = name.replace(UpperCamelCase , UpperCamelCase )
return f'bert/{name}'
def create_tf_var(UpperCamelCase : np.ndarray , UpperCamelCase : str , UpperCamelCase : tf.Session ):
_a = tf.dtypes.as_dtype(tensor.dtype )
_a = tf.get_variable(dtype=UpperCamelCase , shape=tensor.shape , name=UpperCamelCase , initializer=tf.zeros_initializer() )
session.run(tf.variables_initializer([tf_var] ) )
session.run(UpperCamelCase )
return tf_var
tf.reset_default_graph()
with tf.Session() as session:
for var_name in state_dict:
_a = to_tf_var_name(UpperCamelCase )
_a = state_dict[var_name].numpy()
if any(x in var_name for x in tensors_to_transpose ):
_a = torch_tensor.T
_a = create_tf_var(tensor=UpperCamelCase , name=UpperCamelCase , session=UpperCamelCase )
tf.keras.backend.set_value(UpperCamelCase , UpperCamelCase )
_a = session.run(UpperCamelCase )
print(f'Successfully created {tf_name}: {np.allclose(UpperCamelCase , UpperCamelCase )}' )
_a = tf.train.Saver(tf.trainable_variables() )
saver.save(UpperCamelCase , os.path.join(UpperCamelCase , model_name.replace('''-''' , '''_''' ) + '''.ckpt''' ) )
def snake_case_ (UpperCamelCase : Tuple=None ):
'''simple docstring'''
_a = argparse.ArgumentParser()
parser.add_argument('''--model_name''' , type=UpperCamelCase , required=UpperCamelCase , help='''model name e.g. bert-base-uncased''' )
parser.add_argument(
'''--cache_dir''' , type=UpperCamelCase , default=UpperCamelCase , required=UpperCamelCase , help='''Directory containing pytorch model''' )
parser.add_argument('''--pytorch_model_path''' , type=UpperCamelCase , required=UpperCamelCase , help='''/path/to/<pytorch-model-name>.bin''' )
parser.add_argument('''--tf_cache_dir''' , type=UpperCamelCase , required=UpperCamelCase , help='''Directory in which to save tensorflow model''' )
_a = parser.parse_args(UpperCamelCase )
_a = BertModel.from_pretrained(
pretrained_model_name_or_path=args.model_name , state_dict=torch.load(args.pytorch_model_path ) , cache_dir=args.cache_dir , )
convert_pytorch_checkpoint_to_tf(model=UpperCamelCase , ckpt_dir=args.tf_cache_dir , model_name=args.model_name )
if __name__ == "__main__":
main()
| 377
| 1
|
"""simple docstring"""
from cva import destroyAllWindows, imread, imshow, waitKey
def lowercase ( lowerCAmelCase__ ):
# getting number of pixels in the image
lowerCamelCase_ , lowerCamelCase_ = img.shape[0], img.shape[1]
# converting each pixel's color to its negative
for i in range(lowerCAmelCase__ ):
for j in range(lowerCAmelCase__ ):
lowerCamelCase_ = [255, 255, 255] - img[i][j]
return img
if __name__ == "__main__":
# read original image
A_ = imread("""image_data/lena.jpg""", 1)
# convert to its negative
A_ = convert_to_negative(img)
# show result image
imshow("""negative of original image""", img)
waitKey(0)
destroyAllWindows()
| 29
|
def __SCREAMING_SNAKE_CASE ( UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ = 0 , UpperCamelCase__ = 0 ) -> int:
'''simple docstring'''
UpperCAmelCase = right or len(UpperCamelCase__ ) - 1
if left > right:
return -1
elif list_data[left] == key:
return left
elif list_data[right] == key:
return right
else:
return search(UpperCamelCase__ , UpperCamelCase__ , left + 1 , right - 1 )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 130
| 0
|
'''simple docstring'''
from __future__ import annotations
def UpperCAmelCase_ ( A ):
'''simple docstring'''
return [ord(__a ) - 9_6 for elem in plain]
def UpperCAmelCase_ ( A ):
'''simple docstring'''
return "".join(chr(elem + 9_6 ) for elem in encoded )
def UpperCAmelCase_ ( ):
'''simple docstring'''
_a : Dict = encode(input('-> ' ).strip().lower() )
print('Encoded: ' , __a )
print('Decoded:' , decode(__a ) )
if __name__ == "__main__":
main()
| 720
|
'''simple docstring'''
import qiskit
def UpperCAmelCase_ ( A = 2 ):
'''simple docstring'''
_a : Union[str, Any] = qubits
# Using Aer's simulator
_a : str = qiskit.Aer.get_backend('aer_simulator' )
# Creating a Quantum Circuit acting on the q register
_a : Tuple = qiskit.QuantumCircuit(A , A )
# Adding a H gate on qubit 0 (now q0 in superposition)
circuit.h(0 )
for i in range(1 , A ):
# Adding CX (CNOT) gate
circuit.cx(i - 1 , A )
# Mapping the quantum measurement to the classical bits
circuit.measure(list(range(A ) ) , list(range(A ) ) )
# 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
_a : Optional[int] = qiskit.execute(A , A , shots=1_0_0_0 )
return job.result().get_counts(A )
if __name__ == "__main__":
print(f'''Total count for various states are: {quantum_entanglement(3)}''')
| 424
| 0
|
import copy
from collections import OrderedDict
from typing import Dict, Mapping
from packaging import version
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING
A_ : Optional[int] = logging.get_logger(__name__)
A_ : Optional[int] = {
"facebook/detr-resnet-50": "https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json",
# See all DETR models at https://huggingface.co/models?filter=detr
}
class _a (_lowerCamelCase ):
'''simple docstring'''
UpperCAmelCase__: Tuple = '''detr'''
UpperCAmelCase__: Union[str, Any] = ['''past_key_values''']
UpperCAmelCase__: Dict = {
'''hidden_size''': '''d_model''',
'''num_attention_heads''': '''encoder_attention_heads''',
}
def __init__( self , A__=True , A__=None , A__=3 , A__=100 , A__=6 , A__=2048 , A__=8 , A__=6 , A__=2048 , A__=8 , A__=0.0 , A__=0.0 , A__=True , A__="relu" , A__=256 , A__=0.1 , A__=0.0 , A__=0.0 , A__=0.0_2 , A__=1.0 , A__=False , A__="sine" , A__="resnet50" , A__=True , A__=False , A__=1 , A__=5 , A__=2 , A__=1 , A__=1 , A__=5 , A__=2 , A__=0.1 , **A__ , ):
if backbone_config is not None and use_timm_backbone:
raise ValueError("""You can't specify both `backbone_config` and `use_timm_backbone`.""" )
if not use_timm_backbone:
if backbone_config is None:
logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.""" )
A__ : Dict = CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""] )
elif isinstance(A__ , A__ ):
A__ : Optional[int] = backbone_config.get("""model_type""" )
A__ : Tuple = CONFIG_MAPPING[backbone_model_type]
A__ : Tuple = config_class.from_dict(A__ )
# set timm attributes to None
A__ , A__ , A__ : Tuple = None, None, None
A__ : int = use_timm_backbone
A__ : Optional[int] = backbone_config
A__ : Optional[int] = num_channels
A__ : Any = num_queries
A__ : int = d_model
A__ : str = encoder_ffn_dim
A__ : Tuple = encoder_layers
A__ : str = encoder_attention_heads
A__ : str = decoder_ffn_dim
A__ : Dict = decoder_layers
A__ : List[Any] = decoder_attention_heads
A__ : int = dropout
A__ : Union[str, Any] = attention_dropout
A__ : Optional[Any] = activation_dropout
A__ : List[str] = activation_function
A__ : Tuple = init_std
A__ : List[str] = init_xavier_std
A__ : str = encoder_layerdrop
A__ : List[Any] = decoder_layerdrop
A__ : Dict = encoder_layers
A__ : Optional[int] = auxiliary_loss
A__ : Any = position_embedding_type
A__ : Optional[int] = backbone
A__ : Union[str, Any] = use_pretrained_backbone
A__ : Any = dilation
# Hungarian matcher
A__ : List[str] = class_cost
A__ : Optional[int] = bbox_cost
A__ : Union[str, Any] = giou_cost
# Loss coefficients
A__ : Optional[Any] = mask_loss_coefficient
A__ : int = dice_loss_coefficient
A__ : Dict = bbox_loss_coefficient
A__ : Optional[int] = giou_loss_coefficient
A__ : Optional[int] = eos_coefficient
super().__init__(is_encoder_decoder=A__ , **A__ )
@property
def __A ( self ):
return self.encoder_attention_heads
@property
def __A ( self ):
return self.d_model
@classmethod
def __A ( cls , A__ , **A__ ):
return cls(backbone_config=A__ , **A__ )
def __A ( self ):
A__ : Any = copy.deepcopy(self.__dict__ )
if output["backbone_config"] is not None:
A__ : Union[str, Any] = self.backbone_config.to_dict()
A__ : str = self.__class__.model_type
return output
class _a (_lowerCamelCase ):
'''simple docstring'''
UpperCAmelCase__: Optional[int] = version.parse('''1.11''' )
@property
def __A ( self ):
return OrderedDict(
[
("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
("""pixel_mask""", {0: """batch"""}),
] )
@property
def __A ( self ):
return 1e-5
@property
def __A ( self ):
return 12
| 456
|
'''simple docstring'''
import math
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ = 0 , SCREAMING_SNAKE_CASE_ = 0 ) -> list:
"""simple docstring"""
_SCREAMING_SNAKE_CASE = end or len(SCREAMING_SNAKE_CASE_ )
for i in range(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ):
_SCREAMING_SNAKE_CASE = i
_SCREAMING_SNAKE_CASE = array[i]
while temp_index != start and temp_index_value < array[temp_index - 1]:
_SCREAMING_SNAKE_CASE = array[temp_index - 1]
temp_index -= 1
_SCREAMING_SNAKE_CASE = temp_index_value
return array
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) -> None: # Max Heap
"""simple docstring"""
_SCREAMING_SNAKE_CASE = index
_SCREAMING_SNAKE_CASE = 2 * index + 1 # Left Node
_SCREAMING_SNAKE_CASE = 2 * index + 2 # Right Node
if left_index < heap_size and array[largest] < array[left_index]:
_SCREAMING_SNAKE_CASE = left_index
if right_index < heap_size and array[largest] < array[right_index]:
_SCREAMING_SNAKE_CASE = right_index
if largest != index:
_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = array[largest], array[index]
heapify(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ ) -> list:
"""simple docstring"""
_SCREAMING_SNAKE_CASE = len(SCREAMING_SNAKE_CASE_ )
for i in range(n // 2 , -1 , -1 ):
heapify(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
for i in range(n - 1 , 0 , -1 ):
_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = array[0], array[i]
heapify(SCREAMING_SNAKE_CASE_ , 0 , SCREAMING_SNAKE_CASE_ )
return array
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) -> int:
"""simple docstring"""
if (array[first_index] > array[middle_index]) != (
array[first_index] > array[last_index]
):
return array[first_index]
elif (array[middle_index] > array[first_index]) != (
array[middle_index] > array[last_index]
):
return array[middle_index]
else:
return array[last_index]
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) -> int:
"""simple docstring"""
_SCREAMING_SNAKE_CASE = low
_SCREAMING_SNAKE_CASE = high
while True:
while array[i] < pivot:
i += 1
j -= 1
while pivot < array[j]:
j -= 1
if i >= j:
return i
_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = array[j], array[i]
i += 1
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ ) -> list:
"""simple docstring"""
if len(SCREAMING_SNAKE_CASE_ ) == 0:
return array
_SCREAMING_SNAKE_CASE = 2 * math.ceil(math.loga(len(SCREAMING_SNAKE_CASE_ ) ) )
_SCREAMING_SNAKE_CASE = 16
return intro_sort(SCREAMING_SNAKE_CASE_ , 0 , len(SCREAMING_SNAKE_CASE_ ) , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
def lowerCAmelCase_ ( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) -> list:
"""simple docstring"""
while end - start > size_threshold:
if max_depth == 0:
return heap_sort(SCREAMING_SNAKE_CASE_ )
max_depth -= 1
_SCREAMING_SNAKE_CASE = median_of_a(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , start + ((end - start) // 2) + 1 , end - 1 )
_SCREAMING_SNAKE_CASE = partition(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
intro_sort(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
_SCREAMING_SNAKE_CASE = p
return insertion_sort(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ )
if __name__ == "__main__":
import doctest
doctest.testmod()
UpperCamelCase__ : Tuple = input("Enter numbers separated by a comma : ").strip()
UpperCamelCase__ : List[Any] = [float(item) for item in user_input.split(",")]
print(sort(unsorted))
| 591
| 0
|
"""simple docstring"""
import math
def lowerCAmelCase ( UpperCamelCase_: int ) -> bool:
'''simple docstring'''
if 1 < number < 4:
# 2 and 3 are primes
return True
elif number < 2 or number % 2 == 0 or number % 3 == 0:
# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
return False
# All primes number are in format of 6k +/- 1
for i in range(5 , int(math.sqrt(UpperCamelCase_ ) + 1 ) , 6 ):
if number % i == 0 or number % (i + 2) == 0:
return False
return True
def lowerCAmelCase ( UpperCamelCase_: int = 10001 ) -> int:
'''simple docstring'''
try:
_a = int(UpperCamelCase_ )
except (TypeError, ValueError):
raise TypeError("Parameter nth must be int or castable to int." ) from None
if nth <= 0:
raise ValueError("Parameter nth must be greater than or equal to one." )
_a = []
_a = 2
while len(UpperCamelCase_ ) < nth:
if is_prime(UpperCamelCase_ ):
primes.append(UpperCamelCase_ )
num += 1
else:
num += 1
return primes[len(UpperCamelCase_ ) - 1]
if __name__ == "__main__":
print(f"{solution() = }")
| 612
|
"""simple docstring"""
import warnings
from ...utils import logging
from .image_processing_yolos import YolosImageProcessor
UpperCamelCase = logging.get_logger(__name__)
class lowercase_ (_UpperCAmelCase ):
def __init__( self , *a_ , **a_ ) ->None:
'''simple docstring'''
warnings.warn(
"The class YolosFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
" use YolosImageProcessor instead." , a_ , )
super().__init__(*a_ , **a_ )
| 612
| 1
|
from collections import OrderedDict
from typing import List, Mapping
from packaging import version
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
_UpperCAmelCase = logging.get_logger(__name__)
_UpperCAmelCase = {
'google/efficientnet-b7': 'https://huggingface.co/google/efficientnet-b7/resolve/main/config.json',
}
class snake_case_ ( __lowercase ):
A_ = 'efficientnet'
def __init__( self : Union[str, Any] , _snake_case : int = 3 , _snake_case : int = 600 , _snake_case : float = 2.0 , _snake_case : float = 3.1 , _snake_case : int = 8 , _snake_case : List[int] = [3, 3, 5, 3, 5, 5, 3] , _snake_case : List[int] = [32, 16, 24, 40, 80, 112, 192] , _snake_case : List[int] = [16, 24, 40, 80, 112, 192, 320] , _snake_case : List[int] = [] , _snake_case : List[int] = [1, 2, 2, 2, 1, 2, 1] , _snake_case : List[int] = [1, 2, 2, 3, 3, 4, 1] , _snake_case : List[int] = [1, 6, 6, 6, 6, 6, 6] , _snake_case : float = 0.25 , _snake_case : str = "swish" , _snake_case : int = 2560 , _snake_case : str = "mean" , _snake_case : float = 0.02 , _snake_case : float = 0.001 , _snake_case : float = 0.99 , _snake_case : float = 0.5 , _snake_case : float = 0.2 , **_snake_case : str , )->int:
'''simple docstring'''
super().__init__(**_snake_case )
__lowerCAmelCase : Optional[int] = num_channels
__lowerCAmelCase : List[str] = image_size
__lowerCAmelCase : Any = width_coefficient
__lowerCAmelCase : Optional[int] = depth_coefficient
__lowerCAmelCase : Any = depth_divisor
__lowerCAmelCase : Dict = kernel_sizes
__lowerCAmelCase : Dict = in_channels
__lowerCAmelCase : Union[str, Any] = out_channels
__lowerCAmelCase : Dict = depthwise_padding
__lowerCAmelCase : Optional[int] = strides
__lowerCAmelCase : List[Any] = num_block_repeats
__lowerCAmelCase : Optional[int] = expand_ratios
__lowerCAmelCase : Any = squeeze_expansion_ratio
__lowerCAmelCase : str = hidden_act
__lowerCAmelCase : int = hidden_dim
__lowerCAmelCase : Tuple = pooling_type
__lowerCAmelCase : List[Any] = initializer_range
__lowerCAmelCase : int = batch_norm_eps
__lowerCAmelCase : Any = batch_norm_momentum
__lowerCAmelCase : List[str] = dropout_rate
__lowerCAmelCase : Optional[Any] = drop_connect_rate
__lowerCAmelCase : str = sum(_snake_case ) * 4
class snake_case_ ( __lowercase ):
A_ = version.parse('1.11' )
@property
def UpperCAmelCase__ ( self : Union[str, Any] )->Mapping[str, Mapping[int, str]]:
'''simple docstring'''
return OrderedDict(
[
("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
] )
@property
def UpperCAmelCase__ ( self : str )->float:
'''simple docstring'''
return 1E-5
| 504
|
import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import Callable, Dict, List, Tuple
import timm
import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams, RegNetYaagf, RegNetYaagf, RegNetYaaagf
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs
from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.utils import logging
logging.set_verbosity_info()
_UpperCAmelCase = logging.get_logger()
@dataclass
class snake_case_ :
A_ = 42
A_ = field(default_factory=__lowercase )
A_ = field(default_factory=__lowercase )
def UpperCAmelCase__ ( self : Union[str, Any] , _snake_case : Dict , _snake_case : Tensor , _snake_case : Tensor )->List[str]:
'''simple docstring'''
__lowerCAmelCase : Union[str, Any] = len(list(m.modules() ) ) == 1 or isinstance(_snake_case , nn.Convad ) or isinstance(_snake_case , nn.BatchNormad )
if has_not_submodules:
self.traced.append(_snake_case )
def __call__( self : Optional[Any] , _snake_case : Tensor )->List[Any]:
'''simple docstring'''
for m in self.module.modules():
self.handles.append(m.register_forward_hook(self._forward_hook ) )
self.module(_snake_case )
[x.remove() for x in self.handles]
return self
@property
def UpperCAmelCase__ ( self : int )->List[str]:
'''simple docstring'''
return list(filter(lambda _snake_case : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) )
@dataclass
class snake_case_ :
A_ = 42
A_ = 42
A_ = 1
A_ = field(default_factory=__lowercase )
A_ = field(default_factory=__lowercase )
A_ = True
def __call__( self : Tuple , _snake_case : Tensor )->List[str]:
'''simple docstring'''
__lowerCAmelCase : int = Tracker(self.dest )(_snake_case ).parametrized
__lowerCAmelCase : List[str] = Tracker(self.src )(_snake_case ).parametrized
__lowerCAmelCase : int = list(filter(lambda _snake_case : type(_snake_case ) not in self.src_skip , _snake_case ) )
__lowerCAmelCase : List[str] = list(filter(lambda _snake_case : type(_snake_case ) not in self.dest_skip , _snake_case ) )
if len(_snake_case ) != len(_snake_case ) and self.raise_if_mismatch:
raise Exception(
F'''Numbers of operations are different. Source module has {len(_snake_case )} operations while'''
F''' destination module has {len(_snake_case )}.''' )
for dest_m, src_m in zip(_snake_case , _snake_case ):
dest_m.load_state_dict(src_m.state_dict() )
if self.verbose == 1:
print(F'''Transfered from={src_m} to={dest_m}''' )
class snake_case_ ( nn.Module ):
def __init__( self : Any , _snake_case : nn.Module )->str:
'''simple docstring'''
super().__init__()
__lowerCAmelCase : List[Tuple[str, nn.Module]] = []
# - get the stem
feature_blocks.append(("""conv1""", model.stem) )
# - get all the feature blocks
for k, v in model.trunk_output.named_children():
assert k.startswith("""block""" ), F'''Unexpected layer name {k}'''
__lowerCAmelCase : List[str] = len(_snake_case ) + 1
feature_blocks.append((F'''res{block_index}''', v) )
__lowerCAmelCase : List[Any] = nn.ModuleDict(_snake_case )
def UpperCAmelCase__ ( self : Optional[Any] , _snake_case : Tensor )->Optional[int]:
'''simple docstring'''
return get_trunk_forward_outputs(
_snake_case , out_feat_keys=_snake_case , feature_blocks=self._feature_blocks , )
class snake_case_ ( __lowercase ):
def UpperCAmelCase__ ( self : List[str] , _snake_case : str )->str:
'''simple docstring'''
__lowerCAmelCase : Optional[Any] = x.split("""-""" )
return x_split[0] + x_split[1] + "_" + "".join(x_split[2:] )
def __getitem__( self : Optional[int] , _snake_case : str )->Callable[[], Tuple[nn.Module, Dict]]:
'''simple docstring'''
if x not in self:
__lowerCAmelCase : int = self.convert_name_to_timm(_snake_case )
__lowerCAmelCase : List[Any] = partial(lambda: (timm.create_model(_snake_case , pretrained=_snake_case ).eval(), None) )
else:
__lowerCAmelCase : Optional[Any] = super().__getitem__(_snake_case )
return val
class snake_case_ ( __lowercase ):
def __getitem__( self : Union[str, Any] , _snake_case : str )->Callable[[], nn.Module]:
'''simple docstring'''
if "seer" in x and "in1k" not in x:
__lowerCAmelCase : Optional[int] = RegNetModel
else:
__lowerCAmelCase : str = RegNetForImageClassification
return val
def _SCREAMING_SNAKE_CASE ( SCREAMING_SNAKE_CASE :int , SCREAMING_SNAKE_CASE :Any , SCREAMING_SNAKE_CASE :List[Tuple[str, str]] ) -> Any:
for from_key, to_key in keys:
__lowerCAmelCase : List[Any] = from_state_dict[from_key].clone()
print(F'''Copied key={from_key} to={to_key}''' )
return to_state_dict
def _SCREAMING_SNAKE_CASE ( SCREAMING_SNAKE_CASE :str , SCREAMING_SNAKE_CASE :Callable[[], nn.Module] , SCREAMING_SNAKE_CASE :Callable[[], nn.Module] , SCREAMING_SNAKE_CASE :RegNetConfig , SCREAMING_SNAKE_CASE :Path , SCREAMING_SNAKE_CASE :bool = True , ) -> Union[str, Any]:
print(F'''Converting {name}...''' )
with torch.no_grad():
__lowerCAmelCase , __lowerCAmelCase : List[Any] = from_model_func()
__lowerCAmelCase : int = our_model_func(SCREAMING_SNAKE_CASE ).eval()
__lowerCAmelCase : Any = ModuleTransfer(src=SCREAMING_SNAKE_CASE , dest=SCREAMING_SNAKE_CASE , raise_if_mismatch=SCREAMING_SNAKE_CASE )
__lowerCAmelCase : Optional[int] = torch.randn((1, 3, 224, 224) )
module_transfer(SCREAMING_SNAKE_CASE )
if from_state_dict is not None:
__lowerCAmelCase : str = []
# for seer - in1k finetuned we have to manually copy the head
if "seer" in name and "in1k" in name:
__lowerCAmelCase : Optional[int] = [("""0.clf.0.weight""", """classifier.1.weight"""), ("""0.clf.0.bias""", """classifier.1.bias""")]
__lowerCAmelCase : Any = manually_copy_vissl_head(SCREAMING_SNAKE_CASE , our_model.state_dict() , SCREAMING_SNAKE_CASE )
our_model.load_state_dict(SCREAMING_SNAKE_CASE )
__lowerCAmelCase : List[str] = our_model(SCREAMING_SNAKE_CASE , output_hidden_states=SCREAMING_SNAKE_CASE )
__lowerCAmelCase : Any = (
our_outputs.logits if isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) else our_outputs.last_hidden_state
)
__lowerCAmelCase : Optional[int] = from_model(SCREAMING_SNAKE_CASE )
__lowerCAmelCase : int = from_output[-1] if type(SCREAMING_SNAKE_CASE ) is list else from_output
# now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state
if "seer" in name and "in1k" in name:
__lowerCAmelCase : Union[str, Any] = our_outputs.hidden_states[-1]
assert torch.allclose(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ), "The model logits don't match the original one."
if push_to_hub:
our_model.push_to_hub(
repo_path_or_name=save_directory / name , commit_message="""Add model""" , use_temp_dir=SCREAMING_SNAKE_CASE , )
__lowerCAmelCase : List[str] = 224 if """seer""" not in name else 384
# we can use the convnext one
__lowerCAmelCase : Union[str, Any] = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" , size=SCREAMING_SNAKE_CASE )
image_processor.push_to_hub(
repo_path_or_name=save_directory / name , commit_message="""Add image processor""" , use_temp_dir=SCREAMING_SNAKE_CASE , )
print(F'''Pushed {name}''' )
def _SCREAMING_SNAKE_CASE ( SCREAMING_SNAKE_CASE :Path , SCREAMING_SNAKE_CASE :str = None , SCREAMING_SNAKE_CASE :bool = True ) -> Union[str, Any]:
__lowerCAmelCase : List[str] = """imagenet-1k-id2label.json"""
__lowerCAmelCase : str = 1_000
__lowerCAmelCase : Dict = (1, num_labels)
__lowerCAmelCase : Dict = """huggingface/label-files"""
__lowerCAmelCase : Tuple = num_labels
__lowerCAmelCase : str = json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , repo_type="""dataset""" ) ) , """r""" ) )
__lowerCAmelCase : List[Any] = {int(SCREAMING_SNAKE_CASE ): v for k, v in idalabel.items()}
__lowerCAmelCase : Optional[int] = idalabel
__lowerCAmelCase : int = {v: k for k, v in idalabel.items()}
__lowerCAmelCase : List[str] = partial(SCREAMING_SNAKE_CASE , num_labels=SCREAMING_SNAKE_CASE , idalabel=SCREAMING_SNAKE_CASE , labelaid=SCREAMING_SNAKE_CASE )
__lowerCAmelCase : Tuple = {
"""regnet-x-002""": ImageNetPreTrainedConfig(
depths=[1, 1, 4, 7] , hidden_sizes=[24, 56, 152, 368] , groups_width=8 , layer_type="""x""" ),
"""regnet-x-004""": ImageNetPreTrainedConfig(
depths=[1, 2, 7, 12] , hidden_sizes=[32, 64, 160, 384] , groups_width=16 , layer_type="""x""" ),
"""regnet-x-006""": ImageNetPreTrainedConfig(
depths=[1, 3, 5, 7] , hidden_sizes=[48, 96, 240, 528] , groups_width=24 , layer_type="""x""" ),
"""regnet-x-008""": ImageNetPreTrainedConfig(
depths=[1, 3, 7, 5] , hidden_sizes=[64, 128, 288, 672] , groups_width=16 , layer_type="""x""" ),
"""regnet-x-016""": ImageNetPreTrainedConfig(
depths=[2, 4, 10, 2] , hidden_sizes=[72, 168, 408, 912] , groups_width=24 , layer_type="""x""" ),
"""regnet-x-032""": ImageNetPreTrainedConfig(
depths=[2, 6, 15, 2] , hidden_sizes=[96, 192, 432, 1_008] , groups_width=48 , layer_type="""x""" ),
"""regnet-x-040""": ImageNetPreTrainedConfig(
depths=[2, 5, 14, 2] , hidden_sizes=[80, 240, 560, 1_360] , groups_width=40 , layer_type="""x""" ),
"""regnet-x-064""": ImageNetPreTrainedConfig(
depths=[2, 4, 10, 1] , hidden_sizes=[168, 392, 784, 1_624] , groups_width=56 , layer_type="""x""" ),
"""regnet-x-080""": ImageNetPreTrainedConfig(
depths=[2, 5, 15, 1] , hidden_sizes=[80, 240, 720, 1_920] , groups_width=120 , layer_type="""x""" ),
"""regnet-x-120""": ImageNetPreTrainedConfig(
depths=[2, 5, 11, 1] , hidden_sizes=[224, 448, 896, 2_240] , groups_width=112 , layer_type="""x""" ),
"""regnet-x-160""": ImageNetPreTrainedConfig(
depths=[2, 6, 13, 1] , hidden_sizes=[256, 512, 896, 2_048] , groups_width=128 , layer_type="""x""" ),
"""regnet-x-320""": ImageNetPreTrainedConfig(
depths=[2, 7, 13, 1] , hidden_sizes=[336, 672, 1_344, 2_520] , groups_width=168 , layer_type="""x""" ),
# y variant
"""regnet-y-002""": ImageNetPreTrainedConfig(depths=[1, 1, 4, 7] , hidden_sizes=[24, 56, 152, 368] , groups_width=8 ),
"""regnet-y-004""": ImageNetPreTrainedConfig(
depths=[1, 3, 6, 6] , hidden_sizes=[48, 104, 208, 440] , groups_width=8 ),
"""regnet-y-006""": ImageNetPreTrainedConfig(
depths=[1, 3, 7, 4] , hidden_sizes=[48, 112, 256, 608] , groups_width=16 ),
"""regnet-y-008""": ImageNetPreTrainedConfig(
depths=[1, 3, 8, 2] , hidden_sizes=[64, 128, 320, 768] , groups_width=16 ),
"""regnet-y-016""": ImageNetPreTrainedConfig(
depths=[2, 6, 17, 2] , hidden_sizes=[48, 120, 336, 888] , groups_width=24 ),
"""regnet-y-032""": ImageNetPreTrainedConfig(
depths=[2, 5, 13, 1] , hidden_sizes=[72, 216, 576, 1_512] , groups_width=24 ),
"""regnet-y-040""": ImageNetPreTrainedConfig(
depths=[2, 6, 12, 2] , hidden_sizes=[128, 192, 512, 1_088] , groups_width=64 ),
"""regnet-y-064""": ImageNetPreTrainedConfig(
depths=[2, 7, 14, 2] , hidden_sizes=[144, 288, 576, 1_296] , groups_width=72 ),
"""regnet-y-080""": ImageNetPreTrainedConfig(
depths=[2, 4, 10, 1] , hidden_sizes=[168, 448, 896, 2_016] , groups_width=56 ),
"""regnet-y-120""": ImageNetPreTrainedConfig(
depths=[2, 5, 11, 1] , hidden_sizes=[224, 448, 896, 2_240] , groups_width=112 ),
"""regnet-y-160""": ImageNetPreTrainedConfig(
depths=[2, 4, 11, 1] , hidden_sizes=[224, 448, 1_232, 3_024] , groups_width=112 ),
"""regnet-y-320""": ImageNetPreTrainedConfig(
depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1_392, 3_712] , groups_width=232 ),
# models created by SEER -> https://arxiv.org/abs/2202.08360
"""regnet-y-320-seer""": RegNetConfig(depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1_392, 3_712] , groups_width=232 ),
"""regnet-y-640-seer""": RegNetConfig(depths=[2, 5, 12, 1] , hidden_sizes=[328, 984, 1_968, 4_920] , groups_width=328 ),
"""regnet-y-1280-seer""": RegNetConfig(
depths=[2, 7, 17, 1] , hidden_sizes=[528, 1_056, 2_904, 7_392] , groups_width=264 ),
"""regnet-y-2560-seer""": RegNetConfig(
depths=[3, 7, 16, 1] , hidden_sizes=[640, 1_696, 2_544, 5_088] , groups_width=640 ),
"""regnet-y-10b-seer""": ImageNetPreTrainedConfig(
depths=[2, 7, 17, 1] , hidden_sizes=[2_020, 4_040, 11_110, 28_280] , groups_width=1_010 ),
# finetuned on imagenet
"""regnet-y-320-seer-in1k""": ImageNetPreTrainedConfig(
depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1_392, 3_712] , groups_width=232 ),
"""regnet-y-640-seer-in1k""": ImageNetPreTrainedConfig(
depths=[2, 5, 12, 1] , hidden_sizes=[328, 984, 1_968, 4_920] , groups_width=328 ),
"""regnet-y-1280-seer-in1k""": ImageNetPreTrainedConfig(
depths=[2, 7, 17, 1] , hidden_sizes=[528, 1_056, 2_904, 7_392] , groups_width=264 ),
"""regnet-y-2560-seer-in1k""": ImageNetPreTrainedConfig(
depths=[3, 7, 16, 1] , hidden_sizes=[640, 1_696, 2_544, 5_088] , groups_width=640 ),
"""regnet-y-10b-seer-in1k""": ImageNetPreTrainedConfig(
depths=[2, 7, 17, 1] , hidden_sizes=[2_020, 4_040, 11_110, 28_280] , groups_width=1_010 ),
}
__lowerCAmelCase : Dict = NameToOurModelFuncMap()
__lowerCAmelCase : Any = NameToFromModelFuncMap()
# add seer weights logic
def load_using_classy_vision(SCREAMING_SNAKE_CASE :str , SCREAMING_SNAKE_CASE :Callable[[], nn.Module] ) -> Tuple[nn.Module, Dict]:
__lowerCAmelCase : Optional[int] = torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE , model_dir=str(SCREAMING_SNAKE_CASE ) , map_location="""cpu""" )
__lowerCAmelCase : Optional[Any] = model_func()
# check if we have a head, if yes add it
__lowerCAmelCase : List[Any] = files["""classy_state_dict"""]["""base_model"""]["""model"""]
__lowerCAmelCase : List[Any] = model_state_dict["""trunk"""]
model.load_state_dict(SCREAMING_SNAKE_CASE )
return model.eval(), model_state_dict["heads"]
# pretrained
__lowerCAmelCase : Optional[int] = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaagf() ) , )
__lowerCAmelCase : Dict = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaagf() ) , )
__lowerCAmelCase : List[str] = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaaagf() ) , )
__lowerCAmelCase : Union[str, Any] = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch""" , lambda: FakeRegNetVisslWrapper(
RegNet(RegNetParams(depth=27 , group_width=1_010 , w_a=1_744 , w_a=6_20.83 , w_m=2.52 ) ) ) , )
# IN1K finetuned
__lowerCAmelCase : Dict = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaagf() ) , )
__lowerCAmelCase : int = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaagf() ) , )
__lowerCAmelCase : Union[str, Any] = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch""" , lambda: FakeRegNetVisslWrapper(RegNetYaaagf() ) , )
__lowerCAmelCase : int = partial(
SCREAMING_SNAKE_CASE , """https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch""" , lambda: FakeRegNetVisslWrapper(
RegNet(RegNetParams(depth=27 , group_width=1_010 , w_a=1_744 , w_a=6_20.83 , w_m=2.52 ) ) ) , )
if model_name:
convert_weight_and_push(
SCREAMING_SNAKE_CASE , names_to_from_model_map[model_name] , names_to_ours_model_map[model_name] , names_to_config[model_name] , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , )
else:
for model_name, config in names_to_config.items():
convert_weight_and_push(
SCREAMING_SNAKE_CASE , names_to_from_model_map[model_name] , names_to_ours_model_map[model_name] , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , )
return config, expected_shape
if __name__ == "__main__":
_UpperCAmelCase = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--model_name',
default=None,
type=str,
help=(
'The name of the model you wish to convert, it must be one of the supported regnet* architecture,'
' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'
),
)
parser.add_argument(
'--pytorch_dump_folder_path',
default=None,
type=Path,
required=True,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub',
default=True,
type=bool,
required=False,
help='If True, push model and image processor to the hub.',
)
_UpperCAmelCase = parser.parse_args()
_UpperCAmelCase = args.pytorch_dump_folder_path
pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
| 504
| 1
|
"""simple docstring"""
__magic_name__ = {
0: """0""",
1: """1""",
2: """2""",
3: """3""",
4: """4""",
5: """5""",
6: """6""",
7: """7""",
8: """8""",
9: """9""",
10: """a""",
11: """b""",
12: """c""",
13: """d""",
14: """e""",
15: """f""",
}
def _A ( __lowercase ):
"""simple docstring"""
assert type(__lowercase ) in (int, float) and decimal == int(__lowercase )
lowerCamelCase__ = int(__lowercase )
lowerCamelCase__ = """"""
lowerCamelCase__ = False
if decimal < 0:
lowerCamelCase__ = True
decimal *= -1
while decimal > 0:
lowerCamelCase__ , lowerCamelCase__ = divmod(__lowercase , 16 )
lowerCamelCase__ = values[remainder] + hexadecimal
lowerCamelCase__ = """0x""" + hexadecimal
if negative:
lowerCamelCase__ = """-""" + hexadecimal
return hexadecimal
if __name__ == "__main__":
import doctest
doctest.testmod()
| 713
|
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
__magic_name__ = {
"""configuration_encodec""": [
"""ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP""",
"""EncodecConfig""",
],
"""feature_extraction_encodec""": ["""EncodecFeatureExtractor"""],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
__magic_name__ = [
"""ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""EncodecModel""",
"""EncodecPreTrainedModel""",
]
if TYPE_CHECKING:
from .configuration_encodec import (
ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
EncodecConfig,
)
from .feature_extraction_encodec import EncodecFeatureExtractor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_encodec import (
ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
EncodecModel,
EncodecPreTrainedModel,
)
else:
import sys
__magic_name__ = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 258
| 0
|
'''simple docstring'''
import functools
import operator
from ...configuration_utils import PretrainedConfig
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {
"""asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
# See all SEW-D models at https://huggingface.co/models?filter=sew-d
}
class UpperCAmelCase_ ( _SCREAMING_SNAKE_CASE ):
'''simple docstring'''
_lowercase : List[Any] = '''sew-d'''
def __init__( self , _lowercase=32 , _lowercase=768 , _lowercase=12 , _lowercase=12 , _lowercase=3_072 , _lowercase=2 , _lowercase=512 , _lowercase=256 , _lowercase=True , _lowercase=True , _lowercase=("p2c", "c2p") , _lowercase="layer_norm" , _lowercase="gelu_python" , _lowercase=0.1 , _lowercase=0.1 , _lowercase=0.1 , _lowercase=0.0 , _lowercase=0.1 , _lowercase=0.02 , _lowercase=1e-7 , _lowercase=1e-5 , _lowercase="group" , _lowercase="gelu" , _lowercase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512) , _lowercase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , _lowercase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , _lowercase=False , _lowercase=128 , _lowercase=16 , _lowercase=True , _lowercase=0.05 , _lowercase=10 , _lowercase=2 , _lowercase=0.0 , _lowercase=10 , _lowercase=0 , _lowercase="mean" , _lowercase=False , _lowercase=False , _lowercase=256 , _lowercase=0 , _lowercase=1 , _lowercase=2 , **_lowercase , ):
"""simple docstring"""
super().__init__(**_lowercase , pad_token_id=_lowercase , bos_token_id=_lowercase , eos_token_id=_lowercase )
_lowerCAmelCase = hidden_size
_lowerCAmelCase = feat_extract_norm
_lowerCAmelCase = feat_extract_activation
_lowerCAmelCase = list(_lowercase )
_lowerCAmelCase = list(_lowercase )
_lowerCAmelCase = list(_lowercase )
_lowerCAmelCase = conv_bias
_lowerCAmelCase = num_conv_pos_embeddings
_lowerCAmelCase = num_conv_pos_embedding_groups
_lowerCAmelCase = len(self.conv_dim )
_lowerCAmelCase = num_hidden_layers
_lowerCAmelCase = intermediate_size
_lowerCAmelCase = squeeze_factor
_lowerCAmelCase = max_position_embeddings
_lowerCAmelCase = position_buckets
_lowerCAmelCase = share_att_key
_lowerCAmelCase = relative_attention
_lowerCAmelCase = norm_rel_ebd
_lowerCAmelCase = list(_lowercase )
_lowerCAmelCase = hidden_act
_lowerCAmelCase = num_attention_heads
_lowerCAmelCase = hidden_dropout
_lowerCAmelCase = attention_dropout
_lowerCAmelCase = activation_dropout
_lowerCAmelCase = feat_proj_dropout
_lowerCAmelCase = final_dropout
_lowerCAmelCase = layer_norm_eps
_lowerCAmelCase = feature_layer_norm_eps
_lowerCAmelCase = initializer_range
_lowerCAmelCase = vocab_size
if (
(len(self.conv_stride ) != self.num_feat_extract_layers)
or (len(self.conv_kernel ) != self.num_feat_extract_layers)
or (len(self.conv_dim ) != self.num_feat_extract_layers)
):
raise ValueError(
"""Configuration for convolutional layers is incorrect."""
"""It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,"""
F'but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)'
F'= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.' )
# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
_lowerCAmelCase = apply_spec_augment
_lowerCAmelCase = mask_time_prob
_lowerCAmelCase = mask_time_length
_lowerCAmelCase = mask_time_min_masks
_lowerCAmelCase = mask_feature_prob
_lowerCAmelCase = mask_feature_length
_lowerCAmelCase = mask_feature_min_masks
# ctc loss
_lowerCAmelCase = ctc_loss_reduction
_lowerCAmelCase = ctc_zero_infinity
# sequence classification
_lowerCAmelCase = use_weighted_layer_sum
_lowerCAmelCase = classifier_proj_size
@property
def _lowercase ( self ):
"""simple docstring"""
return functools.reduce(operator.mul , self.conv_stride , 1 )
| 5
|
'''simple docstring'''
from __future__ import annotations
import csv
import requests
from bsa import BeautifulSoup
def SCREAMING_SNAKE_CASE ( a_ : str = "" ):
__a = url or 'https://www.imdb.com/chart/top/?ref_=nv_mv_250'
__a = BeautifulSoup(requests.get(a_ ).text , 'html.parser' )
__a = soup.find_all('td' , attrs='titleColumn' )
__a = soup.find_all('td' , class_='ratingColumn imdbRating' )
return {
title.a.text: float(rating.strong.text )
for title, rating in zip(a_ , a_ )
}
def SCREAMING_SNAKE_CASE ( a_ : str = "IMDb_Top_250_Movies.csv" ):
__a = get_imdb_top_aaa_movies()
with open(a_ , 'w' , newline='' ) as out_file:
__a = csv.writer(a_ )
writer.writerow(['Movie title', 'IMDb rating'] )
for title, rating in movies.items():
writer.writerow([title, rating] )
if __name__ == "__main__":
write_movies()
| 539
| 0
|
import inspect
import unittest
from typing import List
import numpy as np
from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available
from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_tf_available():
import tensorflow as tf
from transformers import (
TFEfficientFormerForImageClassification,
TFEfficientFormerForImageClassificationWithTeacher,
TFEfficientFormerModel,
)
from transformers.models.efficientformer.modeling_tf_efficientformer import (
TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
)
if is_vision_available():
from PIL import Image
from transformers import EfficientFormerImageProcessor
class snake_case_ :
"""simple docstring"""
def __init__( self ,lowercase ,lowercase = 13 ,lowercase = 64 ,lowercase = 2 ,lowercase = 3 ,lowercase = 3 ,lowercase = True ,lowercase = True ,lowercase = 128 ,lowercase=[16, 32, 64, 128] ,lowercase = 7 ,lowercase = 4 ,lowercase = 37 ,lowercase = "gelu" ,lowercase = 0.1 ,lowercase = 0.1 ,lowercase = 10 ,lowercase = 0.02 ,lowercase = 2 ,lowercase = 1 ,lowercase = 128 ,lowercase = [2, 2, 2, 2] ,lowercase = 2 ,lowercase = 2 ,):
"""simple docstring"""
UpperCAmelCase_ : Any = parent
UpperCAmelCase_ : List[str] = batch_size
UpperCAmelCase_ : Dict = image_size
UpperCAmelCase_ : Optional[int] = patch_size
UpperCAmelCase_ : int = num_channels
UpperCAmelCase_ : str = is_training
UpperCAmelCase_ : str = use_labels
UpperCAmelCase_ : Optional[Any] = hidden_size
UpperCAmelCase_ : int = num_hidden_layers
UpperCAmelCase_ : Tuple = num_attention_heads
UpperCAmelCase_ : Tuple = intermediate_size
UpperCAmelCase_ : Optional[Any] = hidden_act
UpperCAmelCase_ : int = hidden_dropout_prob
UpperCAmelCase_ : Any = attention_probs_dropout_prob
UpperCAmelCase_ : Optional[int] = type_sequence_label_size
UpperCAmelCase_ : Optional[int] = initializer_range
UpperCAmelCase_ : Dict = encoder_stride
UpperCAmelCase_ : List[str] = num_attention_outputs
UpperCAmelCase_ : Any = embed_dim
UpperCAmelCase_ : Optional[int] = embed_dim + 1
UpperCAmelCase_ : str = resolution
UpperCAmelCase_ : List[str] = depths
UpperCAmelCase_ : Any = hidden_sizes
UpperCAmelCase_ : Optional[Any] = dim
UpperCAmelCase_ : Optional[int] = mlp_expansion_ratio
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : Tuple = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
UpperCAmelCase_ : Dict = None
if self.use_labels:
UpperCAmelCase_ : Tuple = ids_tensor([self.batch_size] ,self.type_sequence_label_size)
UpperCAmelCase_ : int = self.get_config()
return config, pixel_values, labels
def A_ ( self):
"""simple docstring"""
return EfficientFormerConfig(
image_size=self.image_size ,patch_size=self.patch_size ,num_channels=self.num_channels ,hidden_size=self.hidden_size ,num_hidden_layers=self.num_hidden_layers ,num_attention_heads=self.num_attention_heads ,intermediate_size=self.intermediate_size ,hidden_act=self.hidden_act ,hidden_dropout_prob=self.hidden_dropout_prob ,attention_probs_dropout_prob=self.attention_probs_dropout_prob ,is_decoder=lowercase ,initializer_range=self.initializer_range ,encoder_stride=self.encoder_stride ,resolution=self.resolution ,depths=self.depths ,hidden_sizes=self.hidden_sizes ,dim=self.dim ,mlp_expansion_ratio=self.mlp_expansion_ratio ,)
def A_ ( self ,lowercase ,lowercase ,lowercase):
"""simple docstring"""
UpperCAmelCase_ : Tuple = TFEfficientFormerModel(config=lowercase)
UpperCAmelCase_ : Dict = model(lowercase ,training=lowercase)
self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size))
def A_ ( self ,lowercase ,lowercase ,lowercase):
"""simple docstring"""
UpperCAmelCase_ : List[Any] = self.type_sequence_label_size
UpperCAmelCase_ : Tuple = TFEfficientFormerForImageClassification(lowercase)
UpperCAmelCase_ : Union[str, Any] = model(lowercase ,labels=lowercase ,training=lowercase)
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size))
# test greyscale images
UpperCAmelCase_ : str = 1
UpperCAmelCase_ : int = TFEfficientFormerForImageClassification(lowercase)
UpperCAmelCase_ : Optional[int] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
UpperCAmelCase_ : List[Any] = model(lowercase ,labels=lowercase)
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.type_sequence_label_size))
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : str = self.prepare_config_and_inputs()
UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Any = config_and_inputs
UpperCAmelCase_ : int = {"pixel_values": pixel_values}
return config, inputs_dict
@require_tf
class snake_case_ (lowercase__ , lowercase__ , unittest.TestCase ):
"""simple docstring"""
_lowerCamelCase = (
(
TFEfficientFormerModel,
TFEfficientFormerForImageClassificationWithTeacher,
TFEfficientFormerForImageClassification,
)
if is_tf_available()
else ()
)
_lowerCamelCase = (
{
"""feature-extraction""": TFEfficientFormerModel,
"""image-classification""": (
TFEfficientFormerForImageClassification,
TFEfficientFormerForImageClassificationWithTeacher,
),
}
if is_tf_available()
else {}
)
_lowerCamelCase = False
_lowerCamelCase = False
_lowerCamelCase = False
_lowerCamelCase = False
_lowerCamelCase = False
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : Dict = TFEfficientFormerModelTester(self)
UpperCAmelCase_ : Any = ConfigTester(
self ,config_class=lowercase ,has_text_modality=lowercase ,hidden_size=37)
def A_ ( self):
"""simple docstring"""
self.config_tester.run_common_tests()
@unittest.skip(reason="EfficientFormer does not use inputs_embeds")
def A_ ( self):
"""simple docstring"""
pass
@unittest.skip(reason="EfficientFormer does not support input and output embeddings")
def A_ ( self):
"""simple docstring"""
pass
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase_ : int = model_class(lowercase)
UpperCAmelCase_ : Optional[Any] = inspect.signature(model.call)
# signature.parameters is an OrderedDict => so arg_names order is deterministic
UpperCAmelCase_ : int = [*signature.parameters.keys()]
UpperCAmelCase_ : List[str] = ["pixel_values"]
self.assertListEqual(arg_names[:1] ,lowercase)
def A_ ( self):
"""simple docstring"""
def check_hidden_states_output(lowercase ,lowercase ,lowercase):
UpperCAmelCase_ : str = model_class(lowercase)
UpperCAmelCase_ : List[Any] = model(**self._prepare_for_class(lowercase ,lowercase) ,training=lowercase)
UpperCAmelCase_ : Dict = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
UpperCAmelCase_ : str = getattr(
self.model_tester ,"expected_num_hidden_layers" ,self.model_tester.num_hidden_layers + 1)
self.assertEqual(len(lowercase) ,lowercase)
if hasattr(self.model_tester ,"encoder_seq_length"):
UpperCAmelCase_ : List[str] = self.model_tester.encoder_seq_length
if hasattr(self.model_tester ,"chunk_length") and self.model_tester.chunk_length > 1:
UpperCAmelCase_ : Tuple = seq_length * self.model_tester.chunk_length
else:
UpperCAmelCase_ : Optional[int] = self.model_tester.seq_length
self.assertListEqual(
list(hidden_states[-1].shape[-2:]) ,[seq_length, self.model_tester.hidden_size] ,)
if config.is_encoder_decoder:
UpperCAmelCase_ : Any = outputs.decoder_hidden_states
self.asseretIsInstance(lowercase ,(list, tuple))
self.assertEqual(len(lowercase) ,lowercase)
UpperCAmelCase_ : Union[str, Any] = getattr(self.model_tester ,"seq_length" ,lowercase)
UpperCAmelCase_ : Optional[int] = getattr(self.model_tester ,"decoder_seq_length" ,lowercase)
self.assertListEqual(
list(hidden_states[-1].shape[-2:]) ,[decoder_seq_length, self.model_tester.hidden_size] ,)
UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase_ : str = True
check_hidden_states_output(lowercase ,lowercase ,lowercase)
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
UpperCAmelCase_ : str = True
check_hidden_states_output(lowercase ,lowercase ,lowercase)
def A_ ( self ,lowercase ,lowercase ,lowercase=False):
"""simple docstring"""
UpperCAmelCase_ : Optional[int] = super()._prepare_for_class(lowercase ,lowercase ,return_labels=lowercase)
if return_labels:
if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
del inputs_dict["labels"]
return inputs_dict
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : Any = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowercase)
@unittest.skip(reason="EfficientFormer does not implement masked image modeling yet")
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_image_modeling(*lowercase)
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*lowercase)
@slow
def A_ ( self):
"""simple docstring"""
for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
UpperCAmelCase_ : Optional[int] = TFEfficientFormerModel.from_pretrained(lowercase)
self.assertIsNotNone(lowercase)
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ , UpperCAmelCase_ : List[str] = self.model_tester.prepare_config_and_inputs_for_common()
UpperCAmelCase_ : List[Any] = True
UpperCAmelCase_ : Dict = getattr(self.model_tester ,"seq_length" ,lowercase)
UpperCAmelCase_ : Tuple = getattr(self.model_tester ,"encoder_seq_length" ,lowercase)
UpperCAmelCase_ : Dict = getattr(self.model_tester ,"key_length" ,lowercase)
UpperCAmelCase_ : Optional[Any] = getattr(self.model_tester ,"chunk_length" ,lowercase)
if chunk_length is not None and hasattr(self.model_tester ,"num_hashes"):
UpperCAmelCase_ : Optional[Any] = encoder_seq_length * self.model_tester.num_hashes
for model_class in self.all_model_classes:
UpperCAmelCase_ : Optional[Any] = True
UpperCAmelCase_ : Optional[int] = False
UpperCAmelCase_ : List[Any] = True
UpperCAmelCase_ : List[str] = model_class(lowercase)
UpperCAmelCase_ : str = model(**self._prepare_for_class(lowercase ,lowercase) ,training=lowercase)
UpperCAmelCase_ : List[Any] = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
self.assertEqual(len(lowercase) ,self.model_tester.num_attention_outputs)
# check that output_attentions also work using config
del inputs_dict["output_attentions"]
UpperCAmelCase_ : Union[str, Any] = True
UpperCAmelCase_ : Optional[Any] = model_class(lowercase)
UpperCAmelCase_ : int = model(**self._prepare_for_class(lowercase ,lowercase) ,training=lowercase)
UpperCAmelCase_ : Any = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
self.assertEqual(len(lowercase) ,self.model_tester.num_attention_outputs)
if chunk_length is not None:
self.assertListEqual(
list(attentions[0].shape[-4:]) ,[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length] ,)
else:
self.assertListEqual(
list(attentions[0].shape[-3:]) ,[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length] ,)
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
# Prepare our model
UpperCAmelCase_ : Optional[int] = model_class(lowercase)
# These are maximally general inputs for the model, with multiple None dimensions
# Hopefully this will catch any conditionals that fail for flexible shapes
UpperCAmelCase_ : str = {
key: tf.keras.Input(shape=val.shape[1:] ,dtype=val.dtype ,name=lowercase)
for key, val in model.input_signature.items()
if key in model.dummy_inputs
}
UpperCAmelCase_ : Dict = model(lowercase)
self.assertTrue(outputs_dict is not None)
def _snake_case ( ) -> Dict:
'''simple docstring'''
UpperCAmelCase_ : Dict = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
return image
@require_tf
@require_vision
class snake_case_ (unittest.TestCase ):
"""simple docstring"""
@cached_property
def A_ ( self):
"""simple docstring"""
return (
EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300")
if is_vision_available()
else None
)
@slow
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : List[Any] = TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300")
UpperCAmelCase_ : Any = self.default_image_processor
UpperCAmelCase_ : Optional[Any] = prepare_img()
UpperCAmelCase_ : Optional[Any] = image_processor(images=lowercase ,return_tensors="tf")
# forward pass
UpperCAmelCase_ : int = model(**lowercase ,training=lowercase)
# verify the logits
UpperCAmelCase_ : List[str] = tf.TensorShape((1, 1000))
self.assertEqual(outputs.logits.shape ,lowercase)
UpperCAmelCase_ : Union[str, Any] = tf.constant([-0.0555, 0.4825, -0.0852])
self.assertTrue(np.allclose(outputs.logits[0, :3] ,lowercase ,atol=1E-4))
@slow
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : List[str] = TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
"snap-research/efficientformer-l1-300")
UpperCAmelCase_ : str = self.default_image_processor
UpperCAmelCase_ : Dict = prepare_img()
UpperCAmelCase_ : Any = image_processor(images=lowercase ,return_tensors="tf")
# forward pass
UpperCAmelCase_ : List[str] = model(**lowercase ,training=lowercase)
# verify the logits
UpperCAmelCase_ : Dict = tf.TensorShape((1, 1000))
self.assertEqual(outputs.logits.shape ,lowercase)
UpperCAmelCase_ : Tuple = tf.constant([-0.1312, 0.4353, -1.0499])
self.assertTrue(np.allclose(outputs.logits[0, :3] ,lowercase ,atol=1E-4))
| 455
|
from typing import Mapping
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxSeqaSeqConfigWithPast
from ...utils import logging
__lowerCamelCase = logging.get_logger(__name__)
__lowerCamelCase = {
'''google/umt5-small''': '''https://huggingface.co/google/umt5-small/resolve/main/config.json''',
# See all umt5 models at https://huggingface.co/models?filter=umt5
}
class snake_case_ (lowercase__ ):
"""simple docstring"""
_lowerCamelCase = """umt5"""
_lowerCamelCase = ["""past_key_values"""]
def __init__( self ,lowercase=250112 ,lowercase=512 ,lowercase=64 ,lowercase=1024 ,lowercase=8 ,lowercase=None ,lowercase=6 ,lowercase=32 ,lowercase=128 ,lowercase=0.1 ,lowercase=1E-6 ,lowercase=1.0 ,lowercase="gated-gelu" ,lowercase=True ,lowercase=True ,lowercase="T5Tokenizer" ,lowercase=True ,lowercase=0 ,lowercase=1 ,lowercase=0 ,**lowercase ,):
"""simple docstring"""
super().__init__(
is_encoder_decoder=lowercase ,tokenizer_class=lowercase ,tie_word_embeddings=lowercase ,pad_token_id=lowercase ,eos_token_id=lowercase ,decoder_start_token_id=lowercase ,**lowercase ,)
UpperCAmelCase_ : Optional[int] = vocab_size
UpperCAmelCase_ : Any = d_model
UpperCAmelCase_ : Any = d_kv
UpperCAmelCase_ : int = d_ff
UpperCAmelCase_ : Tuple = num_layers
UpperCAmelCase_ : int = (
num_decoder_layers if num_decoder_layers is not None else self.num_layers
) # default = symmetry
UpperCAmelCase_ : Optional[int] = num_heads
UpperCAmelCase_ : str = relative_attention_num_buckets
UpperCAmelCase_ : Any = relative_attention_max_distance
UpperCAmelCase_ : Optional[Any] = dropout_rate
UpperCAmelCase_ : Union[str, Any] = layer_norm_epsilon
UpperCAmelCase_ : Optional[Any] = initializer_factor
UpperCAmelCase_ : int = feed_forward_proj
UpperCAmelCase_ : str = use_cache
UpperCAmelCase_ : List[str] = self.feed_forward_proj.split("-")
UpperCAmelCase_ : Any = act_info[-1]
UpperCAmelCase_ : Optional[int] = act_info[0] == "gated"
if len(lowercase) > 1 and act_info[0] != "gated" or len(lowercase) > 2:
raise ValueError(
F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
"Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. "
"'gated-gelu' or 'relu'")
if feed_forward_proj == "gated-gelu":
UpperCAmelCase_ : Tuple = "gelu_new"
@property
def A_ ( self):
"""simple docstring"""
return self.d_model
@property
def A_ ( self):
"""simple docstring"""
return self.num_heads
@property
def A_ ( self):
"""simple docstring"""
return self.num_layers
class snake_case_ (lowercase__ ):
"""simple docstring"""
@property
# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.inputs
def A_ ( self):
"""simple docstring"""
UpperCAmelCase_ : int = {
"input_ids": {0: "batch", 1: "encoder_sequence"},
"attention_mask": {0: "batch", 1: "encoder_sequence"},
}
if self.use_past:
UpperCAmelCase_ : Union[str, Any] = "past_encoder_sequence + sequence"
UpperCAmelCase_ : Optional[int] = {0: "batch"}
UpperCAmelCase_ : Union[str, Any] = {0: "batch", 1: "past_decoder_sequence + sequence"}
else:
UpperCAmelCase_ : Optional[int] = {0: "batch", 1: "decoder_sequence"}
UpperCAmelCase_ : Dict = {0: "batch", 1: "decoder_sequence"}
if self.use_past:
self.fill_with_past_key_values_(lowercase ,direction="inputs")
return common_inputs
@property
# Copied from transformers.models.t5.configuration_t5.T5OnnxConfig.default_onnx_opset
def A_ ( self):
"""simple docstring"""
return 13
@property
def A_ ( self):
"""simple docstring"""
return 5E-4
| 455
| 1
|
'''simple docstring'''
import logging
import math
from functools import partial
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
import torch
from .tensor_utils import tensor_tree_map, tree_map
def lowerCAmelCase_ ( snake_case_ : Union[dict, list, tuple, torch.Tensor] ) -> List[Tuple[int, ...]]:
'''simple docstring'''
UpperCAmelCase_ = []
if isinstance(snake_case_ , snake_case_ ):
for v in tree.values():
shapes.extend(_fetch_dims(snake_case_ ) )
elif isinstance(snake_case_ , (list, tuple) ):
for t in tree:
shapes.extend(_fetch_dims(snake_case_ ) )
elif isinstance(snake_case_ , torch.Tensor ):
shapes.append(tree.shape )
else:
raise ValueError("Not supported" )
return shapes
@torch.jit.ignore
def lowerCAmelCase_ ( snake_case_ : int , snake_case_ : Tuple[int, ...] ) -> Tuple[int, ...]:
'''simple docstring'''
UpperCAmelCase_ = []
for d in reversed(snake_case_ ):
idx.append(flat_idx % d )
UpperCAmelCase_ = flat_idx // d
return tuple(reversed(snake_case_ ) )
@torch.jit.ignore
def lowerCAmelCase_ ( snake_case_ : Sequence[int] , snake_case_ : Sequence[int] , snake_case_ : Sequence[int] , snake_case_ : Optional[Sequence[bool]] = None , snake_case_ : Optional[Sequence[bool]] = None , ) -> List[Tuple[slice, ...]]:
'''simple docstring'''
def reduce_edge_list(snake_case_ : List[bool] ) -> None:
UpperCAmelCase_ = True
for i in range(len(snake_case_ ) ):
UpperCAmelCase_ = -1 * (i + 1)
l[reversed_idx] &= tally
UpperCAmelCase_ = l[reversed_idx]
if start_edges is None:
UpperCAmelCase_ = [s == 0 for s in start]
reduce_edge_list(snake_case_ )
if end_edges is None:
UpperCAmelCase_ = [e == (d - 1) for e, d in zip(snake_case_ , snake_case_ )]
reduce_edge_list(snake_case_ )
# Base cases. Either start/end are empty and we're done, or the final,
# one-dimensional tensor can be simply sliced
if len(snake_case_ ) == 0:
return [()]
elif len(snake_case_ ) == 1:
return [(slice(start[0] , end[0] + 1 ),)]
UpperCAmelCase_ = []
UpperCAmelCase_ = []
# Dimensions common to start and end can be selected directly
for s, e in zip(snake_case_ , snake_case_ ):
if s == e:
path_list.append(slice(snake_case_ , s + 1 ) )
else:
break
UpperCAmelCase_ = tuple(snake_case_ )
UpperCAmelCase_ = len(snake_case_ )
# start == end, and we're done
if divergence_idx == len(snake_case_ ):
return [path]
def upper() -> Tuple[Tuple[slice, ...], ...]:
assert start_edges is not None
assert end_edges is not None
UpperCAmelCase_ = start[divergence_idx]
return tuple(
path + (slice(snake_case_ , sdi + 1 ),) + s
for s in _get_minimal_slice_set(
start[divergence_idx + 1 :] , [d - 1 for d in dims[divergence_idx + 1 :]] , dims[divergence_idx + 1 :] , start_edges=start_edges[divergence_idx + 1 :] , end_edges=[True for _ in end_edges[divergence_idx + 1 :]] , ) )
def lower() -> Tuple[Tuple[slice, ...], ...]:
assert start_edges is not None
assert end_edges is not None
UpperCAmelCase_ = end[divergence_idx]
return tuple(
path + (slice(snake_case_ , edi + 1 ),) + s
for s in _get_minimal_slice_set(
[0 for _ in start[divergence_idx + 1 :]] , end[divergence_idx + 1 :] , dims[divergence_idx + 1 :] , start_edges=[True for _ in start_edges[divergence_idx + 1 :]] , end_edges=end_edges[divergence_idx + 1 :] , ) )
# If both start and end are at the edges of the subtree rooted at
# divergence_idx, we can just select the whole subtree at once
if start_edges[divergence_idx] and end_edges[divergence_idx]:
slices.append(path + (slice(start[divergence_idx] , end[divergence_idx] + 1 ),) )
# If just start is at the edge, we can grab almost all of the subtree,
# treating only the ragged bottom edge as an edge case
elif start_edges[divergence_idx]:
slices.append(path + (slice(start[divergence_idx] , end[divergence_idx] ),) )
slices.extend(lower() )
# Analogous to the previous case, but the top is ragged this time
elif end_edges[divergence_idx]:
slices.extend(upper() )
slices.append(path + (slice(start[divergence_idx] + 1 , end[divergence_idx] + 1 ),) )
# If both sides of the range are ragged, we need to handle both sides
# separately. If there's contiguous meat in between them, we can index it
# in one big chunk
else:
slices.extend(upper() )
UpperCAmelCase_ = end[divergence_idx] - start[divergence_idx]
if middle_ground > 1:
slices.append(path + (slice(start[divergence_idx] + 1 , end[divergence_idx] ),) )
slices.extend(lower() )
return slices
@torch.jit.ignore
def lowerCAmelCase_ ( snake_case_ : torch.Tensor , snake_case_ : int , snake_case_ : int , snake_case_ : int ) -> torch.Tensor:
'''simple docstring'''
UpperCAmelCase_ = t.shape[:no_batch_dims]
UpperCAmelCase_ = list(_flat_idx_to_idx(snake_case_ , snake_case_ ) )
# _get_minimal_slice_set is inclusive
UpperCAmelCase_ = list(_flat_idx_to_idx(flat_end - 1 , snake_case_ ) )
# Get an ordered list of slices to perform
UpperCAmelCase_ = _get_minimal_slice_set(
snake_case_ , snake_case_ , snake_case_ , )
UpperCAmelCase_ = [t[s] for s in slices]
return torch.cat([s.view((-1,) + t.shape[no_batch_dims:] ) for s in sliced_tensors] )
def lowerCAmelCase_ ( snake_case_ : Callable , snake_case_ : Dict[str, Any] , snake_case_ : int , snake_case_ : int , snake_case_ : bool = False , snake_case_ : Any = None , snake_case_ : bool = False , ) -> Any:
'''simple docstring'''
if not (len(snake_case_ ) > 0):
raise ValueError("Must provide at least one input" )
UpperCAmelCase_ = [shape[:no_batch_dims] for shape in _fetch_dims(snake_case_ )]
UpperCAmelCase_ = tuple([max(snake_case_ ) for s in zip(*snake_case_ )] )
def _prep_inputs(snake_case_ : torch.Tensor ) -> torch.Tensor:
if not low_mem:
if not sum(t.shape[:no_batch_dims] ) == no_batch_dims:
UpperCAmelCase_ = t.expand(orig_batch_dims + t.shape[no_batch_dims:] )
UpperCAmelCase_ = t.reshape(-1 , *t.shape[no_batch_dims:] )
else:
UpperCAmelCase_ = t.expand(orig_batch_dims + t.shape[no_batch_dims:] )
return t
UpperCAmelCase_ = tensor_tree_map(_prep_inputs , snake_case_ )
UpperCAmelCase_ = None
if _out is not None:
UpperCAmelCase_ = tensor_tree_map(lambda snake_case_ : t.view([-1] + list(t.shape[no_batch_dims:] ) ) , _out )
UpperCAmelCase_ = 1
for d in orig_batch_dims:
flat_batch_dim *= d
UpperCAmelCase_ = flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0)
def _select_chunk(snake_case_ : torch.Tensor ) -> torch.Tensor:
return t[i : i + chunk_size] if t.shape[0] != 1 else t
UpperCAmelCase_ = 0
UpperCAmelCase_ = prepped_outputs
for _ in range(snake_case_ ):
# Chunk the input
if not low_mem:
UpperCAmelCase_ = _select_chunk
else:
UpperCAmelCase_ = partial(
_chunk_slice , flat_start=snake_case_ , flat_end=min(snake_case_ , i + chunk_size ) , no_batch_dims=len(snake_case_ ) , )
UpperCAmelCase_ = tensor_tree_map(snake_case_ , snake_case_ )
# Run the layer on the chunk
UpperCAmelCase_ = layer(**snake_case_ )
# Allocate space for the output
if out is None:
UpperCAmelCase_ = tensor_tree_map(lambda snake_case_ : t.new_zeros((flat_batch_dim,) + t.shape[1:] ) , snake_case_ )
# Put the chunk in its pre-allocated space
if isinstance(snake_case_ , snake_case_ ):
def assign(snake_case_ : dict , snake_case_ : dict ) -> None:
for k, v in da.items():
if isinstance(snake_case_ , snake_case_ ):
assign(snake_case_ , da[k] )
else:
if _add_into_out:
v[i : i + chunk_size] += da[k]
else:
UpperCAmelCase_ = da[k]
assign(snake_case_ , snake_case_ )
elif isinstance(snake_case_ , snake_case_ ):
for xa, xa in zip(snake_case_ , snake_case_ ):
if _add_into_out:
xa[i : i + chunk_size] += xa
else:
UpperCAmelCase_ = xa
elif isinstance(snake_case_ , torch.Tensor ):
if _add_into_out:
out[i : i + chunk_size] += output_chunk
else:
UpperCAmelCase_ = output_chunk
else:
raise ValueError("Not supported" )
i += chunk_size
UpperCAmelCase_ = tensor_tree_map(lambda snake_case_ : t.view(orig_batch_dims + t.shape[1:] ) , snake_case_ )
return out
class __A :
def __init__(self : Dict , __a : int = 512 , ):
UpperCAmelCase_ = max_chunk_size
UpperCAmelCase_ = None
UpperCAmelCase_ = None
def _lowercase (self : List[Any] , __a : Callable , __a : tuple , __a : int ):
logging.info("Tuning chunk size..." )
if min_chunk_size >= self.max_chunk_size:
return min_chunk_size
UpperCAmelCase_ = [2**l for l in range(int(math.log(self.max_chunk_size , 2 ) ) + 1 )]
UpperCAmelCase_ = [c for c in candidates if c > min_chunk_size]
UpperCAmelCase_ = [min_chunk_size] + candidates
candidates[-1] += 4
def test_chunk_size(__a : int ) -> bool:
try:
with torch.no_grad():
fn(*__a , chunk_size=__a )
return True
except RuntimeError:
return False
UpperCAmelCase_ = 0
UpperCAmelCase_ = len(__a ) - 1
while i > min_viable_chunk_size_index:
UpperCAmelCase_ = test_chunk_size(candidates[i] )
if not viable:
UpperCAmelCase_ = (min_viable_chunk_size_index + i) // 2
else:
UpperCAmelCase_ = i
UpperCAmelCase_ = (i + len(__a ) - 1) // 2
return candidates[min_viable_chunk_size_index]
def _lowercase (self : int , __a : Iterable , __a : Iterable ):
UpperCAmelCase_ = True
for aa, aa in zip(__a , __a ):
assert type(__a ) == type(__a )
if isinstance(__a , (list, tuple) ):
consistent &= self._compare_arg_caches(__a , __a )
elif isinstance(__a , __a ):
UpperCAmelCase_ = [v for _, v in sorted(aa.items() , key=lambda __a : x[0] )]
UpperCAmelCase_ = [v for _, v in sorted(aa.items() , key=lambda __a : x[0] )]
consistent &= self._compare_arg_caches(__a , __a )
else:
consistent &= aa == aa
return consistent
def _lowercase (self : List[str] , __a : Callable , __a : tuple , __a : int , ):
UpperCAmelCase_ = True
UpperCAmelCase_ = tree_map(lambda __a : a.shape if isinstance(__a , torch.Tensor ) else a , __a , __a )
if self.cached_arg_data is not None:
# If args have changed shape/value, we need to re-tune
assert len(self.cached_arg_data ) == len(__a )
UpperCAmelCase_ = self._compare_arg_caches(self.cached_arg_data , __a )
else:
# Otherwise, we can reuse the precomputed value
UpperCAmelCase_ = False
if not consistent:
UpperCAmelCase_ = self._determine_favorable_chunk_size(
__a , __a , __a , )
UpperCAmelCase_ = arg_data
assert self.cached_chunk_size is not None
return self.cached_chunk_size
| 78
|
"""simple docstring"""
import hashlib
import unittest
from typing import Dict
import numpy as np
from transformers import (
MODEL_FOR_MASK_GENERATION_MAPPING,
TF_MODEL_FOR_MASK_GENERATION_MAPPING,
is_vision_available,
pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
is_pipeline_test,
nested_simplify,
require_tf,
require_torch,
require_vision,
slow,
)
if is_vision_available():
from PIL import Image
else:
class __magic_name__ :
@staticmethod
def _lowerCamelCase ( *__magic_name__ , **__magic_name__ ):
"""simple docstring"""
pass
def A__ ( __lowerCamelCase ):
"""simple docstring"""
_lowerCAmelCase = hashlib.mda(image.tobytes() )
return m.hexdigest()[:1_0]
def A__ ( __lowerCamelCase ):
"""simple docstring"""
_lowerCAmelCase = np.array(__lowerCamelCase )
_lowerCAmelCase = npimg.shape
return {"hash": hashimage(__lowerCamelCase ), "shape": shape}
@is_pipeline_test
@require_vision
@require_torch
class __magic_name__ ( unittest.TestCase ):
UpperCamelCase : Tuple = dict(
(list(MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if MODEL_FOR_MASK_GENERATION_MAPPING else []) )
UpperCamelCase : Union[str, Any] = dict(
(list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else []) )
def _lowerCamelCase ( self , __magic_name__ , __magic_name__ , __magic_name__ ):
"""simple docstring"""
_lowerCAmelCase = MaskGenerationPipeline(model=__magic_name__ , image_processor=__magic_name__ )
return image_segmenter, [
"./tests/fixtures/tests_samples/COCO/000000039769.png",
"./tests/fixtures/tests_samples/COCO/000000039769.png",
]
def _lowerCamelCase ( self , __magic_name__ , __magic_name__ ):
"""simple docstring"""
pass
@require_tf
@unittest.skip('Image segmentation not implemented in TF' )
def _lowerCamelCase ( self ):
"""simple docstring"""
pass
@slow
@require_torch
def _lowerCamelCase ( self ):
"""simple docstring"""
_lowerCAmelCase = pipeline('mask-generation' , model='facebook/sam-vit-huge' )
_lowerCAmelCase = image_segmenter('http://images.cocodataset.org/val2017/000000039769.jpg' , points_per_batch=2_5_6 )
# Shortening by hashing
_lowerCAmelCase = []
for i, o in enumerate(outputs['masks'] ):
new_outupt += [{"mask": mask_to_test_readable(__magic_name__ ), "scores": outputs["scores"][i]}]
# fmt: off
self.assertEqual(
nested_simplify(__magic_name__ , decimals=4 ) , [
{'mask': {'hash': '115ad19f5f', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.04_44},
{'mask': {'hash': '6affa964c6', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.0_21},
{'mask': {'hash': 'dfe28a0388', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.01_67},
{'mask': {'hash': 'c0a5f4a318', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.01_32},
{'mask': {'hash': 'fe8065c197', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.00_53},
{'mask': {'hash': 'e2d0b7a0b7', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.99_67},
{'mask': {'hash': '453c7844bd', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.9_93},
{'mask': {'hash': '3d44f2926d', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.99_09},
{'mask': {'hash': '64033ddc3f', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.98_79},
{'mask': {'hash': '801064ff79', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.98_34},
{'mask': {'hash': '6172f276ef', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.97_16},
{'mask': {'hash': 'b49e60e084', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.96_12},
{'mask': {'hash': 'a811e775fd', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.95_99},
{'mask': {'hash': 'a6a8ebcf4b', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.95_52},
{'mask': {'hash': '9d8257e080', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.95_32},
{'mask': {'hash': '32de6454a8', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.95_16},
{'mask': {'hash': 'af3d4af2c8', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.94_99},
{'mask': {'hash': '3c6db475fb', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.94_83},
{'mask': {'hash': 'c290813fb9', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.94_64},
{'mask': {'hash': 'b6f0b8f606', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.9_43},
{'mask': {'hash': '92ce16bfdf', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.9_43},
{'mask': {'hash': 'c749b25868', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.94_08},
{'mask': {'hash': 'efb6cab859', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.93_35},
{'mask': {'hash': '1ff2eafb30', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.93_26},
{'mask': {'hash': '788b798e24', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.92_62},
{'mask': {'hash': 'abea804f0e', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.89_99},
{'mask': {'hash': '7b9e8ddb73', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.89_86},
{'mask': {'hash': 'cd24047c8a', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.89_84},
{'mask': {'hash': '6943e6bcbd', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.88_73},
{'mask': {'hash': 'b5f47c9191', 'shape': (4_8_0, 6_4_0)}, 'scores': 0.88_71}
] , )
# fmt: on
@require_torch
@slow
def _lowerCamelCase ( self ):
"""simple docstring"""
_lowerCAmelCase = 'facebook/sam-vit-huge'
_lowerCAmelCase = pipeline('mask-generation' , model=__magic_name__ )
_lowerCAmelCase = image_segmenter(
'http://images.cocodataset.org/val2017/000000039769.jpg' , pred_iou_thresh=1 , points_per_batch=2_5_6 )
# Shortening by hashing
_lowerCAmelCase = []
for i, o in enumerate(outputs['masks'] ):
new_outupt += [{"mask": mask_to_test_readable(__magic_name__ ), "scores": outputs["scores"][i]}]
self.assertEqual(
nested_simplify(__magic_name__ , decimals=4 ) , [
{'mask': {'hash': '115ad19f5f', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.04_44},
{'mask': {'hash': '6affa964c6', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.02_10},
{'mask': {'hash': 'dfe28a0388', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.01_67},
{'mask': {'hash': 'c0a5f4a318', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.01_32},
{'mask': {'hash': 'fe8065c197', 'shape': (4_8_0, 6_4_0)}, 'scores': 1.00_53},
] , )
| 589
| 0
|
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_torch_available,
)
__UpperCAmelCase ={
"""configuration_wav2vec2""": ["""WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Wav2Vec2Config"""],
"""feature_extraction_wav2vec2""": ["""Wav2Vec2FeatureExtractor"""],
"""processing_wav2vec2""": ["""Wav2Vec2Processor"""],
"""tokenization_wav2vec2""": ["""Wav2Vec2CTCTokenizer""", """Wav2Vec2Tokenizer"""],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
__UpperCAmelCase =[
"""WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""Wav2Vec2ForAudioFrameClassification""",
"""Wav2Vec2ForCTC""",
"""Wav2Vec2ForMaskedLM""",
"""Wav2Vec2ForPreTraining""",
"""Wav2Vec2ForSequenceClassification""",
"""Wav2Vec2ForXVector""",
"""Wav2Vec2Model""",
"""Wav2Vec2PreTrainedModel""",
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
__UpperCAmelCase =[
"""TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST""",
"""TFWav2Vec2ForCTC""",
"""TFWav2Vec2Model""",
"""TFWav2Vec2PreTrainedModel""",
"""TFWav2Vec2ForSequenceClassification""",
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
__UpperCAmelCase =[
"""FlaxWav2Vec2ForCTC""",
"""FlaxWav2Vec2ForPreTraining""",
"""FlaxWav2Vec2Model""",
"""FlaxWav2Vec2PreTrainedModel""",
]
if TYPE_CHECKING:
from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .processing_wavaveca import WavaVecaProcessor
from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_wavaveca import (
WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
WavaVecaForAudioFrameClassification,
WavaVecaForCTC,
WavaVecaForMaskedLM,
WavaVecaForPreTraining,
WavaVecaForSequenceClassification,
WavaVecaForXVector,
WavaVecaModel,
WavaVecaPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_wavaveca import (
TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
TFWavaVecaForCTC,
TFWavaVecaForSequenceClassification,
TFWavaVecaModel,
TFWavaVecaPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_wavaveca import (
FlaxWavaVecaForCTC,
FlaxWavaVecaForPreTraining,
FlaxWavaVecaModel,
FlaxWavaVecaPreTrainedModel,
)
else:
import sys
__UpperCAmelCase =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
| 261
|
"""simple docstring"""
import os
from glob import glob
import imageio
import torch
import torchvision
import wandb
from img_processing import custom_to_pil, loop_post_process, preprocess, preprocess_vqgan
from loaders import load_vqgan
from PIL import Image
from torch import nn
from transformers import CLIPModel, CLIPTokenizerFast
from utils import get_device, get_timestamp, show_pil
class lowerCAmelCase__ :
def __init__( self , UpperCamelCase__ = "cpu" , UpperCamelCase__ = "openai/clip-vit-large-patch14" ):
'''simple docstring'''
A__ = device
A__ = CLIPTokenizerFast.from_pretrained(UpperCamelCase__ )
A__ = [0.4814_5466, 0.457_8275, 0.4082_1073]
A__ = [0.2686_2954, 0.2613_0258, 0.2757_7711]
A__ = torchvision.transforms.Normalize(self.image_mean , self.image_std )
A__ = torchvision.transforms.Resize(2_24 )
A__ = torchvision.transforms.CenterCrop(2_24 )
def lowercase_ ( self , UpperCamelCase__ ):
'''simple docstring'''
A__ = self.resize(UpperCamelCase__ )
A__ = self.center_crop(UpperCamelCase__ )
A__ = self.normalize(UpperCamelCase__ )
return images
def __call__( self , UpperCamelCase__=None , UpperCamelCase__=None , **UpperCamelCase__ ):
'''simple docstring'''
A__ = self.tokenizer(text=UpperCamelCase__ , **UpperCamelCase__ )
A__ = self.preprocess_img(UpperCamelCase__ )
A__ = {key: value.to(self.device ) for (key, value) in encoding.items()}
return encoding
class lowerCAmelCase__ ( nn.Module ):
def __init__( self , UpperCamelCase__=10 , UpperCamelCase__=0.01 , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=False , UpperCamelCase__=True , UpperCamelCase__="image" , UpperCamelCase__=True , UpperCamelCase__=False , UpperCamelCase__=False , UpperCamelCase__=False , ):
'''simple docstring'''
super().__init__()
A__ = None
A__ = device if device else get_device()
if vqgan:
A__ = vqgan
else:
A__ = load_vqgan(self.device , conf_path=UpperCamelCase__ , ckpt_path=UpperCamelCase__ )
self.vqgan.eval()
if clip:
A__ = clip
else:
A__ = CLIPModel.from_pretrained("openai/clip-vit-base-patch32" )
self.clip.to(self.device )
A__ = ProcessorGradientFlow(device=self.device )
A__ = iterations
A__ = lr
A__ = log
A__ = make_grid
A__ = return_val
A__ = quantize
A__ = self.vqgan.decoder.z_shape
def lowercase_ ( self , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=5 , UpperCamelCase__=True ):
'''simple docstring'''
A__ = []
if output_path is None:
A__ = "./animation.gif"
if input_path is None:
A__ = self.save_path
A__ = sorted(glob(input_path + "/*" ) )
if not len(UpperCamelCase__ ):
raise ValueError(
"No images found in save path, aborting (did you pass save_intermediate=True to the generate"
" function?)" )
if len(UpperCamelCase__ ) == 1:
print("Only one image found in save path, (did you pass save_intermediate=True to the generate function?)" )
A__ = total_duration / len(UpperCamelCase__ )
A__ = [frame_duration] * len(UpperCamelCase__ )
if extend_frames:
A__ = 1.5
A__ = 3
for file_name in paths:
if file_name.endswith(".png" ):
images.append(imageio.imread(UpperCamelCase__ ) )
imageio.mimsave(UpperCamelCase__ , UpperCamelCase__ , duration=UpperCamelCase__ )
print(f"""gif saved to {output_path}""" )
def lowercase_ ( self , UpperCamelCase__=None , UpperCamelCase__=None ):
'''simple docstring'''
if not (path or img):
raise ValueError("Input either path or tensor" )
if img is not None:
raise NotImplementedError
A__ = preprocess(Image.open(UpperCamelCase__ ) , target_image_size=2_56 ).to(self.device )
A__ = preprocess_vqgan(UpperCamelCase__ )
A__ , *A__ = self.vqgan.encode(UpperCamelCase__ )
return z
def lowercase_ ( self , UpperCamelCase__ ):
'''simple docstring'''
A__ = self.latent.detach().requires_grad_()
A__ = base_latent + transform_vector
if self.quantize:
A__ , *A__ = self.vqgan.quantize(UpperCamelCase__ )
else:
A__ = trans_latent
return self.vqgan.decode(UpperCamelCase__ )
def lowercase_ ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__=None ):
'''simple docstring'''
A__ = self.clip_preprocessor(text=UpperCamelCase__ , images=UpperCamelCase__ , return_tensors="pt" , padding=UpperCamelCase__ )
A__ = self.clip(**UpperCamelCase__ )
A__ = clip_outputs.logits_per_image
if weights is not None:
A__ = similarity_logits * weights
return similarity_logits.sum()
def lowercase_ ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ):
'''simple docstring'''
A__ = self._get_clip_similarity(pos_prompts["prompts"] , UpperCamelCase__ , weights=(1 / pos_prompts["weights"]) )
if neg_prompts:
A__ = self._get_clip_similarity(neg_prompts["prompts"] , UpperCamelCase__ , weights=neg_prompts["weights"] )
else:
A__ = torch.tensor([1] , device=self.device )
A__ = -torch.log(UpperCamelCase__ ) + torch.log(UpperCamelCase__ )
return loss
def lowercase_ ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ):
'''simple docstring'''
A__ = torch.randn_like(self.latent , requires_grad=UpperCamelCase__ , device=self.device )
A__ = torch.optim.Adam([vector] , lr=self.lr )
for i in range(self.iterations ):
optim.zero_grad()
A__ = self._add_vector(UpperCamelCase__ )
A__ = loop_post_process(UpperCamelCase__ )
A__ = self._get_CLIP_loss(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ )
print("CLIP loss" , UpperCamelCase__ )
if self.log:
wandb.log({"CLIP Loss": clip_loss} )
clip_loss.backward(retain_graph=UpperCamelCase__ )
optim.step()
if self.return_val == "image":
yield custom_to_pil(transformed_img[0] )
else:
yield vector
def lowercase_ ( self , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ):
'''simple docstring'''
wandb.init(reinit=UpperCamelCase__ , project="face-editor" )
wandb.config.update({"Positive Prompts": positive_prompts} )
wandb.config.update({"Negative Prompts": negative_prompts} )
wandb.config.update({"lr": self.lr, "iterations": self.iterations} )
if image_path:
A__ = Image.open(UpperCamelCase__ )
A__ = image.resize((2_56, 2_56) )
wandb.log("Original Image" , wandb.Image(UpperCamelCase__ ) )
def lowercase_ ( self , UpperCamelCase__ ):
'''simple docstring'''
if not prompts:
return []
A__ = []
A__ = []
if isinstance(UpperCamelCase__ , UpperCamelCase__ ):
A__ = [prompt.strip() for prompt in prompts.split("|" )]
for prompt in prompts:
if isinstance(UpperCamelCase__ , (tuple, list) ):
A__ = prompt[0]
A__ = float(prompt[1] )
elif ":" in prompt:
A__ , A__ = prompt.split(":" )
A__ = float(UpperCamelCase__ )
else:
A__ = prompt
A__ = 1.0
processed_prompts.append(UpperCamelCase__ )
weights.append(UpperCamelCase__ )
return {
"prompts": processed_prompts,
"weights": torch.tensor(UpperCamelCase__ , device=self.device ),
}
def lowercase_ ( self , UpperCamelCase__ , UpperCamelCase__=None , UpperCamelCase__=None , UpperCamelCase__=True , UpperCamelCase__=False , UpperCamelCase__=True , UpperCamelCase__=True , UpperCamelCase__=None , ):
'''simple docstring'''
if image_path:
A__ = self._get_latent(UpperCamelCase__ )
else:
A__ = torch.randn(self.latent_dim , device=self.device )
if self.log:
self._init_logging(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ )
assert pos_prompts, "You must provide at least one positive prompt."
A__ = self.process_prompts(UpperCamelCase__ )
A__ = self.process_prompts(UpperCamelCase__ )
if save_final and save_path is None:
A__ = os.path.join("./outputs/" , "_".join(pos_prompts["prompts"] ) )
if not os.path.exists(UpperCamelCase__ ):
os.makedirs(UpperCamelCase__ )
else:
A__ = save_path + "_" + get_timestamp()
os.makedirs(UpperCamelCase__ )
A__ = save_path
A__ = self.vqgan.decode(self.latent )[0]
if show_intermediate:
print("Original Image" )
show_pil(custom_to_pil(UpperCamelCase__ ) )
A__ = loop_post_process(UpperCamelCase__ )
for iter, transformed_img in enumerate(self._optimize_CLIP(UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ ) ):
if show_intermediate:
show_pil(UpperCamelCase__ )
if save_intermediate:
transformed_img.save(os.path.join(self.save_path , f"""iter_{iter:03d}.png""" ) )
if self.log:
wandb.log({"Image": wandb.Image(UpperCamelCase__ )} )
if show_final:
show_pil(UpperCamelCase__ )
if save_final:
transformed_img.save(os.path.join(self.save_path , f"""iter_{iter:03d}_final.png""" ) )
| 261
| 1
|
"""simple docstring"""
import os
from shutil import copyfile
from typing import List, Optional, Tuple
from tokenizers import processors
from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging
if is_sentencepiece_available():
from .tokenization_mbart import MBartTokenizer
else:
lowercase = None
lowercase = logging.get_logger(__name__)
lowercase = {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}
lowercase = {
'''vocab_file''': {
'''facebook/mbart-large-en-ro''': (
'''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model'''
),
'''facebook/mbart-large-cc25''': (
'''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model'''
),
},
'''tokenizer_file''': {
'''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''',
'''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''',
},
}
lowercase = {
'''facebook/mbart-large-en-ro''': 10_24,
'''facebook/mbart-large-cc25''': 10_24,
}
# fmt: off
lowercase = ['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''']
class lowercase__ ( A ):
'''simple docstring'''
_UpperCAmelCase = VOCAB_FILES_NAMES
_UpperCAmelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_UpperCAmelCase = PRETRAINED_VOCAB_FILES_MAP
_UpperCAmelCase = ['''input_ids''', '''attention_mask''']
_UpperCAmelCase = MBartTokenizer
_UpperCAmelCase = []
_UpperCAmelCase = []
def __init__( self , snake_case=None , snake_case=None , snake_case="<s>" , snake_case="</s>" , snake_case="</s>" , snake_case="<s>" , snake_case="<unk>" , snake_case="<pad>" , snake_case="<mask>" , snake_case=None , snake_case=None , snake_case=None , **snake_case , ) -> str:
# Mask token behave like a normal word, i.e. include the space before it
_UpperCAmelCase = AddedToken(snake_case , lstrip=snake_case , rstrip=snake_case ) if isinstance(snake_case , snake_case ) else mask_token
super().__init__(
vocab_file=snake_case , tokenizer_file=snake_case , bos_token=snake_case , eos_token=snake_case , sep_token=snake_case , cls_token=snake_case , unk_token=snake_case , pad_token=snake_case , mask_token=snake_case , src_lang=snake_case , tgt_lang=snake_case , additional_special_tokens=snake_case , **snake_case , )
_UpperCAmelCase = vocab_file
_UpperCAmelCase = False if not self.vocab_file else True
_UpperCAmelCase = FAIRSEQ_LANGUAGE_CODES.copy()
if additional_special_tokens is not None:
# Only add those special tokens if they are not already there.
_additional_special_tokens.extend(
[t for t in additional_special_tokens if t not in _additional_special_tokens] )
self.add_special_tokens({'additional_special_tokens': _additional_special_tokens} )
_UpperCAmelCase = {
lang_code: self.convert_tokens_to_ids(snake_case ) for lang_code in FAIRSEQ_LANGUAGE_CODES
}
_UpperCAmelCase = src_lang if src_lang is not None else 'en_XX'
_UpperCAmelCase = self.convert_tokens_to_ids(self._src_lang )
_UpperCAmelCase = tgt_lang
self.set_src_lang_special_tokens(self._src_lang )
@property
def lowerCamelCase_ ( self ) -> str:
return self._src_lang
@src_lang.setter
def lowerCamelCase_ ( self , snake_case ) -> None:
_UpperCAmelCase = new_src_lang
self.set_src_lang_special_tokens(self._src_lang )
def lowerCamelCase_ ( self , snake_case , snake_case = None ) -> List[int]:
if token_ids_a is None:
return self.prefix_tokens + token_ids_a + self.suffix_tokens
# We don't expect to process pairs, but leave the pair logic for API consistency
return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens
def lowerCamelCase_ ( self , snake_case , snake_case = None ) -> List[int]:
_UpperCAmelCase = [self.sep_token_id]
_UpperCAmelCase = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
def lowerCamelCase_ ( self , snake_case , snake_case , snake_case , snake_case , **snake_case ) -> Any:
if src_lang is None or tgt_lang is None:
raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model' )
_UpperCAmelCase = src_lang
_UpperCAmelCase = self(snake_case , add_special_tokens=snake_case , return_tensors=snake_case , **snake_case )
_UpperCAmelCase = self.convert_tokens_to_ids(snake_case )
_UpperCAmelCase = tgt_lang_id
return inputs
def lowerCamelCase_ ( self , snake_case , snake_case = "en_XX" , snake_case = None , snake_case = "ro_RO" , **snake_case , ) -> BatchEncoding:
_UpperCAmelCase = src_lang
_UpperCAmelCase = tgt_lang
return super().prepare_seqaseq_batch(snake_case , snake_case , **snake_case )
def lowerCamelCase_ ( self ) -> Optional[int]:
return self.set_src_lang_special_tokens(self.src_lang )
def lowerCamelCase_ ( self ) -> int:
return self.set_tgt_lang_special_tokens(self.tgt_lang )
def lowerCamelCase_ ( self , snake_case ) -> None:
_UpperCAmelCase = self.convert_tokens_to_ids(snake_case )
_UpperCAmelCase = []
_UpperCAmelCase = [self.eos_token_id, self.cur_lang_code]
_UpperCAmelCase = self.convert_ids_to_tokens(self.prefix_tokens )
_UpperCAmelCase = self.convert_ids_to_tokens(self.suffix_tokens )
_UpperCAmelCase = processors.TemplateProcessing(
single=prefix_tokens_str + ['$A'] + suffix_tokens_str , pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , )
def lowerCamelCase_ ( self , snake_case ) -> None:
_UpperCAmelCase = self.convert_tokens_to_ids(snake_case )
_UpperCAmelCase = []
_UpperCAmelCase = [self.eos_token_id, self.cur_lang_code]
_UpperCAmelCase = self.convert_ids_to_tokens(self.prefix_tokens )
_UpperCAmelCase = self.convert_ids_to_tokens(self.suffix_tokens )
_UpperCAmelCase = processors.TemplateProcessing(
single=prefix_tokens_str + ['$A'] + suffix_tokens_str , pair=prefix_tokens_str + ['$A', '$B'] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , )
def lowerCamelCase_ ( self , snake_case , snake_case = None ) -> Tuple[str]:
if not self.can_save_slow_tokenizer:
raise ValueError(
'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
'tokenizer.' )
if not os.path.isdir(snake_case ):
logger.error(f'Vocabulary path ({save_directory}) should be a directory.' )
return
_UpperCAmelCase = os.path.join(
snake_case , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case ):
copyfile(self.vocab_file , snake_case )
return (out_vocab_file,)
| 573
|
"""simple docstring"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Model name or path of model to be trained.'''} )
_UpperCAmelCase = field(
default='''./''', metadata={'''help''': '''Save dir where model repo is cloned and models updates are saved to.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot-clean-train''', metadata={'''help''': '''Name or path of training dataset.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot-clean-valid''', metadata={'''help''': '''Name or path of validation dataset.'''} )
_UpperCAmelCase = field(default=2, metadata={'''help''': '''Batch size for training.'''} )
_UpperCAmelCase = field(default=2, metadata={'''help''': '''Batch size for evaluation.'''} )
_UpperCAmelCase = field(default=0.1, metadata={'''help''': '''Value of weight decay.'''} )
_UpperCAmelCase = field(
default=1_00_00, metadata={'''help''': '''Size of buffer used to shuffle streaming dataset.'''} )
_UpperCAmelCase = field(default=2E-4, metadata={'''help''': '''Learning rate fo training.'''} )
_UpperCAmelCase = field(default='''cosine''', metadata={'''help''': '''Learning rate.'''} )
_UpperCAmelCase = field(
default=7_50, metadata={'''help''': '''Number of warmup steps in the learning rate schedule.'''} )
_UpperCAmelCase = field(
default=16, metadata={'''help''': '''Number of gradient accumulation steps.'''} )
_UpperCAmelCase = field(
default=A, metadata={'''help''': '''Use gradient checkpointing to reduce memory footprint.'''} )
_UpperCAmelCase = field(default=5_00_00, metadata={'''help''': '''Maximum number of training steps.'''} )
_UpperCAmelCase = field(
default=-1, metadata={'''help''': '''Maximum number of evaluation steps. If -1 the full dataset is evaluated.'''} )
_UpperCAmelCase = field(default=10_24, metadata={'''help''': '''Sequence lengths used for training.'''} )
_UpperCAmelCase = field(default=1, metadata={'''help''': '''Training seed.'''} )
_UpperCAmelCase = field(
default=10_24, metadata={'''help''': '''Interval to save checkpoints. Measured as number of forward passes not training steps.'''}, )
_UpperCAmelCase = field(
default=A, metadata={'''help''': '''States path if the training should continue from a checkpoint folder.'''} )
_UpperCAmelCase = field(default=A, metadata={'''help''': '''If True the data is pretokenized.'''} )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Model name or path of model to be evaluated.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot-clean-valid''', metadata={'''help''': '''Name or path of validation dataset.'''} )
_UpperCAmelCase = field(default=2, metadata={'''help''': '''Batch size used for evaluation.'''} )
_UpperCAmelCase = field(
default=-1, metadata={'''help''': '''Maximum number of evaluation steps. If -1 the full dataset is evaluated.'''} )
_UpperCAmelCase = field(default=10_24, metadata={'''help''': '''Length of sequences to be evaluated.'''} )
_UpperCAmelCase = field(default=1, metadata={'''help''': '''Random seed used for evaluation.'''} )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Model name or path of model to be evaluated.'''} )
_UpperCAmelCase = field(default=A, metadata={'''help''': '''Number of workers used for code evaluation.'''} )
_UpperCAmelCase = field(
default=A, metadata={'''help''': '''The number of human-eval tasks to run. If not included all tasks are evaluated.'''}, )
_UpperCAmelCase = field(
default=A, metadata={'''help''': '''Sample from the language model\'s output distribution.'''} )
_UpperCAmelCase = field(default=0.2, metadata={'''help''': '''Sampling temperature used for generation.'''} )
_UpperCAmelCase = field(default=2_56, metadata={'''help''': '''Maximum number of newly generated tokens.'''} )
_UpperCAmelCase = field(default=0, metadata={'''help''': '''Top-k parameter used for generation.'''} )
_UpperCAmelCase = field(default=0.95, metadata={'''help''': '''Top-p parameter used for nucleus sampling.'''} )
_UpperCAmelCase = field(default=10, metadata={'''help''': '''Number of generations to run in parallel.'''} )
_UpperCAmelCase = field(
default=2_00, metadata={'''help''': '''Number of completions to generate for each sample.'''} )
_UpperCAmelCase = field(default=1, metadata={'''help''': '''Random seed used for evaluation.'''} )
_UpperCAmelCase = field(
default='''eval_results.json''', metadata={'''help''': '''Random seed used for evaluation.'''} )
_UpperCAmelCase = field(
default='''0''', metadata={'''help''': '''Allow `code_eval` to execute Python code on machine'''} )
_UpperCAmelCase = field(
default=-1, metadata={
'''help''': (
'''Determine which device to run the `text-generation` Pipeline on. -1 is CPU and any zero or positive'''
''' number corresponds to which GPU device id to run on.'''
)
}, )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default=A, metadata={
'''help''': '''The number of CPU cores to use for parallel preprocessing. Default uses the maximum available.'''
}, )
_UpperCAmelCase = field(
default='''transformersbook/codeparrot''', metadata={'''help''': '''Folder or name of dataset to process.'''} )
_UpperCAmelCase = field(
default='''codeparrot-clean''', metadata={'''help''': '''Folder to save processed processed dataset.'''} )
_UpperCAmelCase = field(
default=10_00_00, metadata={'''help''': '''Number of files to save per JSON output file.'''} )
_UpperCAmelCase = field(default='''content''', metadata={'''help''': '''Column containing text data to process.'''} )
_UpperCAmelCase = field(
default=10_00, metadata={'''help''': '''Maximum line length in file, otherwise file is filtered.'''} )
_UpperCAmelCase = field(
default=1_00, metadata={'''help''': '''Maximum mean line length in file, otherwise file is filtered.'''} )
_UpperCAmelCase = field(
default=0.25, metadata={'''help''': '''Maximum fraction of non-alphanumeric characters, otherwise file is filtered.'''} )
_UpperCAmelCase = field(
default=1.5, metadata={'''help''': '''Minimum character token ratio for the file, otherwise file is filtered.'''} )
_UpperCAmelCase = field(
default=0.7, metadata={'''help''': '''Probability for filtering config, test and uncommon files.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Name or path to the tokenizer.'''}, )
_UpperCAmelCase = field(
default=A, metadata={'''help''': '''If True, near-duplicate samples are removed.'''} )
_UpperCAmelCase = field(
default=0.85, metadata={'''help''': '''Jaccard threshold for near-duplicate samples.'''} )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''gpt2''', metadata={'''help''': '''Base tokenizer to build new tokenizer from.'''} )
_UpperCAmelCase = field(
default='''transformersbook/codeparrot-train''', metadata={'''help''': '''Dataset to train tokenizer on.'''} )
_UpperCAmelCase = field(default='''content''', metadata={'''help''': '''Column containing text data to process.'''} )
_UpperCAmelCase = field(default=20_00_00, metadata={'''help''': '''Number of examples to train tokenizer on.'''} )
_UpperCAmelCase = field(
default=3_27_68, metadata={'''help''': '''Number of examples to train the tokenizer on.'''} )
_UpperCAmelCase = field(default='''codeparrot''', metadata={'''help''': '''Name of new tokenizer.'''} )
_UpperCAmelCase = field(default=A, metadata={'''help''': '''Push saved tokenizer to the hub.'''} )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Name or path to the tokenizer.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot-clean-train''', metadata={'''help''': '''Name or path to the dataset to pretokenize.'''} )
_UpperCAmelCase = field(
default='''tokenized-codeparrot-train''', metadata={'''help''': '''Repo name of the pretokenized data.'''} )
_UpperCAmelCase = field(default=A, metadata={'''help''': '''Number of workers used for code evaluation.'''} )
@dataclass
class lowercase__ :
'''simple docstring'''
_UpperCAmelCase = field(
default='''gpt2-large''', metadata={'''help''': '''Configuration to use for model initialization.'''} )
_UpperCAmelCase = field(
default='''codeparrot/codeparrot''', metadata={'''help''': '''Tokenizer attached to model.'''} )
_UpperCAmelCase = field(default='''codeparrot''', metadata={'''help''': '''Name of the created model.'''} )
_UpperCAmelCase = field(default=A, metadata={'''help''': '''Push saved tokenizer to the hub.'''} )
| 573
| 1
|
'''simple docstring'''
import unittest
import numpy as np
import torch
from diffusers import DDIMPipeline, DDIMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device
from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
enable_full_determinism()
class UpperCamelCase_ ( __a , unittest.TestCase ):
lowercase = DDIMPipeline
lowercase = UNCONDITIONAL_IMAGE_GENERATION_PARAMS
lowercase = PipelineTesterMixin.required_optional_params - {
"num_images_per_prompt",
"latents",
"callback",
"callback_steps",
}
lowercase = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS
lowercase = False
def _lowercase( self ) -> List[str]:
torch.manual_seed(0 )
UpperCAmelCase : Union[str, Any] = UNetaDModel(
block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , )
UpperCAmelCase : int = DDIMScheduler()
UpperCAmelCase : int = {"""unet""": unet, """scheduler""": scheduler}
return components
def _lowercase( self , A , A=0 ) -> Union[str, Any]:
if str(lowerCAmelCase_ ).startswith("""mps""" ):
UpperCAmelCase : Any = torch.manual_seed(lowerCAmelCase_ )
else:
UpperCAmelCase : int = torch.Generator(device=lowerCAmelCase_ ).manual_seed(lowerCAmelCase_ )
UpperCAmelCase : Dict = {
"""batch_size""": 1,
"""generator""": generator,
"""num_inference_steps""": 2,
"""output_type""": """numpy""",
}
return inputs
def _lowercase( self ) -> List[str]:
UpperCAmelCase : List[Any] = """cpu"""
UpperCAmelCase : int = self.get_dummy_components()
UpperCAmelCase : List[Any] = self.pipeline_class(**lowerCAmelCase_ )
pipe.to(lowerCAmelCase_ )
pipe.set_progress_bar_config(disable=lowerCAmelCase_ )
UpperCAmelCase : List[Any] = self.get_dummy_inputs(lowerCAmelCase_ )
UpperCAmelCase : Dict = pipe(**lowerCAmelCase_ ).images
UpperCAmelCase : int = image[0, -3:, -3:, -1]
self.assertEqual(image.shape , (1, 32, 32, 3) )
UpperCAmelCase : List[str] = np.array(
[1.000e00, 5.717e-01, 4.717e-01, 1.000e00, 0.000e00, 1.000e00, 3.000e-04, 0.000e00, 9.000e-04] )
UpperCAmelCase : str = np.abs(image_slice.flatten() - expected_slice ).max()
self.assertLessEqual(lowerCAmelCase_ , 1e-3 )
def _lowercase( self ) -> Optional[int]:
super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )
def _lowercase( self ) -> Any:
super().test_save_load_local(expected_max_difference=3e-3 )
def _lowercase( self ) -> Optional[int]:
super().test_save_load_optional_components(expected_max_difference=3e-3 )
def _lowercase( self ) -> Dict:
super().test_inference_batch_single_identical(expected_max_diff=3e-3 )
@slow
@require_torch_gpu
class UpperCamelCase_ ( unittest.TestCase ):
def _lowercase( self ) -> Dict:
UpperCAmelCase : List[str] = """google/ddpm-cifar10-32"""
UpperCAmelCase : List[Any] = UNetaDModel.from_pretrained(lowerCAmelCase_ )
UpperCAmelCase : Union[str, Any] = DDIMScheduler()
UpperCAmelCase : List[str] = DDIMPipeline(unet=lowerCAmelCase_ , scheduler=lowerCAmelCase_ )
ddim.to(lowerCAmelCase_ )
ddim.set_progress_bar_config(disable=lowerCAmelCase_ )
UpperCAmelCase : Any = torch.manual_seed(0 )
UpperCAmelCase : List[str] = ddim(generator=lowerCAmelCase_ , eta=0.0 , output_type="""numpy""" ).images
UpperCAmelCase : Any = image[0, -3:, -3:, -1]
assert image.shape == (1, 32, 32, 3)
UpperCAmelCase : Optional[int] = np.array([0.1_7_2_3, 0.1_6_1_7, 0.1_6_0_0, 0.1_6_2_6, 0.1_4_9_7, 0.1_5_1_3, 0.1_5_0_5, 0.1_4_4_2, 0.1_4_5_3] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
def _lowercase( self ) -> Dict:
UpperCAmelCase : str = """google/ddpm-ema-bedroom-256"""
UpperCAmelCase : List[Any] = UNetaDModel.from_pretrained(lowerCAmelCase_ )
UpperCAmelCase : Dict = DDIMScheduler.from_pretrained(lowerCAmelCase_ )
UpperCAmelCase : Dict = DDIMPipeline(unet=lowerCAmelCase_ , scheduler=lowerCAmelCase_ )
ddpm.to(lowerCAmelCase_ )
ddpm.set_progress_bar_config(disable=lowerCAmelCase_ )
UpperCAmelCase : Tuple = torch.manual_seed(0 )
UpperCAmelCase : Optional[int] = ddpm(generator=lowerCAmelCase_ , output_type="""numpy""" ).images
UpperCAmelCase : Any = image[0, -3:, -3:, -1]
assert image.shape == (1, 256, 256, 3)
UpperCAmelCase : Tuple = np.array([0.0_0_6_0, 0.0_2_0_1, 0.0_3_4_4, 0.0_0_2_4, 0.0_0_1_8, 0.0_0_0_2, 0.0_0_2_2, 0.0_0_0_0, 0.0_0_6_9] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 719
|
'''simple docstring'''
# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional
import numpy as np
import pyarrow as pa
from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter
if TYPE_CHECKING:
import jax
import jaxlib
a : Any = get_logger()
a : Optional[dict] = None
class UpperCamelCase_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ):
def __init__( self , A=None , A=None , **A ) -> str:
super().__init__(features=A )
import jax
from jaxlib.xla_client import Device
if isinstance(A , A ):
raise ValueError(
f'''Expected {device} to be a `str` not {type(A )}, as `jaxlib.xla_extension.Device` '''
"""is not serializable neither with `pickle` nor with `dill`. Instead you can surround """
"""the device with `str()` to get its string identifier that will be internally mapped """
"""to the actual `jaxlib.xla_extension.Device`.""" )
UpperCAmelCase : Optional[int] = device if isinstance(A , A ) else str(jax.devices()[0] )
# using global variable since `jaxlib.xla_extension.Device` is not serializable neither
# with `pickle` nor with `dill`, so we need to use a global variable instead
global DEVICE_MAPPING
if DEVICE_MAPPING is None:
UpperCAmelCase : Any = self._map_devices_to_str()
if self.device not in list(DEVICE_MAPPING.keys() ):
logger.warning(
f'''Device with string identifier {self.device} not listed among the available '''
f'''devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default '''
f'''device: {str(jax.devices()[0] )}.''' )
UpperCAmelCase : List[Any] = str(jax.devices()[0] )
UpperCAmelCase : Union[str, Any] = jnp_array_kwargs
@staticmethod
def _lowercase( ) -> Dict[str, "jaxlib.xla_extension.Device"]:
import jax
return {str(A ): device for device in jax.devices()}
def _lowercase( self , A ) -> str:
import jax
import jax.numpy as jnp
if isinstance(A , A ) and column:
if all(
isinstance(A , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ):
return jnp.stack(A , axis=0 )
return column
def _lowercase( self , A ) -> Tuple:
import jax
import jax.numpy as jnp
if isinstance(A , (str, bytes, type(A )) ):
return value
elif isinstance(A , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ):
return value.tolist()
UpperCAmelCase : List[str] = {}
if isinstance(A , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ):
# the default int precision depends on the jax config
# see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
if jax.config.jax_enable_xaa:
UpperCAmelCase : str = {"""dtype""": jnp.intaa}
else:
UpperCAmelCase : int = {"""dtype""": jnp.intaa}
elif isinstance(A , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ):
UpperCAmelCase : Any = {"""dtype""": jnp.floataa}
elif config.PIL_AVAILABLE and "PIL" in sys.modules:
import PIL.Image
if isinstance(A , PIL.Image.Image ):
UpperCAmelCase : List[str] = np.asarray(A )
# using global variable since `jaxlib.xla_extension.Device` is not serializable neither
# with `pickle` nor with `dill`, so we need to use a global variable instead
global DEVICE_MAPPING
if DEVICE_MAPPING is None:
UpperCAmelCase : Dict = self._map_devices_to_str()
with jax.default_device(DEVICE_MAPPING[self.device] ):
# calling jnp.array on a np.ndarray does copy the data
# see https://github.com/google/jax/issues/4486
return jnp.array(A , **{**default_dtype, **self.jnp_array_kwargs} )
def _lowercase( self , A ) -> Tuple:
import jax
# support for torch, tf, jax etc.
if config.TORCH_AVAILABLE and "torch" in sys.modules:
import torch
if isinstance(A , torch.Tensor ):
return self._tensorize(data_struct.detach().cpu().numpy()[()] )
if hasattr(A , """__array__""" ) and not isinstance(A , jax.Array ):
UpperCAmelCase : Optional[int] = data_struct.__array__()
# support for nested types like struct of list of struct
if isinstance(A , np.ndarray ):
if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects
return self._consolidate([self.recursive_tensorize(A ) for substruct in data_struct] )
elif isinstance(A , (list, tuple) ):
return self._consolidate([self.recursive_tensorize(A ) for substruct in data_struct] )
return self._tensorize(A )
def _lowercase( self , A ) -> Dict:
return map_nested(self._recursive_tensorize , A , map_list=A )
def _lowercase( self , A ) -> Mapping:
UpperCAmelCase : Union[str, Any] = self.numpy_arrow_extractor().extract_row(A )
UpperCAmelCase : Dict = self.python_features_decoder.decode_row(A )
return self.recursive_tensorize(A )
def _lowercase( self , A ) -> "jax.Array":
UpperCAmelCase : int = self.numpy_arrow_extractor().extract_column(A )
UpperCAmelCase : Optional[Any] = self.python_features_decoder.decode_column(A , pa_table.column_names[0] )
UpperCAmelCase : Optional[int] = self.recursive_tensorize(A )
UpperCAmelCase : Any = self._consolidate(A )
return column
def _lowercase( self , A ) -> Mapping:
UpperCAmelCase : Optional[int] = self.numpy_arrow_extractor().extract_batch(A )
UpperCAmelCase : List[str] = self.python_features_decoder.decode_batch(A )
UpperCAmelCase : Union[str, Any] = self.recursive_tensorize(A )
for column_name in batch:
UpperCAmelCase : Optional[Any] = self._consolidate(batch[column_name] )
return batch
| 672
| 0
|
import torch
from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device
from .test_schedulers import SchedulerCommonTest
class lowerCAmelCase ( __UpperCamelCase ):
'''simple docstring'''
snake_case = (KDPMaDiscreteScheduler,)
snake_case = 10
def lowerCamelCase__ ( self : str , **__snake_case : Optional[int] ) -> Union[str, Any]:
'''simple docstring'''
lowerCamelCase = {
'num_train_timesteps': 1100,
'beta_start': 0.0001,
'beta_end': 0.02,
'beta_schedule': 'linear',
}
config.update(**__UpperCamelCase )
return config
def lowerCamelCase__ ( self : Optional[Any] ) -> str:
'''simple docstring'''
for timesteps in [10, 50, 100, 1000]:
self.check_over_configs(num_train_timesteps=__UpperCamelCase )
def lowerCamelCase__ ( self : Dict ) -> int:
'''simple docstring'''
for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001] , [0.0002, 0.002, 0.02] ):
self.check_over_configs(beta_start=__UpperCamelCase , beta_end=__UpperCamelCase )
def lowerCamelCase__ ( self : Union[str, Any] ) -> int:
'''simple docstring'''
for schedule in ["linear", "scaled_linear"]:
self.check_over_configs(beta_schedule=__UpperCamelCase )
def lowerCamelCase__ ( self : List[str] ) -> str:
'''simple docstring'''
for prediction_type in ["epsilon", "v_prediction"]:
self.check_over_configs(prediction_type=__UpperCamelCase )
def lowerCamelCase__ ( self : Optional[int] ) -> Tuple:
'''simple docstring'''
lowerCamelCase = self.scheduler_classes[0]
lowerCamelCase = self.get_scheduler_config(prediction_type='v_prediction' )
lowerCamelCase = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps )
lowerCamelCase = self.dummy_model()
lowerCamelCase = self.dummy_sample_deter * scheduler.init_noise_sigma
lowerCamelCase = sample.to(__UpperCamelCase )
for i, t in enumerate(scheduler.timesteps ):
lowerCamelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase = output.prev_sample
lowerCamelCase = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase = torch.mean(torch.abs(__UpperCamelCase ) )
if torch_device in ["cpu", "mps"]:
assert abs(result_sum.item() - 4.6934e-07 ) < 1e-2
assert abs(result_mean.item() - 6.1112e-10 ) < 1e-3
else:
# CUDA
assert abs(result_sum.item() - 4.693_4286_5017_0972e-07 ) < 1e-2
assert abs(result_mean.item() - 0.0002 ) < 1e-3
def lowerCamelCase__ ( self : List[Any] ) -> Optional[int]:
'''simple docstring'''
if torch_device == "mps":
return
lowerCamelCase = self.scheduler_classes[0]
lowerCamelCase = self.get_scheduler_config()
lowerCamelCase = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps )
lowerCamelCase = self.dummy_model()
lowerCamelCase = self.dummy_sample_deter * scheduler.init_noise_sigma
lowerCamelCase = sample.to(__UpperCamelCase )
for i, t in enumerate(scheduler.timesteps ):
lowerCamelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase = output.prev_sample
lowerCamelCase = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase = torch.mean(torch.abs(__UpperCamelCase ) )
if torch_device in ["cpu", "mps"]:
assert abs(result_sum.item() - 20.4125 ) < 1e-2
assert abs(result_mean.item() - 0.0266 ) < 1e-3
else:
# CUDA
assert abs(result_sum.item() - 20.4125 ) < 1e-2
assert abs(result_mean.item() - 0.0266 ) < 1e-3
def lowerCamelCase__ ( self : Optional[int] ) -> Optional[int]:
'''simple docstring'''
if torch_device == "mps":
return
lowerCamelCase = self.scheduler_classes[0]
lowerCamelCase = self.get_scheduler_config()
lowerCamelCase = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps , device=__UpperCamelCase )
lowerCamelCase = self.dummy_model()
lowerCamelCase = self.dummy_sample_deter.to(__UpperCamelCase ) * scheduler.init_noise_sigma
for t in scheduler.timesteps:
lowerCamelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase = output.prev_sample
lowerCamelCase = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase = torch.mean(torch.abs(__UpperCamelCase ) )
if str(__UpperCamelCase ).startswith('cpu' ):
# The following sum varies between 148 and 156 on mps. Why?
assert abs(result_sum.item() - 20.4125 ) < 1e-2
assert abs(result_mean.item() - 0.0266 ) < 1e-3
else:
# CUDA
assert abs(result_sum.item() - 20.4125 ) < 1e-2
assert abs(result_mean.item() - 0.0266 ) < 1e-3
| 246
|
import torch
from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device
from .test_schedulers import SchedulerCommonTest
class __A( UpperCAmelCase ):
SCREAMING_SNAKE_CASE = (KDPMaDiscreteScheduler,)
SCREAMING_SNAKE_CASE = 1_0
def lowercase__ ( self : str , **__UpperCamelCase : Optional[int] ):
lowerCamelCase_ = {
"""num_train_timesteps""": 1_1_0_0,
"""beta_start""": 0.0001,
"""beta_end""": 0.02,
"""beta_schedule""": """linear""",
}
config.update(**__UpperCamelCase )
return config
def lowercase__ ( self : Optional[Any] ):
for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]:
self.check_over_configs(num_train_timesteps=__UpperCamelCase )
def lowercase__ ( self : Dict ):
for beta_start, beta_end in zip([0.00001, 0.0001, 0.001] , [0.0002, 0.002, 0.02] ):
self.check_over_configs(beta_start=__UpperCamelCase , beta_end=__UpperCamelCase )
def lowercase__ ( self : Union[str, Any] ):
for schedule in ["linear", "scaled_linear"]:
self.check_over_configs(beta_schedule=__UpperCamelCase )
def lowercase__ ( self : List[str] ):
for prediction_type in ["epsilon", "v_prediction"]:
self.check_over_configs(prediction_type=__UpperCamelCase )
def lowercase__ ( self : Optional[int] ):
lowerCamelCase_ = self.scheduler_classes[0]
lowerCamelCase_ = self.get_scheduler_config(prediction_type="""v_prediction""" )
lowerCamelCase_ = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps )
lowerCamelCase_ = self.dummy_model()
lowerCamelCase_ = self.dummy_sample_deter * scheduler.init_noise_sigma
lowerCamelCase_ = sample.to(__UpperCamelCase )
for i, t in enumerate(scheduler.timesteps ):
lowerCamelCase_ = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = output.prev_sample
lowerCamelCase_ = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase_ = torch.mean(torch.abs(__UpperCamelCase ) )
if torch_device in ["cpu", "mps"]:
assert abs(result_sum.item() - 4.6934E-07 ) < 1E-2
assert abs(result_mean.item() - 6.1112E-10 ) < 1E-3
else:
# CUDA
assert abs(result_sum.item() - 4.693_4286_5017_0972E-07 ) < 1E-2
assert abs(result_mean.item() - 0.0002 ) < 1E-3
def lowercase__ ( self : List[Any] ):
if torch_device == "mps":
return
lowerCamelCase_ = self.scheduler_classes[0]
lowerCamelCase_ = self.get_scheduler_config()
lowerCamelCase_ = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps )
lowerCamelCase_ = self.dummy_model()
lowerCamelCase_ = self.dummy_sample_deter * scheduler.init_noise_sigma
lowerCamelCase_ = sample.to(__UpperCamelCase )
for i, t in enumerate(scheduler.timesteps ):
lowerCamelCase_ = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = output.prev_sample
lowerCamelCase_ = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase_ = torch.mean(torch.abs(__UpperCamelCase ) )
if torch_device in ["cpu", "mps"]:
assert abs(result_sum.item() - 20.4125 ) < 1E-2
assert abs(result_mean.item() - 0.0266 ) < 1E-3
else:
# CUDA
assert abs(result_sum.item() - 20.4125 ) < 1E-2
assert abs(result_mean.item() - 0.0266 ) < 1E-3
def lowercase__ ( self : Optional[int] ):
if torch_device == "mps":
return
lowerCamelCase_ = self.scheduler_classes[0]
lowerCamelCase_ = self.get_scheduler_config()
lowerCamelCase_ = scheduler_class(**__UpperCamelCase )
scheduler.set_timesteps(self.num_inference_steps , device=__UpperCamelCase )
lowerCamelCase_ = self.dummy_model()
lowerCamelCase_ = self.dummy_sample_deter.to(__UpperCamelCase ) * scheduler.init_noise_sigma
for t in scheduler.timesteps:
lowerCamelCase_ = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = model(__UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase )
lowerCamelCase_ = output.prev_sample
lowerCamelCase_ = torch.sum(torch.abs(__UpperCamelCase ) )
lowerCamelCase_ = torch.mean(torch.abs(__UpperCamelCase ) )
if str(__UpperCamelCase ).startswith("""cpu""" ):
# The following sum varies between 148 and 156 on mps. Why?
assert abs(result_sum.item() - 20.4125 ) < 1E-2
assert abs(result_mean.item() - 0.0266 ) < 1E-3
else:
# CUDA
assert abs(result_sum.item() - 20.4125 ) < 1E-2
assert abs(result_mean.item() - 0.0266 ) < 1E-3
| 272
| 0
|
import math
import torch
from torch import nn
from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin
class UpperCAmelCase( snake_case_ , snake_case_ ):
"""simple docstring"""
@register_to_config
def __init__( self , lowerCamelCase = 128 , lowerCamelCase = 256 , lowerCamelCase = 20_00.0 , lowerCamelCase = 768 , lowerCamelCase = 12 , lowerCamelCase = 12 , lowerCamelCase = 64 , lowerCamelCase = 2048 , lowerCamelCase = 0.1 , ) -> Dict:
"""simple docstring"""
super().__init__()
lowercase__ : List[str] = nn.Sequential(
nn.Linear(lowerCamelCase , d_model * 4 , bias=lowerCamelCase ) , nn.SiLU() , nn.Linear(d_model * 4 , d_model * 4 , bias=lowerCamelCase ) , nn.SiLU() , )
lowercase__ : Optional[Any] = nn.Embedding(lowerCamelCase , lowerCamelCase )
lowercase__ : Dict = False
lowercase__ : Optional[Any] = nn.Linear(lowerCamelCase , lowerCamelCase , bias=lowerCamelCase )
lowercase__ : Tuple = nn.Dropout(p=lowerCamelCase )
lowercase__ : Any = nn.ModuleList()
for lyr_num in range(lowerCamelCase ):
# FiLM conditional T5 decoder
lowercase__ : str = DecoderLayer(d_model=lowerCamelCase , d_kv=lowerCamelCase , num_heads=lowerCamelCase , d_ff=lowerCamelCase , dropout_rate=lowerCamelCase )
self.decoders.append(lowerCamelCase )
lowercase__ : List[str] = TaLayerNorm(lowerCamelCase )
lowercase__ : str = nn.Dropout(p=lowerCamelCase )
lowercase__ : Optional[int] = nn.Linear(lowerCamelCase , lowerCamelCase , bias=lowerCamelCase )
def __a ( self , lowerCamelCase , lowerCamelCase ) -> Any:
"""simple docstring"""
lowercase__ : str = torch.mul(query_input.unsqueeze(-1 ) , key_input.unsqueeze(-2 ) )
return mask.unsqueeze(-3 )
def __a ( self , lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Union[str, Any]:
"""simple docstring"""
lowercase__ , lowercase__ , lowercase__ : Optional[Any] = decoder_input_tokens.shape
assert decoder_noise_time.shape == (batch,)
# decoder_noise_time is in [0, 1), so rescale to expected timing range.
lowercase__ : Dict = get_timestep_embedding(
decoder_noise_time * self.config.max_decoder_noise_time , embedding_dim=self.config.d_model , max_period=self.config.max_decoder_noise_time , ).to(dtype=self.dtype )
lowercase__ : List[Any] = self.conditioning_emb(lowerCamelCase ).unsqueeze(1 )
assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)
lowercase__ : Union[str, Any] = decoder_input_tokens.shape[1]
# If we want to use relative positions for audio context, we can just offset
# this sequence by the length of encodings_and_masks.
lowercase__ : str = torch.broadcast_to(
torch.arange(lowerCamelCase , device=decoder_input_tokens.device ) , (batch, seq_length) , )
lowercase__ : List[Any] = self.position_encoding(lowerCamelCase )
lowercase__ : str = self.continuous_inputs_projection(lowerCamelCase )
inputs += position_encodings
lowercase__ : Optional[Any] = self.dropout(lowerCamelCase )
# decoder: No padding present.
lowercase__ : List[str] = torch.ones(
decoder_input_tokens.shape[:2] , device=decoder_input_tokens.device , dtype=inputs.dtype )
# Translate encoding masks to encoder-decoder masks.
lowercase__ : List[str] = [(x, self.encoder_decoder_mask(lowerCamelCase , lowerCamelCase )) for x, y in encodings_and_masks]
# cross attend style: concat encodings
lowercase__ : int = torch.cat([x[0] for x in encodings_and_encdec_masks] , dim=1 )
lowercase__ : List[Any] = torch.cat([x[1] for x in encodings_and_encdec_masks] , dim=-1 )
for lyr in self.decoders:
lowercase__ : Optional[int] = lyr(
lowerCamelCase , conditioning_emb=lowerCamelCase , encoder_hidden_states=lowerCamelCase , encoder_attention_mask=lowerCamelCase , )[0]
lowercase__ : List[Any] = self.decoder_norm(lowerCamelCase )
lowercase__ : List[str] = self.post_dropout(lowerCamelCase )
lowercase__ : Dict = self.spec_out(lowerCamelCase )
return spec_out
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase=1E-6 ) -> int:
"""simple docstring"""
super().__init__()
lowercase__ : Any = nn.ModuleList()
# cond self attention: layer 0
self.layer.append(
TaLayerSelfAttentionCond(d_model=lowerCamelCase , d_kv=lowerCamelCase , num_heads=lowerCamelCase , dropout_rate=lowerCamelCase ) )
# cross attention: layer 1
self.layer.append(
TaLayerCrossAttention(
d_model=lowerCamelCase , d_kv=lowerCamelCase , num_heads=lowerCamelCase , dropout_rate=lowerCamelCase , layer_norm_epsilon=lowerCamelCase , ) )
# Film Cond MLP + dropout: last layer
self.layer.append(
TaLayerFFCond(d_model=lowerCamelCase , d_ff=lowerCamelCase , dropout_rate=lowerCamelCase , layer_norm_epsilon=lowerCamelCase ) )
def __a ( self , lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase=None , ) -> List[Any]:
"""simple docstring"""
lowercase__ : Tuple = self.layer[0](
lowerCamelCase , conditioning_emb=lowerCamelCase , attention_mask=lowerCamelCase , )
if encoder_hidden_states is not None:
lowercase__ : int = torch.where(encoder_attention_mask > 0 , 0 , -1E10 ).to(
encoder_hidden_states.dtype )
lowercase__ : Any = self.layer[1](
lowerCamelCase , key_value_states=lowerCamelCase , attention_mask=lowerCamelCase , )
# Apply Film Conditional Feed Forward layer
lowercase__ : Optional[int] = self.layer[-1](lowerCamelCase , lowerCamelCase )
return (hidden_states,)
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> List[Any]:
"""simple docstring"""
super().__init__()
lowercase__ : Dict = TaLayerNorm(lowerCamelCase )
lowercase__ : List[str] = TaFiLMLayer(in_features=d_model * 4 , out_features=lowerCamelCase )
lowercase__ : Any = Attention(query_dim=lowerCamelCase , heads=lowerCamelCase , dim_head=lowerCamelCase , out_bias=lowerCamelCase , scale_qk=lowerCamelCase )
lowercase__ : Any = nn.Dropout(lowerCamelCase )
def __a ( self , lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , ) -> Optional[int]:
"""simple docstring"""
lowercase__ : Tuple = self.layer_norm(lowerCamelCase )
if conditioning_emb is not None:
lowercase__ : str = self.FiLMLayer(lowerCamelCase , lowerCamelCase )
# Self-attention block
lowercase__ : Tuple = self.attention(lowerCamelCase )
lowercase__ : List[str] = hidden_states + self.dropout(lowerCamelCase )
return hidden_states
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Dict:
"""simple docstring"""
super().__init__()
lowercase__ : str = Attention(query_dim=lowerCamelCase , heads=lowerCamelCase , dim_head=lowerCamelCase , out_bias=lowerCamelCase , scale_qk=lowerCamelCase )
lowercase__ : Optional[int] = TaLayerNorm(lowerCamelCase , eps=lowerCamelCase )
lowercase__ : int = nn.Dropout(lowerCamelCase )
def __a ( self , lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , ) -> Optional[Any]:
"""simple docstring"""
lowercase__ : int = self.layer_norm(lowerCamelCase )
lowercase__ : Dict = self.attention(
lowerCamelCase , encoder_hidden_states=lowerCamelCase , attention_mask=attention_mask.squeeze(1 ) , )
lowercase__ : Dict = hidden_states + self.dropout(lowerCamelCase )
return layer_output
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> str:
"""simple docstring"""
super().__init__()
lowercase__ : str = TaDenseGatedActDense(d_model=lowerCamelCase , d_ff=lowerCamelCase , dropout_rate=lowerCamelCase )
lowercase__ : Optional[int] = TaFiLMLayer(in_features=d_model * 4 , out_features=lowerCamelCase )
lowercase__ : Tuple = TaLayerNorm(lowerCamelCase , eps=lowerCamelCase )
lowercase__ : List[str] = nn.Dropout(lowerCamelCase )
def __a ( self , lowerCamelCase , lowerCamelCase=None ) -> List[Any]:
"""simple docstring"""
lowercase__ : List[str] = self.layer_norm(lowerCamelCase )
if conditioning_emb is not None:
lowercase__ : Any = self.film(lowerCamelCase , lowerCamelCase )
lowercase__ : Dict = self.DenseReluDense(lowerCamelCase )
lowercase__ : Union[str, Any] = hidden_states + self.dropout(lowerCamelCase )
return hidden_states
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Tuple:
"""simple docstring"""
super().__init__()
lowercase__ : Dict = nn.Linear(lowerCamelCase , lowerCamelCase , bias=lowerCamelCase )
lowercase__ : str = nn.Linear(lowerCamelCase , lowerCamelCase , bias=lowerCamelCase )
lowercase__ : Optional[int] = nn.Linear(lowerCamelCase , lowerCamelCase , bias=lowerCamelCase )
lowercase__ : List[Any] = nn.Dropout(lowerCamelCase )
lowercase__ : int = NewGELUActivation()
def __a ( self , lowerCamelCase ) -> Union[str, Any]:
"""simple docstring"""
lowercase__ : Tuple = self.act(self.wi_a(lowerCamelCase ) )
lowercase__ : List[str] = self.wi_a(lowerCamelCase )
lowercase__ : List[str] = hidden_gelu * hidden_linear
lowercase__ : Dict = self.dropout(lowerCamelCase )
lowercase__ : str = self.wo(lowerCamelCase )
return hidden_states
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase=1E-6 ) -> List[Any]:
"""simple docstring"""
super().__init__()
lowercase__ : List[Any] = nn.Parameter(torch.ones(lowerCamelCase ) )
lowercase__ : List[Any] = eps
def __a ( self , lowerCamelCase ) -> Union[str, Any]:
"""simple docstring"""
lowercase__ : Optional[int] = hidden_states.to(torch.floataa ).pow(2 ).mean(-1 , keepdim=lowerCamelCase )
lowercase__ : str = hidden_states * torch.rsqrt(variance + self.variance_epsilon )
# convert into half-precision if necessary
if self.weight.dtype in [torch.floataa, torch.bfloataa]:
lowercase__ : int = hidden_states.to(self.weight.dtype )
return self.weight * hidden_states
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __a ( self , lowerCamelCase ) -> torch.Tensor:
"""simple docstring"""
return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi ) * (input + 0.04_47_15 * torch.pow(lowerCamelCase , 3.0 )) ))
class UpperCAmelCase( nn.Module ):
"""simple docstring"""
def __init__( self , lowerCamelCase , lowerCamelCase ) -> str:
"""simple docstring"""
super().__init__()
lowercase__ : Optional[int] = nn.Linear(lowerCamelCase , out_features * 2 , bias=lowerCamelCase )
def __a ( self , lowerCamelCase , lowerCamelCase ) -> Any:
"""simple docstring"""
lowercase__ : int = self.scale_bias(lowerCamelCase )
lowercase__ , lowercase__ : Any = torch.chunk(lowerCamelCase , 2 , -1 )
lowercase__ : Tuple = x * (1 + scale) + shift
return x
| 298
|
import argparse
import collections
import torch
from flax import traverse_util
from tax import checkpoints
from transformers import TaConfig, TaEncoderModel, TaForConditionalGeneration
from transformers.utils import logging
logging.set_verbosity_info()
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_="attention" ) -> int:
lowercase__ : Tuple = params[F"""{prefix}/layers_{i}/{layer_name}/key/kernel"""]
lowercase__ : str = params[F"""{prefix}/layers_{i}/{layer_name}/out/kernel"""]
lowercase__ : List[Any] = params[F"""{prefix}/layers_{i}/{layer_name}/query/kernel"""]
lowercase__ : List[str] = params[F"""{prefix}/layers_{i}/{layer_name}/value/kernel"""]
return k, o, q, v
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_=False ) -> Any:
if split_mlp_wi:
lowercase__ : int = params[F"""{prefix}/layers_{i}/mlp/wi_0/kernel"""]
lowercase__ : List[Any] = params[F"""{prefix}/layers_{i}/mlp/wi_1/kernel"""]
lowercase__ : Optional[int] = (wi_a, wi_a)
else:
lowercase__ : Optional[int] = params[F"""{prefix}/layers_{i}/mlp/wi/kernel"""]
lowercase__ : Tuple = params[F"""{prefix}/layers_{i}/mlp/wo/kernel"""]
return wi, wo
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ) -> int:
return params[F"""{prefix}/layers_{i}/{layer_name}/scale"""]
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,*, SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ) -> Any:
lowercase__ : List[Any] = traverse_util.flatten_dict(variables["target"] )
lowercase__ : Any = {"/".join(SCREAMING_SNAKE_CASE_ ): v for k, v in old.items()}
# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
lowercase__ : Optional[int] = "encoder/layers_0/mlp/wi_0/kernel" in old
print("Split MLP:" ,SCREAMING_SNAKE_CASE_ )
lowercase__ : Optional[int] = collections.OrderedDict()
# Shared embeddings.
lowercase__ : List[Any] = old["token_embedder/embedding"]
# Encoder.
for i in range(SCREAMING_SNAKE_CASE_ ):
# Block i, layer 0 (Self Attention).
lowercase__ : Any = tax_layer_norm_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"encoder" ,"pre_attention_layer_norm" )
lowercase__ , lowercase__ , lowercase__ , lowercase__ : Optional[Any] = tax_attention_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"encoder" ,"attention" )
lowercase__ : Tuple = layer_norm
lowercase__ : Optional[Any] = k.T
lowercase__ : Optional[int] = o.T
lowercase__ : Optional[int] = q.T
lowercase__ : str = v.T
# Block i, layer 1 (MLP).
lowercase__ : Union[str, Any] = tax_layer_norm_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"encoder" ,"pre_mlp_layer_norm" )
lowercase__ , lowercase__ : str = tax_mlp_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"encoder" ,SCREAMING_SNAKE_CASE_ )
lowercase__ : List[str] = layer_norm
if split_mlp_wi:
lowercase__ : Dict = wi[0].T
lowercase__ : Optional[int] = wi[1].T
else:
lowercase__ : List[Any] = wi.T
lowercase__ : Optional[Any] = wo.T
lowercase__ : Optional[int] = old[
"encoder/relpos_bias/rel_embedding"
].T
lowercase__ : Tuple = old["encoder/encoder_norm/scale"]
if not is_encoder_only:
# Decoder.
for i in range(SCREAMING_SNAKE_CASE_ ):
# Block i, layer 0 (Self Attention).
lowercase__ : Optional[int] = tax_layer_norm_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,"pre_self_attention_layer_norm" )
lowercase__ , lowercase__ , lowercase__ , lowercase__ : List[Any] = tax_attention_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,"self_attention" )
lowercase__ : List[str] = layer_norm
lowercase__ : str = k.T
lowercase__ : int = o.T
lowercase__ : Dict = q.T
lowercase__ : Optional[int] = v.T
# Block i, layer 1 (Cross Attention).
lowercase__ : Optional[Any] = tax_layer_norm_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,"pre_cross_attention_layer_norm" )
lowercase__ , lowercase__ , lowercase__ , lowercase__ : List[Any] = tax_attention_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,"encoder_decoder_attention" )
lowercase__ : Union[str, Any] = layer_norm
lowercase__ : List[Any] = k.T
lowercase__ : str = o.T
lowercase__ : str = q.T
lowercase__ : Dict = v.T
# Block i, layer 2 (MLP).
lowercase__ : Any = tax_layer_norm_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,"pre_mlp_layer_norm" )
lowercase__ , lowercase__ : Optional[Any] = tax_mlp_lookup(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,"decoder" ,SCREAMING_SNAKE_CASE_ )
lowercase__ : Optional[Any] = layer_norm
if split_mlp_wi:
lowercase__ : int = wi[0].T
lowercase__ : Dict = wi[1].T
else:
lowercase__ : Any = wi.T
lowercase__ : Union[str, Any] = wo.T
lowercase__ : Tuple = old["decoder/decoder_norm/scale"]
lowercase__ : List[Any] = old[
"decoder/relpos_bias/rel_embedding"
].T
# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
if "decoder/logits_dense/kernel" in old:
lowercase__ : Union[str, Any] = old["decoder/logits_dense/kernel"].T
return new
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ) -> List[str]:
lowercase__ : int = collections.OrderedDict([(k, torch.from_numpy(v.copy() )) for (k, v) in converted_params.items()] )
# Add what is missing.
if "encoder.embed_tokens.weight" not in state_dict:
lowercase__ : Tuple = state_dict["shared.weight"]
if not is_encoder_only:
if "decoder.embed_tokens.weight" not in state_dict:
lowercase__ : Optional[int] = state_dict["shared.weight"]
if "lm_head.weight" not in state_dict: # For old 1.0 models.
print("Using shared word embeddings as lm_head." )
lowercase__ : str = state_dict["shared.weight"]
return state_dict
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ) -> Tuple:
lowercase__ : Optional[Any] = checkpoints.load_tax_checkpoint(SCREAMING_SNAKE_CASE_ )
lowercase__ : List[str] = convert_tax_to_pytorch(SCREAMING_SNAKE_CASE_ ,num_layers=config.num_layers ,is_encoder_only=SCREAMING_SNAKE_CASE_ )
lowercase__ : Optional[int] = make_state_dict(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ )
model.load_state_dict(SCREAMING_SNAKE_CASE_ ,strict=SCREAMING_SNAKE_CASE_ )
def snake_case_ ( SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ = False ) -> Tuple:
lowercase__ : Optional[int] = TaConfig.from_json_file(SCREAMING_SNAKE_CASE_ )
print(F"""Building PyTorch model from configuration: {config}""" )
# Non-v1.1 checkpoints could also use T5Model, but this works for all.
# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
if is_encoder_only:
lowercase__ : List[Any] = TaEncoderModel(SCREAMING_SNAKE_CASE_ )
else:
lowercase__ : Union[str, Any] = TaForConditionalGeneration(SCREAMING_SNAKE_CASE_ )
# Load weights from tf checkpoint
load_tax_weights_in_ta(SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ ,SCREAMING_SNAKE_CASE_ )
# Save pytorch-model
print(F"""Save PyTorch model to {pytorch_dump_path}""" )
model.save_pretrained(SCREAMING_SNAKE_CASE_ )
# Verify that we can load the checkpoint.
model.from_pretrained(SCREAMING_SNAKE_CASE_ )
print("Done" )
if __name__ == "__main__":
__a : Tuple = argparse.ArgumentParser(description='''Converts a native T5X checkpoint into a PyTorch checkpoint.''')
# Required parameters
parser.add_argument(
'''--t5x_checkpoint_path''', default=None, type=str, required=True, help='''Path to the T5X checkpoint.'''
)
parser.add_argument(
'''--config_file''',
default=None,
type=str,
required=True,
help='''The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.''',
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_encoder_only''', action='''store_true''', help='''Check if the model is encoder-decoder model''', default=False
)
__a : Any = parser.parse_args()
convert_tax_checkpoint_to_pytorch(
args.tax_checkpoint_path, args.config_file, args.pytorch_dump_path, args.is_encoder_only
)
| 298
| 1
|
'''simple docstring'''
import argparse
import json
import os
import fairseq
import torch
from fairseq.data import Dictionary
from transformers import (
WavaVecaConfig,
WavaVecaCTCTokenizer,
WavaVecaFeatureExtractor,
WavaVecaForCTC,
WavaVecaForPreTraining,
WavaVecaProcessor,
logging,
)
from transformers.models.wavaveca.modeling_wavaveca import WavaVecaForSequenceClassification
logging.set_verbosity_info()
UpperCamelCase__: Tuple = logging.get_logger(__name__)
UpperCamelCase__: Union[str, Any] = {
'''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''',
'''adapter_layer''': '''encoder.layers.*.adapter_layer''',
'''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''',
'''pooling_layer.linear''': '''projector''',
'''pooling_layer.projection''': '''classifier''',
}
UpperCamelCase__: Union[str, Any] = [
'''lm_head''',
'''quantizer.weight_proj''',
'''quantizer.codevectors''',
'''project_q''',
'''project_hid''',
'''projector''',
'''classifier''',
]
def snake_case_ ( _lowerCAmelCase : Tuple ) -> Union[str, Any]:
UpperCAmelCase : List[Any] = {}
with open(SCREAMING_SNAKE_CASE__ , '''r''' ) as file:
for line_number, line in enumerate(SCREAMING_SNAKE_CASE__ ):
UpperCAmelCase : str = line.strip()
if line:
UpperCAmelCase : str = line.split()
UpperCAmelCase : Optional[int] = line_number
UpperCAmelCase : str = words[0]
UpperCAmelCase : Dict = value
return result
def snake_case_ ( _lowerCAmelCase : int , _lowerCAmelCase : Any , _lowerCAmelCase : str , _lowerCAmelCase : Dict , _lowerCAmelCase : Dict ) -> Optional[int]:
for attribute in key.split('''.''' ):
UpperCAmelCase : Union[str, Any] = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Optional[int] = None
for param_key in PARAM_MAPPING.keys():
if full_name.endswith(SCREAMING_SNAKE_CASE__ ):
UpperCAmelCase : int = PARAM_MAPPING[full_name.split('''.''' )[-1]]
UpperCAmelCase : Tuple = "param"
if weight_type is not None and weight_type != "param":
UpperCAmelCase : Union[str, Any] = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ).shape
elif weight_type is not None and weight_type == "param":
UpperCAmelCase : Dict = hf_pointer
for attribute in hf_param_name.split('''.''' ):
UpperCAmelCase : Tuple = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Optional[int] = shape_pointer.shape
# let's reduce dimension
UpperCAmelCase : List[str] = value[0]
else:
UpperCAmelCase : Optional[Any] = hf_pointer.shape
if hf_shape != value.shape:
raise ValueError(
f"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be"""
f""" {value.shape} for {full_name}""" )
if weight_type == "weight":
UpperCAmelCase : Union[str, Any] = value
elif weight_type == "weight_g":
UpperCAmelCase : List[Any] = value
elif weight_type == "weight_v":
UpperCAmelCase : str = value
elif weight_type == "bias":
UpperCAmelCase : str = value
elif weight_type == "param":
for attribute in hf_param_name.split('''.''' ):
UpperCAmelCase : Any = getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : List[Any] = value
else:
UpperCAmelCase : Optional[int] = value
logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""" )
def snake_case_ ( _lowerCAmelCase : Any , _lowerCAmelCase : Dict , _lowerCAmelCase : Dict , _lowerCAmelCase : str , _lowerCAmelCase : Optional[Any] ) -> List[Any]:
UpperCAmelCase : Dict = None
for param_key in PARAM_MAPPING.keys():
if full_name.endswith(SCREAMING_SNAKE_CASE__ ):
UpperCAmelCase : Dict = PARAM_MAPPING[full_name.split('''.''' )[-1]]
UpperCAmelCase : str = "param"
if weight_type is not None and weight_type != "param":
UpperCAmelCase : Dict = ".".join([key, weight_type] )
elif weight_type is not None and weight_type == "param":
UpperCAmelCase : Union[str, Any] = ".".join([key, hf_param_name] )
else:
UpperCAmelCase : Dict = key
UpperCAmelCase : Optional[Any] = value if "lm_head" in full_key else value[0]
UpperCamelCase__: Optional[int] = {
'''W_a''': '''linear_1.weight''',
'''W_b''': '''linear_2.weight''',
'''b_a''': '''linear_1.bias''',
'''b_b''': '''linear_2.bias''',
'''ln_W''': '''norm.weight''',
'''ln_b''': '''norm.bias''',
}
def snake_case_ ( _lowerCAmelCase : List[Any] , _lowerCAmelCase : Tuple , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Optional[Any]=None ) -> Any:
UpperCAmelCase : Any = False
for key, mapped_key in MAPPING.items():
UpperCAmelCase : Dict = "wav2vec2." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]:
UpperCAmelCase : Dict = True
if "*" in mapped_key:
UpperCAmelCase : Any = name.split(SCREAMING_SNAKE_CASE__ )[0].split('''.''' )[-2]
UpperCAmelCase : int = mapped_key.replace('''*''' , SCREAMING_SNAKE_CASE__ )
if "weight_g" in name:
UpperCAmelCase : Tuple = "weight_g"
elif "weight_v" in name:
UpperCAmelCase : int = "weight_v"
elif "bias" in name:
UpperCAmelCase : Tuple = "bias"
elif "weight" in name:
# TODO: don't match quantizer.weight_proj
UpperCAmelCase : Union[str, Any] = "weight"
else:
UpperCAmelCase : List[str] = None
if hf_dict is not None:
rename_dict(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
else:
set_recursively(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
return is_used
return is_used
def snake_case_ ( _lowerCAmelCase : str , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[Any] ) -> int:
UpperCAmelCase : List[str] = []
UpperCAmelCase : List[str] = fairseq_model.state_dict()
UpperCAmelCase : Tuple = hf_model.wavaveca.feature_extractor
for name, value in fairseq_dict.items():
UpperCAmelCase : List[Any] = 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''' , )
UpperCAmelCase : Any = True
else:
UpperCAmelCase : int = load_wavaveca_layer(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
if not is_used:
unused_weights.append(SCREAMING_SNAKE_CASE__ )
logger.warning(f"""Unused weights: {unused_weights}""" )
def snake_case_ ( _lowerCAmelCase : int , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Union[str, Any] ) -> Dict:
UpperCAmelCase : str = full_name.split('''conv_layers.''' )[-1]
UpperCAmelCase : Optional[int] = name.split('''.''' )
UpperCAmelCase : Union[str, Any] = int(items[0] )
UpperCAmelCase : Union[str, Any] = int(items[1] )
if type_id == 0:
if "bias" in name:
if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
raise ValueError(
f"""{full_name} has size {value.shape}, but"""
f""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.""" )
UpperCAmelCase : Tuple = value
logger.info(f"""Feat extract conv layer {layer_id} was initialized from {full_name}.""" )
elif "weight" in name:
if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
raise ValueError(
f"""{full_name} has size {value.shape}, but"""
f""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.""" )
UpperCAmelCase : 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:
if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
raise ValueError(
f"""{full_name} has size {value.shape}, but"""
f""" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.""" )
UpperCAmelCase : Tuple = value
logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""" )
elif "weight" in name:
if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
raise ValueError(
f"""{full_name} has size {value.shape}, but"""
f""" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.""" )
UpperCAmelCase : Union[str, 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__ )
@torch.no_grad()
def snake_case_ ( _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Dict=True , _lowerCAmelCase : List[str]=False ) -> Dict:
if config_path is not None:
UpperCAmelCase : int = WavaVecaConfig.from_pretrained(SCREAMING_SNAKE_CASE__ )
else:
UpperCAmelCase : Optional[int] = WavaVecaConfig()
if is_seq_class:
UpperCAmelCase : str = read_txt_into_dict(SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Optional[int] = idalabel
UpperCAmelCase : List[str] = WavaVecaForSequenceClassification(SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : List[Any] = WavaVecaFeatureExtractor(
feature_size=1 , sampling_rate=16000 , padding_value=0 , do_normalize=SCREAMING_SNAKE_CASE__ , return_attention_mask=SCREAMING_SNAKE_CASE__ , )
feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__ )
elif is_finetuned:
if dict_path:
UpperCAmelCase : Optional[Any] = Dictionary.load(SCREAMING_SNAKE_CASE__ )
# important change bos & pad token id since CTC symbol is <pad> and
# not <s> as in fairseq
UpperCAmelCase : Optional[int] = target_dict.pad_index
UpperCAmelCase : List[Any] = target_dict.bos_index
UpperCAmelCase : Tuple = target_dict.eos_index
UpperCAmelCase : Tuple = len(target_dict.symbols )
UpperCAmelCase : Dict = os.path.join(SCREAMING_SNAKE_CASE__ , '''vocab.json''' )
if not os.path.isdir(SCREAMING_SNAKE_CASE__ ):
logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(SCREAMING_SNAKE_CASE__ ) )
return
os.makedirs(SCREAMING_SNAKE_CASE__ , exist_ok=SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Union[str, Any] = target_dict.indices
# fairseq has the <pad> and <s> switched
UpperCAmelCase : List[Any] = 0
UpperCAmelCase : Dict = 1
with open(SCREAMING_SNAKE_CASE__ , '''w''' , encoding='''utf-8''' ) as vocab_handle:
json.dump(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : List[Any] = WavaVecaCTCTokenizer(
SCREAMING_SNAKE_CASE__ , unk_token=target_dict.unk_word , pad_token=target_dict.pad_word , bos_token=target_dict.bos_word , eos_token=target_dict.eos_word , word_delimiter_token='''|''' , do_lower_case=SCREAMING_SNAKE_CASE__ , )
UpperCAmelCase : int = True if config.feat_extract_norm == "layer" else False
UpperCAmelCase : List[Any] = WavaVecaFeatureExtractor(
feature_size=1 , sampling_rate=16000 , padding_value=0 , do_normalize=SCREAMING_SNAKE_CASE__ , return_attention_mask=SCREAMING_SNAKE_CASE__ , )
UpperCAmelCase : Any = WavaVecaProcessor(feature_extractor=SCREAMING_SNAKE_CASE__ , tokenizer=SCREAMING_SNAKE_CASE__ )
processor.save_pretrained(SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Union[str, Any] = WavaVecaForCTC(SCREAMING_SNAKE_CASE__ )
else:
UpperCAmelCase : Dict = WavaVecaForPreTraining(SCREAMING_SNAKE_CASE__ )
if is_finetuned or is_seq_class:
UpperCAmelCase : str = fairseq.checkpoint_utils.load_model_ensemble_and_task(
[checkpoint_path] , arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} )
else:
UpperCAmelCase : int = argparse.Namespace(task='''audio_pretraining''' )
UpperCAmelCase : Any = fairseq.tasks.setup_task(SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Dict = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] , task=SCREAMING_SNAKE_CASE__ )
UpperCAmelCase : Any = model[0].eval()
recursively_load_weights(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , not is_finetuned )
hf_wavavec.save_pretrained(SCREAMING_SNAKE_CASE__ )
if __name__ == "__main__":
UpperCamelCase__: Dict = 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_path", default=None, type=str, help="Path to hf config.json of model to convert")
parser.add_argument(
"--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
)
parser.add_argument(
"--is_seq_class",
action="store_true",
help="Whether the model to convert is a fine-tuned sequence classification model or not",
)
UpperCamelCase__: str = parser.parse_args()
UpperCamelCase__: Union[str, Any] = not args.not_finetuned and not args.is_seq_class
convert_wavaveca_checkpoint(
args.checkpoint_path,
args.pytorch_dump_folder_path,
args.config_path,
args.dict_path,
is_finetuned,
args.is_seq_class,
)
| 127
|
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_tf_available,
is_torch_available,
is_vision_available,
)
_lowerCamelCase : Optional[Any] = {
'''configuration_mobilevit''': ['''MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MobileViTConfig''', '''MobileViTOnnxConfig'''],
}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase : Optional[int] = ['''MobileViTFeatureExtractor''']
_lowerCamelCase : List[str] = ['''MobileViTImageProcessor''']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase : Optional[Any] = [
'''MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''MobileViTForImageClassification''',
'''MobileViTForSemanticSegmentation''',
'''MobileViTModel''',
'''MobileViTPreTrainedModel''',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowerCamelCase : Optional[int] = [
'''TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFMobileViTForImageClassification''',
'''TFMobileViTForSemanticSegmentation''',
'''TFMobileViTModel''',
'''TFMobileViTPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_mobilevit import MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileViTConfig, MobileViTOnnxConfig
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_mobilevit import MobileViTFeatureExtractor
from .image_processing_mobilevit import MobileViTImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_mobilevit import (
MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
MobileViTForImageClassification,
MobileViTForSemanticSegmentation,
MobileViTModel,
MobileViTPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_mobilevit import (
TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFMobileViTForImageClassification,
TFMobileViTForSemanticSegmentation,
TFMobileViTModel,
TFMobileViTPreTrainedModel,
)
else:
import sys
_lowerCamelCase : Union[str, Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 663
| 0
|
from __future__ import annotations
from collections.abc import Callable
from typing import Any, Generic, TypeVar
__magic_name__ = TypeVar('''T''')
class a__ ( Generic[T] ):
"""simple docstring"""
def __init__( self :str , lowercase__ :list[T] , lowercase__ :Callable[[T, T], T] ):
lowercase = None
lowercase = len(lowercase__ )
lowercase = [any_type for _ in range(self.N )] + arr
lowercase = fnc
self.build()
def __UpperCAmelCase ( self :Any ):
for p in range(self.N - 1 , 0 , -1 ):
lowercase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] )
def __UpperCAmelCase ( self :Tuple , lowercase__ :int , lowercase__ :T ):
p += self.N
lowercase = v
while p > 1:
lowercase = p // 2
lowercase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] )
def __UpperCAmelCase ( self :Any , lowercase__ :int , lowercase__ :int ): # noqa: E741
lowercase , lowercase = l + self.N, r + self.N
lowercase = None
while l <= r:
if l % 2 == 1:
lowercase = self.st[l] if res is None else self.fn(lowercase__ , self.st[l] )
if r % 2 == 0:
lowercase = self.st[r] if res is None else self.fn(lowercase__ , self.st[r] )
lowercase , lowercase = (l + 1) // 2, (r - 1) // 2
return res
if __name__ == "__main__":
from functools import reduce
__magic_name__ = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12]
__magic_name__ = {
0: 7,
1: 2,
2: 6,
3: -14,
4: 5,
5: 4,
6: 7,
7: -10,
8: 9,
9: 10,
10: 12,
11: 1,
}
__magic_name__ = SegmentTree(test_array, min)
__magic_name__ = SegmentTree(test_array, max)
__magic_name__ = SegmentTree(test_array, lambda a, b: a + b)
def __snake_case ( ):
"""simple docstring"""
for i in range(len(_UpperCAmelCase ) ):
for j in range(_UpperCAmelCase , len(_UpperCAmelCase ) ):
lowercase = reduce(_UpperCAmelCase , test_array[i : j + 1] )
lowercase = reduce(_UpperCAmelCase , test_array[i : j + 1] )
lowercase = reduce(lambda _UpperCAmelCase , _UpperCAmelCase : a + b , test_array[i : j + 1] )
assert min_range == min_segment_tree.query(_UpperCAmelCase , _UpperCAmelCase )
assert max_range == max_segment_tree.query(_UpperCAmelCase , _UpperCAmelCase )
assert sum_range == sum_segment_tree.query(_UpperCAmelCase , _UpperCAmelCase )
test_all_segments()
for index, value in test_updates.items():
__magic_name__ = value
min_segment_tree.update(index, value)
max_segment_tree.update(index, value)
sum_segment_tree.update(index, value)
test_all_segments()
| 314
|
import unittest
from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin
__magic_name__ = get_tests_dir('''fixtures/test_sentencepiece.model''')
@require_sentencepiece
@require_tokenizers
class a__ ( _snake_case , unittest.TestCase ):
"""simple docstring"""
A__ : List[Any] = XLNetTokenizer
A__ : str = XLNetTokenizerFast
A__ : str = True
A__ : int = True
def __UpperCAmelCase ( self :Optional[int] ):
super().setUp()
# We have a SentencePiece fixture for testing
lowercase = XLNetTokenizer(lowercase__ , keep_accents=lowercase__ )
tokenizer.sanitize_special_tokens()
tokenizer.save_pretrained(self.tmpdirname )
def __UpperCAmelCase ( self :List[str] ):
lowercase = '<s>'
lowercase = 1
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowercase__ ) , lowercase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowercase__ ) , lowercase__ )
def __UpperCAmelCase ( self :Optional[int] ):
lowercase = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] , '<unk>' )
self.assertEqual(vocab_keys[1] , '<s>' )
self.assertEqual(vocab_keys[-1] , '<eod>' )
self.assertEqual(len(lowercase__ ) , 1006 )
def __UpperCAmelCase ( self :Union[str, Any] ):
self.assertEqual(self.get_tokenizer().vocab_size , 1000 )
def __UpperCAmelCase ( self :Dict ):
lowercase = XLNetTokenizer(lowercase__ , keep_accents=lowercase__ )
lowercase = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowercase__ , ['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase__ ) , [285, 46, 10, 170, 382] )
lowercase = tokenizer.tokenize('I was born in 92000, and this is falsé.' )
self.assertListEqual(
lowercase__ , [
SPIECE_UNDERLINE + 'I',
SPIECE_UNDERLINE + 'was',
SPIECE_UNDERLINE + 'b',
'or',
'n',
SPIECE_UNDERLINE + 'in',
SPIECE_UNDERLINE + '',
'9',
'2',
'0',
'0',
'0',
',',
SPIECE_UNDERLINE + 'and',
SPIECE_UNDERLINE + 'this',
SPIECE_UNDERLINE + 'is',
SPIECE_UNDERLINE + 'f',
'al',
's',
'é',
'.',
] , )
lowercase = tokenizer.convert_tokens_to_ids(lowercase__ )
self.assertListEqual(lowercase__ , [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4] )
lowercase = tokenizer.convert_ids_to_tokens(lowercase__ )
self.assertListEqual(
lowercase__ , [
SPIECE_UNDERLINE + 'I',
SPIECE_UNDERLINE + 'was',
SPIECE_UNDERLINE + 'b',
'or',
'n',
SPIECE_UNDERLINE + 'in',
SPIECE_UNDERLINE + '',
'<unk>',
'2',
'0',
'0',
'0',
',',
SPIECE_UNDERLINE + 'and',
SPIECE_UNDERLINE + 'this',
SPIECE_UNDERLINE + 'is',
SPIECE_UNDERLINE + 'f',
'al',
's',
'<unk>',
'.',
] , )
def __UpperCAmelCase ( self :Optional[int] ):
lowercase = XLNetTokenizer(lowercase__ , do_lower_case=lowercase__ )
lowercase = tokenizer.tokenize('I was born in 92000, and this is falsé.' )
self.assertListEqual(
lowercase__ , [
SPIECE_UNDERLINE + '',
'i',
SPIECE_UNDERLINE + 'was',
SPIECE_UNDERLINE + 'b',
'or',
'n',
SPIECE_UNDERLINE + 'in',
SPIECE_UNDERLINE + '',
'9',
'2',
'0',
'0',
'0',
',',
SPIECE_UNDERLINE + 'and',
SPIECE_UNDERLINE + 'this',
SPIECE_UNDERLINE + 'is',
SPIECE_UNDERLINE + 'f',
'al',
'se',
'.',
] , )
self.assertListEqual(tokenizer.tokenize('H\u00E9llo' ) , ['▁he', 'll', 'o'] )
def __UpperCAmelCase ( self :Dict ):
lowercase = XLNetTokenizer(lowercase__ , do_lower_case=lowercase__ )
lowercase = tokenizer.tokenize('I was born in 92000, and this is falsé.' )
self.assertListEqual(
lowercase__ , [
SPIECE_UNDERLINE + 'I',
SPIECE_UNDERLINE + 'was',
SPIECE_UNDERLINE + 'b',
'or',
'n',
SPIECE_UNDERLINE + 'in',
SPIECE_UNDERLINE + '',
'9',
'2',
'0',
'0',
'0',
',',
SPIECE_UNDERLINE + 'and',
SPIECE_UNDERLINE + 'this',
SPIECE_UNDERLINE + 'is',
SPIECE_UNDERLINE + 'f',
'al',
'se',
'.',
] , )
@slow
def __UpperCAmelCase ( self :Optional[int] ):
lowercase = XLNetTokenizer.from_pretrained('xlnet-base-cased' )
lowercase = tokenizer.encode('sequence builders' , add_special_tokens=lowercase__ )
lowercase = tokenizer.encode('multi-sequence build' , add_special_tokens=lowercase__ )
lowercase = tokenizer.build_inputs_with_special_tokens(lowercase__ )
lowercase = tokenizer.build_inputs_with_special_tokens(lowercase__ , lowercase__ )
assert encoded_sentence == text + [4, 3]
assert encoded_pair == text + [4] + text_a + [4, 3]
@slow
def __UpperCAmelCase ( self :Dict ):
# fmt: off
lowercase = {'input_ids': [[17, 2_1442, 270, 17, 10, 1_4645, 318, 34, 17, 4546, 3145, 787, 13, 7752, 2_2018, 23, 21, 17, 4546, 3145, 787, 13, 3352, 1_4431, 13, 5500, 11, 1176, 580, 13, 1_6819, 4797, 23, 17, 10, 1_7135, 658, 19, 457, 7932, 13, 184, 19, 3154, 1_7135, 6468, 19, 1404, 1_2269, 19, 4229, 5356, 1_6264, 46, 19, 17, 2_0545, 1_0395, 9, 9, 9, 11, 28, 6421, 9531, 2_0729, 17, 10, 353, 1_7022, 11, 21, 6421, 9531, 1_6949, 17, 10, 1_1509, 753, 11, 33, 95, 2421, 7385, 956, 1_4431, 2626, 25, 842, 7385, 4836, 21, 1429, 2272, 9855, 3120, 161, 2_4738, 19, 1_3203, 658, 218, 787, 21, 430, 1_8482, 847, 2637, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 322, 2_2178, 27, 1064, 22, 956, 13, 1_1101, 1429, 5854, 2_4313, 1_8953, 40, 422, 2_4366, 68, 1758, 37, 1_0483, 1_4257, 31, 207, 263, 21, 203, 3773, 25, 71, 9735, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 2049, 3442, 17, 1_3894, 3380, 23, 95, 18, 1_7634, 2288, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowercase__ , model_name='xlnet-base-cased' , revision='c841166438c31ec7ca9a106dee7bb312b73ae511' , )
| 314
| 1
|
'''simple docstring'''
import unittest
from datasets import load_dataset
from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow
@is_pipeline_test
@require_torch
class SCREAMING_SNAKE_CASE (unittest.TestCase ):
@require_torch
def SCREAMING_SNAKE_CASE ( self):
'''simple docstring'''
__A : List[str] = pipeline(
task='zero-shot-audio-classification' , model='hf-internal-testing/tiny-clap-htsat-unfused')
__A : str = load_dataset('ashraq/esc50')
__A : str = dataset['train']['audio'][-1]['array']
__A : Union[str, Any] = audio_classifier(_UpperCAmelCase , candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner'])
self.assertEqual(
nested_simplify(_UpperCAmelCase) , [{'score': 0.501, 'label': 'Sound of a dog'}, {'score': 0.499, 'label': 'Sound of vaccum cleaner'}] , )
@unittest.skip('No models are available in TF')
def SCREAMING_SNAKE_CASE ( self):
'''simple docstring'''
pass
@slow
@require_torch
def SCREAMING_SNAKE_CASE ( self):
'''simple docstring'''
__A : List[str] = pipeline(
task='zero-shot-audio-classification' , model='laion/clap-htsat-unfused' , )
# This is an audio of a dog
__A : Any = load_dataset('ashraq/esc50')
__A : Dict = dataset['train']['audio'][-1]['array']
__A : Tuple = audio_classifier(_UpperCAmelCase , candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner'])
self.assertEqual(
nested_simplify(_UpperCAmelCase) , [
{'score': 0.999, 'label': 'Sound of a dog'},
{'score': 0.001, 'label': 'Sound of vaccum cleaner'},
] , )
__A : Tuple = audio_classifier([audio] * 5 , candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner'])
self.assertEqual(
nested_simplify(_UpperCAmelCase) , [
[
{'score': 0.999, 'label': 'Sound of a dog'},
{'score': 0.001, 'label': 'Sound of vaccum cleaner'},
],
]
* 5 , )
__A : List[str] = audio_classifier(
[audio] * 5 , candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner'] , batch_size=5)
self.assertEqual(
nested_simplify(_UpperCAmelCase) , [
[
{'score': 0.999, 'label': 'Sound of a dog'},
{'score': 0.001, 'label': 'Sound of vaccum cleaner'},
],
]
* 5 , )
@unittest.skip('No models are available in TF')
def SCREAMING_SNAKE_CASE ( self):
'''simple docstring'''
pass
| 8
|
from dataclasses import dataclass
from typing import List, Optional, Union
import numpy as np
import PIL
from PIL import Image
from ...utils import (
BaseOutput,
OptionalDependencyNotAvailable,
is_flax_available,
is_k_diffusion_available,
is_k_diffusion_version,
is_onnx_available,
is_torch_available,
is_transformers_available,
is_transformers_version,
)
@dataclass
class __lowerCamelCase ( UpperCamelCase__ ):
"""simple docstring"""
snake_case__ = 42
snake_case__ = 42
try:
if not (is_transformers_available() and is_torch_available()):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import * # noqa F403
else:
from .pipeline_cycle_diffusion import CycleDiffusionPipeline
from .pipeline_stable_diffusion import StableDiffusionPipeline
from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
from .pipeline_stable_unclip import StableUnCLIPPipeline
from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
from .safety_checker import StableDiffusionSafetyChecker
from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
try:
if not (is_transformers_available() and is_torch_available() and is_transformers_version('>=', '4.25.0')):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline
try:
if not (is_transformers_available() and is_torch_available() and is_transformers_version('>=', '4.26.0')):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import (
StableDiffusionDepthaImgPipeline,
StableDiffusionDiffEditPipeline,
StableDiffusionPixaPixZeroPipeline,
)
else:
from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline
try:
if not (
is_torch_available()
and is_transformers_available()
and is_k_diffusion_available()
and is_k_diffusion_version('>=', '0.0.12')
):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403
else:
from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline
try:
if not (is_transformers_available() and is_onnx_available()):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_onnx_objects import * # noqa F403
else:
from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline
if is_transformers_available() and is_flax_available():
import flax
@flax.struct.dataclass
class __lowerCamelCase ( UpperCamelCase__ ):
"""simple docstring"""
snake_case__ = 42
snake_case__ = 42
from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
from .safety_checker_flax import FlaxStableDiffusionSafetyChecker
| 61
| 0
|
import json
import os
import unittest
from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers
from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class a ( __lowerCamelCase , unittest.TestCase ):
__lowerCAmelCase : List[str] = MgpstrTokenizer
__lowerCAmelCase : int = False
__lowerCAmelCase : List[str] = {}
__lowerCAmelCase : Any = False
def __lowerCamelCase ( self :Optional[Any] ):
super().setUp()
# fmt: off
snake_case__ : Optional[Any] = ['''[GO]''', '''[s]''', '''0''', '''1''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''', '''a''', '''b''', '''c''', '''d''', '''e''', '''f''', '''g''', '''h''', '''i''', '''j''', '''k''', '''l''', '''m''', '''n''', '''o''', '''p''', '''q''', '''r''', '''s''', '''t''', '''u''', '''v''', '''w''', '''x''', '''y''', '''z''']
# fmt: on
snake_case__ : Optional[int] = dict(zip(__lowercase ,range(len(__lowercase ) ) ) )
snake_case__ : Tuple = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES['''vocab_file'''] )
with open(self.vocab_file ,'''w''' ,encoding='''utf-8''' ) as fp:
fp.write(json.dumps(__lowercase ) + '''\n''' )
def __lowerCamelCase ( self :Any ,**__lowercase :Optional[int] ):
return MgpstrTokenizer.from_pretrained(self.tmpdirname ,**__lowercase )
def __lowerCamelCase ( self :Optional[Any] ,__lowercase :Union[str, Any] ):
snake_case__ : List[str] = '''tester'''
snake_case__ : Dict = '''tester'''
return input_text, output_text
@unittest.skip('''MGP-STR always lower cases letters.''' )
def __lowerCamelCase ( self :Dict ):
pass
def __lowerCamelCase ( self :List[Any] ):
snake_case__ : Optional[Any] = self.get_tokenizers(do_lower_case=__lowercase )
for tokenizer in tokenizers:
with self.subTest(F"""{tokenizer.__class__.__name__}""" ):
snake_case__ : Tuple = '''[SPECIAL_TOKEN]'''
tokenizer.add_special_tokens({'''cls_token''': special_token} )
snake_case__ : str = tokenizer.encode([special_token] ,add_special_tokens=__lowercase )
self.assertEqual(len(__lowercase ) ,1 )
snake_case__ : Tuple = tokenizer.decode(__lowercase ,skip_special_tokens=__lowercase )
self.assertTrue(special_token not in decoded )
def __lowerCamelCase ( self :Any ):
snake_case__ : Optional[int] = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(F"""{tokenizer.__class__.__name__}""" ):
snake_case__ , snake_case__ : Dict = self.get_input_output_texts(__lowercase )
snake_case__ : Optional[int] = tokenizer.tokenize(__lowercase )
snake_case__ : str = tokenizer.convert_tokens_to_ids(__lowercase )
snake_case__ : Dict = tokenizer.encode(__lowercase ,add_special_tokens=__lowercase )
self.assertListEqual(__lowercase ,__lowercase )
snake_case__ : int = tokenizer.convert_ids_to_tokens(__lowercase )
self.assertNotEqual(len(__lowercase ) ,0 )
snake_case__ : Any = tokenizer.decode(__lowercase )
self.assertIsInstance(__lowercase ,__lowercase )
self.assertEqual(text_a.replace(''' ''' ,'''''' ) ,__lowercase )
@unittest.skip('''MGP-STR tokenizer only handles one sequence.''' )
def __lowerCamelCase ( self :Optional[int] ):
pass
@unittest.skip('''inputs cannot be pretokenized in MgpstrTokenizer''' )
def __lowerCamelCase ( self :Union[str, Any] ):
pass
| 219
|
import copy
import fnmatch
import json
import os
import pickle as pkl
import shutil
import sys
import tarfile
import tempfile
from collections import OrderedDict
from contextlib import contextmanager
from functools import partial
from hashlib import shaaaa
from io import BytesIO
from pathlib import Path
from urllib.parse import urlparse
from zipfile import ZipFile, is_zipfile
import cva
import numpy as np
import requests
import wget
from filelock import FileLock
from PIL import Image
from tqdm.auto import tqdm
from yaml import Loader, dump, load
try:
import torch
A__ = True
except ImportError:
A__ = False
try:
from torch.hub import _get_torch_home
A__ = _get_torch_home()
except ImportError:
A__ = os.path.expanduser(
os.getenv('''TORCH_HOME''', os.path.join(os.getenv('''XDG_CACHE_HOME''', '''~/.cache'''), '''torch'''))
)
A__ = os.path.join(torch_cache_home, '''transformers''')
A__ = '''https://cdn.huggingface.co'''
A__ = '''https://s3.amazonaws.com/models.huggingface.co/bert'''
A__ = '''/'''.join(str(Path(__file__).resolve()).split('''/''')[:-1])
A__ = os.path.join(PATH, '''config.yaml''')
A__ = os.path.join(PATH, '''attributes.txt''')
A__ = os.path.join(PATH, '''objects.txt''')
A__ = os.getenv('''PYTORCH_PRETRAINED_BERT_CACHE''', default_cache_path)
A__ = os.getenv('''PYTORCH_TRANSFORMERS_CACHE''', PYTORCH_PRETRAINED_BERT_CACHE)
A__ = os.getenv('''TRANSFORMERS_CACHE''', PYTORCH_TRANSFORMERS_CACHE)
A__ = '''pytorch_model.bin'''
A__ = '''config.yaml'''
def _lowerCAmelCase ( __lowerCAmelCase=OBJECTS , __lowerCAmelCase=ATTRIBUTES ) -> List[str]:
"""simple docstring"""
snake_case__ : str = []
with open(__lowerCAmelCase ) as f:
for object in f.readlines():
vg_classes.append(object.split(''',''' )[0].lower().strip() )
snake_case__ : List[Any] = []
with open(__lowerCAmelCase ) as f:
for object in f.readlines():
vg_attrs.append(object.split(''',''' )[0].lower().strip() )
return vg_classes, vg_attrs
def _lowerCAmelCase ( __lowerCAmelCase ) -> int:
"""simple docstring"""
snake_case__ : int = OrderedDict()
with open(__lowerCAmelCase , '''rb''' ) as f:
snake_case__ : List[Any] = pkl.load(__lowerCAmelCase )['''model''']
for k in copy.deepcopy(list(ckp.keys() ) ):
snake_case__ : Union[str, Any] = ckp.pop(__lowerCAmelCase )
if isinstance(__lowerCAmelCase , np.ndarray ):
snake_case__ : List[Any] = torch.tensor(__lowerCAmelCase )
else:
assert isinstance(__lowerCAmelCase , torch.tensor ), type(__lowerCAmelCase )
snake_case__ : int = v
return r
class a :
__lowerCAmelCase : Dict = {}
def __init__( self :List[Any] ,__lowercase :dict ,__lowercase :str = "root" ,__lowercase :Tuple=0 ):
snake_case__ : Dict = name
snake_case__ : str = level
snake_case__ : Dict = {}
for k, v in dictionary.items():
if v is None:
raise ValueError()
snake_case__ : Any = copy.deepcopy(__lowercase )
snake_case__ : List[str] = copy.deepcopy(__lowercase )
if isinstance(__lowercase ,__lowercase ):
snake_case__ : Dict = Config(__lowercase ,name=__lowercase ,level=level + 1 )
snake_case__ : Optional[Any] = v
setattr(self ,__lowercase ,__lowercase )
snake_case__ : List[str] = d
def __repr__( self :Dict ):
return str(list((self._pointer.keys()) ) )
def __setattr__( self :int ,__lowercase :Tuple ,__lowercase :Dict ):
snake_case__ : int = val
snake_case__ : Optional[Any] = val
snake_case__ : str = key.split('''.''' )
snake_case__ : Any = len(__lowercase ) - 1
snake_case__ : Optional[int] = self._pointer
if len(__lowercase ) > 1:
for i, l in enumerate(__lowercase ):
if hasattr(self ,__lowercase ) and isinstance(getattr(self ,__lowercase ) ,__lowercase ):
setattr(getattr(self ,__lowercase ) ,'''.'''.join(levels[i:] ) ,__lowercase )
if l == last_level:
snake_case__ : Tuple = val
else:
snake_case__ : Any = pointer[l]
def __lowerCamelCase ( self :Union[str, Any] ):
return self._pointer
def __lowerCamelCase ( self :Optional[int] ,__lowercase :List[str] ,__lowercase :Any ):
with open(F"""{file_name}""" ,'''w''' ) as stream:
dump(__lowercase ,__lowercase )
def __lowerCamelCase ( self :Optional[Any] ,__lowercase :Dict ,__lowercase :List[str] ):
with open(F"""{file_name}""" ,'''w''' ) as stream:
json.dump(__lowercase ,__lowercase )
@staticmethod
def __lowerCamelCase ( __lowercase :Union[str, Any] ):
with open(__lowercase ) as stream:
snake_case__ : Optional[Any] = load(__lowercase ,Loader=__lowercase )
return data
def __str__( self :Optional[Any] ):
snake_case__ : Dict = ''' '''
if self._name != "root":
snake_case__ : Optional[int] = F"""{t * (self._level-1)}{self._name}:\n"""
else:
snake_case__ : Tuple = ''''''
snake_case__ : List[Any] = self._level
for i, (k, v) in enumerate(self._pointer.items() ):
if isinstance(__lowercase ,__lowercase ):
r += F"""{t * (self._level)}{v}\n"""
self._level += 1
else:
r += F"""{t * (self._level)}{k}: {v} ({type(__lowercase ).__name__})\n"""
snake_case__ : Optional[int] = level
return r[:-1]
@classmethod
def __lowerCamelCase ( cls :Union[str, Any] ,__lowercase :str ,**__lowercase :str ):
snake_case__ , snake_case__ : Optional[Any] = cls.get_config_dict(__lowercase ,**__lowercase )
return cls(__lowercase )
@classmethod
def __lowerCamelCase ( cls :str ,__lowercase :str ,**__lowercase :List[str] ):
snake_case__ : Optional[Any] = kwargs.pop('''cache_dir''' ,__lowercase )
snake_case__ : Optional[int] = kwargs.pop('''force_download''' ,__lowercase )
snake_case__ : Optional[Any] = kwargs.pop('''resume_download''' ,__lowercase )
snake_case__ : Dict = kwargs.pop('''proxies''' ,__lowercase )
snake_case__ : Any = kwargs.pop('''local_files_only''' ,__lowercase )
if os.path.isdir(__lowercase ):
snake_case__ : Optional[Any] = os.path.join(__lowercase ,__lowercase )
elif os.path.isfile(__lowercase ) or is_remote_url(__lowercase ):
snake_case__ : Union[str, Any] = pretrained_model_name_or_path
else:
snake_case__ : Union[str, Any] = hf_bucket_url(__lowercase ,filename=__lowercase ,use_cdn=__lowercase )
try:
# Load from URL or cache if already cached
snake_case__ : str = cached_path(
__lowercase ,cache_dir=__lowercase ,force_download=__lowercase ,proxies=__lowercase ,resume_download=__lowercase ,local_files_only=__lowercase ,)
# Load config dict
if resolved_config_file is None:
raise EnvironmentError
snake_case__ : Union[str, Any] = Config.load_yaml(__lowercase )
except EnvironmentError:
snake_case__ : Optional[Any] = '''Can\'t load config for'''
raise EnvironmentError(__lowercase )
if resolved_config_file == config_file:
print('''loading configuration file from path''' )
else:
print('''loading configuration file cache''' )
return Config.load_yaml(__lowercase ), kwargs
def _lowerCAmelCase ( __lowerCAmelCase ) -> Optional[int]:
"""simple docstring"""
snake_case__ : int = torch.load('''dump.pt''' , map_location=in_tensor.device )
snake_case__ : Optional[int] = in_tensor.numpy()
snake_case__ : int = out_tensor.numpy()[0]
print(na.shape , na[0, 0, :5] )
print(na.shape , na[0, 0, :5] )
assert np.allclose(__lowerCAmelCase , __lowerCAmelCase , rtol=0.01 , atol=0.1 ), (
f"""{sum([1 for x in np.isclose(__lowerCAmelCase , __lowerCAmelCase , rtol=0.01 , atol=0.1 ).flatten() if x is False] )/len(na.flatten() )*100:.4f} %"""
" element-wise mismatch"
)
raise Exception('''tensors are all good''' )
# Hugging face functions below
def _lowerCAmelCase ( __lowerCAmelCase ) -> List[Any]:
"""simple docstring"""
snake_case__ : Optional[int] = urlparse(__lowerCAmelCase )
return parsed.scheme in ("http", "https")
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase=True ) -> str:
"""simple docstring"""
snake_case__ : List[str] = CLOUDFRONT_DISTRIB_PREFIX if use_cdn else S3_BUCKET_PREFIX
snake_case__ : Union[str, Any] = '''/''' not in model_id
if legacy_format:
return f"""{endpoint}/{model_id}-{filename}"""
else:
return f"""{endpoint}/{model_id}/{filename}"""
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase=None , __lowerCAmelCase=0 , __lowerCAmelCase=None , ) -> List[str]:
"""simple docstring"""
snake_case__ : Tuple = '''python/{}'''.format(sys.version.split()[0] )
if _torch_available:
ua += "; torch/{}".format(torch.__version__ )
if isinstance(__lowerCAmelCase , __lowerCAmelCase ):
ua += "; " + "; ".join('''{}/{}'''.format(__lowerCAmelCase , __lowerCAmelCase ) for k, v in user_agent.items() )
elif isinstance(__lowerCAmelCase , __lowerCAmelCase ):
ua += "; " + user_agent
snake_case__ : Optional[int] = {'''user-agent''': ua}
if resume_size > 0:
snake_case__ : Union[str, Any] = '''bytes=%d-''' % (resume_size,)
snake_case__ : Any = requests.get(__lowerCAmelCase , stream=__lowerCAmelCase , proxies=__lowerCAmelCase , headers=__lowerCAmelCase )
if response.status_code == 416: # Range not satisfiable
return
snake_case__ : Optional[Any] = response.headers.get('''Content-Length''' )
snake_case__ : Any = resume_size + int(__lowerCAmelCase ) if content_length is not None else None
snake_case__ : Any = tqdm(
unit='''B''' , unit_scale=__lowerCAmelCase , total=__lowerCAmelCase , initial=__lowerCAmelCase , desc='''Downloading''' , )
for chunk in response.iter_content(chunk_size=1024 ):
if chunk: # filter out keep-alive new chunks
progress.update(len(__lowerCAmelCase ) )
temp_file.write(__lowerCAmelCase )
progress.close()
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase=None , __lowerCAmelCase=False , __lowerCAmelCase=None , __lowerCAmelCase=10 , __lowerCAmelCase=False , __lowerCAmelCase=None , __lowerCAmelCase=False , ) -> Any:
"""simple docstring"""
if cache_dir is None:
snake_case__ : Tuple = TRANSFORMERS_CACHE
if isinstance(__lowerCAmelCase , __lowerCAmelCase ):
snake_case__ : Dict = str(__lowerCAmelCase )
os.makedirs(__lowerCAmelCase , exist_ok=__lowerCAmelCase )
snake_case__ : List[Any] = None
if not local_files_only:
try:
snake_case__ : Tuple = requests.head(__lowerCAmelCase , allow_redirects=__lowerCAmelCase , proxies=__lowerCAmelCase , timeout=__lowerCAmelCase )
if response.status_code == 200:
snake_case__ : Optional[int] = response.headers.get('''ETag''' )
except (EnvironmentError, requests.exceptions.Timeout):
# etag is already None
pass
snake_case__ : str = url_to_filename(__lowerCAmelCase , __lowerCAmelCase )
# get cache path to put the file
snake_case__ : Tuple = os.path.join(__lowerCAmelCase , __lowerCAmelCase )
# etag is None = we don't have a connection, or url doesn't exist, or is otherwise inaccessible.
# try to get the last downloaded one
if etag is None:
if os.path.exists(__lowerCAmelCase ):
return cache_path
else:
snake_case__ : int = [
file
for file in fnmatch.filter(os.listdir(__lowerCAmelCase ) , filename + '''.*''' )
if not file.endswith('''.json''' ) and not file.endswith('''.lock''' )
]
if len(__lowerCAmelCase ) > 0:
return os.path.join(__lowerCAmelCase , matching_files[-1] )
else:
# If files cannot be found and local_files_only=True,
# the models might've been found if local_files_only=False
# Notify the user about that
if local_files_only:
raise ValueError(
'''Cannot find the requested files in the cached path and outgoing traffic has been'''
''' disabled. To enable model look-ups and downloads online, set \'local_files_only\''''
''' to False.''' )
return None
# From now on, etag is not None.
if os.path.exists(__lowerCAmelCase ) and not force_download:
return cache_path
# Prevent parallel downloads of the same file with a lock.
snake_case__ : Tuple = cache_path + '''.lock'''
with FileLock(__lowerCAmelCase ):
# If the download just completed while the lock was activated.
if os.path.exists(__lowerCAmelCase ) and not force_download:
# Even if returning early like here, the lock will be released.
return cache_path
if resume_download:
snake_case__ : List[str] = cache_path + '''.incomplete'''
@contextmanager
def _resumable_file_manager():
with open(__lowerCAmelCase , '''a+b''' ) as f:
yield f
snake_case__ : Any = _resumable_file_manager
if os.path.exists(__lowerCAmelCase ):
snake_case__ : str = os.stat(__lowerCAmelCase ).st_size
else:
snake_case__ : int = 0
else:
snake_case__ : Optional[Any] = partial(tempfile.NamedTemporaryFile , dir=__lowerCAmelCase , delete=__lowerCAmelCase )
snake_case__ : List[str] = 0
# Download to temporary file, then copy to cache dir once finished.
# Otherwise you get corrupt cache entries if the download gets interrupted.
with temp_file_manager() as temp_file:
print(
'''%s not found in cache or force_download set to True, downloading to %s''' , __lowerCAmelCase , temp_file.name , )
http_get(
__lowerCAmelCase , __lowerCAmelCase , proxies=__lowerCAmelCase , resume_size=__lowerCAmelCase , user_agent=__lowerCAmelCase , )
os.replace(temp_file.name , __lowerCAmelCase )
snake_case__ : Optional[Any] = {'''url''': url, '''etag''': etag}
snake_case__ : Tuple = cache_path + '''.json'''
with open(__lowerCAmelCase , '''w''' ) as meta_file:
json.dump(__lowerCAmelCase , __lowerCAmelCase )
return cache_path
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase=None ) -> Any:
"""simple docstring"""
snake_case__ : Dict = url.encode('''utf-8''' )
snake_case__ : Optional[int] = shaaaa(__lowerCAmelCase )
snake_case__ : int = url_hash.hexdigest()
if etag:
snake_case__ : Any = etag.encode('''utf-8''' )
snake_case__ : str = shaaaa(__lowerCAmelCase )
filename += "." + etag_hash.hexdigest()
if url.endswith('''.h5''' ):
filename += ".h5"
return filename
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase=None , __lowerCAmelCase=False , __lowerCAmelCase=None , __lowerCAmelCase=False , __lowerCAmelCase=None , __lowerCAmelCase=False , __lowerCAmelCase=False , __lowerCAmelCase=False , ) -> List[Any]:
"""simple docstring"""
if cache_dir is None:
snake_case__ : Optional[Any] = TRANSFORMERS_CACHE
if isinstance(__lowerCAmelCase , __lowerCAmelCase ):
snake_case__ : List[str] = str(__lowerCAmelCase )
if isinstance(__lowerCAmelCase , __lowerCAmelCase ):
snake_case__ : Union[str, Any] = str(__lowerCAmelCase )
if is_remote_url(__lowerCAmelCase ):
# URL, so get it from the cache (downloading if necessary)
snake_case__ : Dict = get_from_cache(
__lowerCAmelCase , cache_dir=__lowerCAmelCase , force_download=__lowerCAmelCase , proxies=__lowerCAmelCase , resume_download=__lowerCAmelCase , user_agent=__lowerCAmelCase , local_files_only=__lowerCAmelCase , )
elif os.path.exists(__lowerCAmelCase ):
# File, and it exists.
snake_case__ : Any = url_or_filename
elif urlparse(__lowerCAmelCase ).scheme == "":
# File, but it doesn't exist.
raise EnvironmentError('''file {} not found'''.format(__lowerCAmelCase ) )
else:
# Something unknown
raise ValueError('''unable to parse {} as a URL or as a local path'''.format(__lowerCAmelCase ) )
if extract_compressed_file:
if not is_zipfile(__lowerCAmelCase ) and not tarfile.is_tarfile(__lowerCAmelCase ):
return output_path
# Path where we extract compressed archives
# We avoid '.' in dir name and add "-extracted" at the end: "./model.zip" => "./model-zip-extracted/"
snake_case__ , snake_case__ : List[Any] = os.path.split(__lowerCAmelCase )
snake_case__ : Optional[Any] = output_file.replace('''.''' , '''-''' ) + '''-extracted'''
snake_case__ : List[Any] = os.path.join(__lowerCAmelCase , __lowerCAmelCase )
if os.path.isdir(__lowerCAmelCase ) and os.listdir(__lowerCAmelCase ) and not force_extract:
return output_path_extracted
# Prevent parallel extractions
snake_case__ : Tuple = output_path + '''.lock'''
with FileLock(__lowerCAmelCase ):
shutil.rmtree(__lowerCAmelCase , ignore_errors=__lowerCAmelCase )
os.makedirs(__lowerCAmelCase )
if is_zipfile(__lowerCAmelCase ):
with ZipFile(__lowerCAmelCase , '''r''' ) as zip_file:
zip_file.extractall(__lowerCAmelCase )
zip_file.close()
elif tarfile.is_tarfile(__lowerCAmelCase ):
snake_case__ : Union[str, Any] = tarfile.open(__lowerCAmelCase )
tar_file.extractall(__lowerCAmelCase )
tar_file.close()
else:
raise EnvironmentError('''Archive format of {} could not be identified'''.format(__lowerCAmelCase ) )
return output_path_extracted
return output_path
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase="," ) -> Optional[int]:
"""simple docstring"""
assert isinstance(__lowerCAmelCase , __lowerCAmelCase )
if os.path.isfile(__lowerCAmelCase ):
with open(__lowerCAmelCase ) as f:
snake_case__ : List[str] = eval(f.read() )
else:
snake_case__ : Optional[Any] = requests.get(__lowerCAmelCase )
try:
snake_case__ : Tuple = requests.json()
except Exception:
snake_case__ : Optional[int] = req.content.decode()
assert data is not None, "could not connect"
try:
snake_case__ : int = eval(__lowerCAmelCase )
except Exception:
snake_case__ : Optional[Any] = data.split('''\n''' )
req.close()
return data
def _lowerCAmelCase ( __lowerCAmelCase ) -> Union[str, Any]:
"""simple docstring"""
snake_case__ : Dict = requests.get(__lowerCAmelCase )
snake_case__ : Tuple = np.array(Image.open(BytesIO(response.content ) ) )
return img
def _lowerCAmelCase ( __lowerCAmelCase ) -> List[str]:
"""simple docstring"""
snake_case__ : Dict = url.split('''/''' )[-1]
if fn not in os.listdir(os.getcwd() ):
wget.download(__lowerCAmelCase )
with open(__lowerCAmelCase , '''rb''' ) as stream:
snake_case__ : List[str] = pkl.load(__lowerCAmelCase )
snake_case__ : Optional[Any] = weights.pop('''model''' )
snake_case__ : List[str] = {}
for k, v in model.items():
snake_case__ : Optional[int] = torch.from_numpy(__lowerCAmelCase )
if "running_var" in k:
snake_case__ : Tuple = torch.tensor([0] )
snake_case__ : Optional[Any] = k.replace('''running_var''' , '''num_batches_tracked''' )
snake_case__ : Dict = zero
return new
def _lowerCAmelCase ( ) -> Tuple:
"""simple docstring"""
print(f"""{os.path.abspath(os.path.join(__lowerCAmelCase , os.pardir ) )}/demo.ipynb""" )
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase="RGB" ) -> Dict:
"""simple docstring"""
assert isinstance(__lowerCAmelCase , __lowerCAmelCase )
if os.path.isfile(__lowerCAmelCase ):
snake_case__ : int = cva.imread(__lowerCAmelCase )
else:
snake_case__ : List[Any] = get_image_from_url(__lowerCAmelCase )
assert img is not None, f"""could not connect to: {im}"""
snake_case__ : str = cva.cvtColor(__lowerCAmelCase , cva.COLOR_BGR2RGB )
if input_format == "RGB":
snake_case__ : Any = img[:, :, ::-1]
return img
def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase=1 ) -> str:
"""simple docstring"""
return (images[i : i + batch] for i in range(0 , len(__lowerCAmelCase ) , __lowerCAmelCase ))
| 219
| 1
|
import argparse
from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection
from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline
if __name__ == "__main__":
SCREAMING_SNAKE_CASE :List[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.',
)
SCREAMING_SNAKE_CASE :List[Any] = parser.parse_args()
SCREAMING_SNAKE_CASE :Dict = UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)
SCREAMING_SNAKE_CASE :Optional[int] = CLIPImageProcessor()
SCREAMING_SNAKE_CASE :int = CLIPVisionModelWithProjection.from_pretrained('openai/clip-vit-large-patch14')
SCREAMING_SNAKE_CASE :str = 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)
| 55
|
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
a_ = {
'configuration_instructblip': [
'INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
'InstructBlipConfig',
'InstructBlipQFormerConfig',
'InstructBlipVisionConfig',
],
'processing_instructblip': ['InstructBlipProcessor'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
a_ = [
'INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
'InstructBlipQFormerModel',
'InstructBlipPreTrainedModel',
'InstructBlipForConditionalGeneration',
'InstructBlipVisionModel',
]
if TYPE_CHECKING:
from .configuration_instructblip import (
INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
InstructBlipConfig,
InstructBlipQFormerConfig,
InstructBlipVisionConfig,
)
from .processing_instructblip import InstructBlipProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_instructblip import (
INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
InstructBlipForConditionalGeneration,
InstructBlipPreTrainedModel,
InstructBlipQFormerModel,
InstructBlipVisionModel,
)
else:
import sys
a_ = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 25
| 0
|
from typing import Dict, List, Optional, Tuple, Union
import torch
from ...models import AutoencoderKL, TransformeraDModel
from ...schedulers import KarrasDiffusionSchedulers
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
class __snake_case ( SCREAMING_SNAKE_CASE__ ):
'''simple docstring'''
def __init__( self : List[str] , _UpperCamelCase : Dict , _UpperCamelCase : Optional[Any] , _UpperCamelCase : Optional[Any] , _UpperCamelCase : List[Any] = None , ) ->Optional[Any]:
"""simple docstring"""
super().__init__()
self.register_modules(transformer=snake_case__ , vae=snake_case__ , scheduler=snake_case__)
# create a imagenet -> id dictionary for easier use
_lowerCamelCase : Union[str, Any] = {}
if idalabel is not None:
for key, value in idalabel.items():
for label in value.split(""","""):
_lowerCamelCase : Optional[int] = int(snake_case__)
_lowerCamelCase : Optional[Any] = dict(sorted(self.labels.items()))
def _SCREAMING_SNAKE_CASE ( self : Optional[int] , _UpperCamelCase : Optional[Any]) ->Optional[Any]:
"""simple docstring"""
if not isinstance(snake_case__ , snake_case__):
_lowerCamelCase : int = list(snake_case__)
for l in label:
if l not in self.labels:
raise ValueError(
F"""{l} does not exist. Please make sure to select one of the following labels: \n {self.labels}.""")
return [self.labels[l] for l in label]
@torch.no_grad()
def __call__( self : Optional[int] , _UpperCamelCase : Optional[int] , _UpperCamelCase : Tuple = 4.0 , _UpperCamelCase : int = None , _UpperCamelCase : List[str] = 50 , _UpperCamelCase : Any = "pil" , _UpperCamelCase : Dict = True , ) ->Union[str, Any]:
"""simple docstring"""
_lowerCamelCase : Optional[Any] = len(snake_case__)
_lowerCamelCase : Any = self.transformer.config.sample_size
_lowerCamelCase : List[Any] = self.transformer.config.in_channels
_lowerCamelCase : List[Any] = randn_tensor(
shape=(batch_size, latent_channels, latent_size, latent_size) , generator=snake_case__ , device=self.device , dtype=self.transformer.dtype , )
_lowerCamelCase : str = torch.cat([latents] * 2) if guidance_scale > 1 else latents
_lowerCamelCase : List[str] = torch.tensor(snake_case__ , device=self.device).reshape(-1)
_lowerCamelCase : Optional[Any] = torch.tensor([1000] * batch_size , device=self.device)
_lowerCamelCase : int = torch.cat([class_labels, class_null] , 0) if guidance_scale > 1 else class_labels
# set step values
self.scheduler.set_timesteps(snake_case__)
for t in self.progress_bar(self.scheduler.timesteps):
if guidance_scale > 1:
_lowerCamelCase : Optional[Any] = latent_model_input[: len(snake_case__) // 2]
_lowerCamelCase : Tuple = torch.cat([half, half] , dim=0)
_lowerCamelCase : Optional[int] = self.scheduler.scale_model_input(snake_case__ , snake_case__)
_lowerCamelCase : Union[str, Any] = t
if not torch.is_tensor(snake_case__):
# TODO: this requires sync between CPU and GPU. So try to pass timesteps as tensors if you can
# This would be a good case for the `match` statement (Python 3.10+)
_lowerCamelCase : Any = latent_model_input.device.type == "mps"
if isinstance(snake_case__ , snake_case__):
_lowerCamelCase : Tuple = torch.floataa if is_mps else torch.floataa
else:
_lowerCamelCase : Tuple = torch.intaa if is_mps else torch.intaa
_lowerCamelCase : List[Any] = torch.tensor([timesteps] , dtype=snake_case__ , device=latent_model_input.device)
elif len(timesteps.shape) == 0:
_lowerCamelCase : Dict = timesteps[None].to(latent_model_input.device)
# broadcast to batch dimension in a way that's compatible with ONNX/Core ML
_lowerCamelCase : Optional[int] = timesteps.expand(latent_model_input.shape[0])
# predict noise model_output
_lowerCamelCase : Optional[Any] = self.transformer(
snake_case__ , timestep=snake_case__ , class_labels=snake_case__).sample
# perform guidance
if guidance_scale > 1:
_lowerCamelCase : Optional[int] = noise_pred[:, :latent_channels], noise_pred[:, latent_channels:]
_lowerCamelCase : Dict = torch.split(snake_case__ , len(snake_case__) // 2 , dim=0)
_lowerCamelCase : Optional[Any] = uncond_eps + guidance_scale * (cond_eps - uncond_eps)
_lowerCamelCase : Tuple = torch.cat([half_eps, half_eps] , dim=0)
_lowerCamelCase : Optional[int] = torch.cat([eps, rest] , dim=1)
# learned sigma
if self.transformer.config.out_channels // 2 == latent_channels:
_lowerCamelCase : Dict = torch.split(snake_case__ , snake_case__ , dim=1)
else:
_lowerCamelCase : str = noise_pred
# compute previous image: x_t -> x_t-1
_lowerCamelCase : Any = self.scheduler.step(snake_case__ , snake_case__ , snake_case__).prev_sample
if guidance_scale > 1:
_lowerCamelCase : Any = latent_model_input.chunk(2 , dim=0)
else:
_lowerCamelCase : List[str] = latent_model_input
_lowerCamelCase : Any = 1 / self.vae.config.scaling_factor * latents
_lowerCamelCase : Dict = self.vae.decode(snake_case__).sample
_lowerCamelCase : Dict = (samples / 2 + 0.5).clamp(0 , 1)
# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
_lowerCamelCase : Tuple = samples.cpu().permute(0 , 2 , 3 , 1).float().numpy()
if output_type == "pil":
_lowerCamelCase : Tuple = self.numpy_to_pil(snake_case__)
if not return_dict:
return (samples,)
return ImagePipelineOutput(images=snake_case__)
| 718
|
import unittest
from transformers.utils.backbone_utils import (
BackboneMixin,
get_aligned_output_features_output_indices,
verify_out_features_out_indices,
)
class __snake_case ( unittest.TestCase ):
'''simple docstring'''
def _SCREAMING_SNAKE_CASE ( self : Union[str, Any]) ->Optional[Any]:
"""simple docstring"""
_lowerCamelCase : Tuple = ["""a""", """b""", """c"""]
# Defaults to last layer if both are None
_lowerCamelCase , _lowerCamelCase : int = get_aligned_output_features_output_indices(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase)
self.assertEqual(_UpperCamelCase , ["""c"""])
self.assertEqual(_UpperCamelCase , [2])
# Out indices set to match out features
_lowerCamelCase , _lowerCamelCase : int = get_aligned_output_features_output_indices(["""a""", """c"""] , _UpperCamelCase , _UpperCamelCase)
self.assertEqual(_UpperCamelCase , ["""a""", """c"""])
self.assertEqual(_UpperCamelCase , [0, 2])
# Out features set to match out indices
_lowerCamelCase , _lowerCamelCase : Tuple = get_aligned_output_features_output_indices(_UpperCamelCase , [0, 2] , _UpperCamelCase)
self.assertEqual(_UpperCamelCase , ["""a""", """c"""])
self.assertEqual(_UpperCamelCase , [0, 2])
# Out features selected from negative indices
_lowerCamelCase , _lowerCamelCase : str = get_aligned_output_features_output_indices(_UpperCamelCase , [-3, -1] , _UpperCamelCase)
self.assertEqual(_UpperCamelCase , ["""a""", """c"""])
self.assertEqual(_UpperCamelCase , [-3, -1])
def _SCREAMING_SNAKE_CASE ( self : int) ->int:
"""simple docstring"""
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(["""a""", """b"""] , (0, 1) , _UpperCamelCase)
# Out features must be a list
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(("""a""", """b""") , (0, 1) , ["""a""", """b"""])
# Out features must be a subset of stage names
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(["""a""", """b"""] , (0, 1) , ["""a"""])
# Out indices must be a list or tuple
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(_UpperCamelCase , 0 , ["""a""", """b"""])
# Out indices must be a subset of stage names
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(_UpperCamelCase , (0, 1) , ["""a"""])
# Out features and out indices must be the same length
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(["""a""", """b"""] , (0,) , ["""a""", """b""", """c"""])
# Out features should match out indices
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(["""a""", """b"""] , (0, 2) , ["""a""", """b""", """c"""])
# Out features and out indices should be in order
with self.assertRaises(_UpperCamelCase):
verify_out_features_out_indices(["""b""", """a"""] , (0, 1) , ["""a""", """b"""])
# Check passes with valid inputs
verify_out_features_out_indices(["""a""", """b""", """d"""] , (0, 1, -1) , ["""a""", """b""", """c""", """d"""])
def _SCREAMING_SNAKE_CASE ( self : int) ->List[Any]:
"""simple docstring"""
_lowerCamelCase : int = BackboneMixin()
_lowerCamelCase : Union[str, Any] = ["""a""", """b""", """c"""]
_lowerCamelCase : Tuple = ["""a""", """c"""]
_lowerCamelCase : List[Any] = [0, 2]
# Check that the output features and indices are set correctly
self.assertEqual(backbone.out_features , ["""a""", """c"""])
self.assertEqual(backbone.out_indices , [0, 2])
# Check out features and indices are updated correctly
_lowerCamelCase : str = ["""a""", """b"""]
self.assertEqual(backbone.out_features , ["""a""", """b"""])
self.assertEqual(backbone.out_indices , [0, 1])
_lowerCamelCase : Optional[int] = [-3, -1]
self.assertEqual(backbone.out_features , ["""a""", """c"""])
self.assertEqual(backbone.out_indices , [-3, -1])
| 15
| 0
|
import unittest
import numpy as np
import torch
from diffusers import KarrasVePipeline, KarrasVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device
enable_full_determinism()
class __magic_name__ ( unittest.TestCase ):
"""simple docstring"""
@property
def SCREAMING_SNAKE_CASE ( self :Union[str, Any] ):
'''simple docstring'''
torch.manual_seed(0 )
A_ : Optional[Any] = UNetaDModel(
block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("DownBlock2D", "AttnDownBlock2D") , up_block_types=("AttnUpBlock2D", "UpBlock2D") , )
return model
def SCREAMING_SNAKE_CASE ( self :int ):
'''simple docstring'''
A_ : int = self.dummy_uncond_unet
A_ : Union[str, Any] = KarrasVeScheduler()
A_ : Tuple = KarrasVePipeline(unet=snake_case , scheduler=snake_case )
pipe.to(snake_case )
pipe.set_progress_bar_config(disable=snake_case )
A_ : Dict = torch.manual_seed(0 )
A_ : Union[str, Any] = pipe(num_inference_steps=2 , generator=snake_case , output_type="numpy" ).images
A_ : Optional[Any] = torch.manual_seed(0 )
A_ : List[Any] = pipe(num_inference_steps=2 , generator=snake_case , output_type="numpy" , return_dict=snake_case )[0]
A_ : str = image[0, -3:, -3:, -1]
A_ : Dict = image_from_tuple[0, -3:, -3:, -1]
assert image.shape == (1, 32, 32, 3)
A_ : Optional[Any] = np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2
@slow
@require_torch
class __magic_name__ ( unittest.TestCase ):
"""simple docstring"""
def SCREAMING_SNAKE_CASE ( self :Dict ):
'''simple docstring'''
A_ : Tuple = "google/ncsnpp-celebahq-256"
A_ : List[Any] = UNetaDModel.from_pretrained(snake_case )
A_ : Tuple = KarrasVeScheduler()
A_ : List[Any] = KarrasVePipeline(unet=snake_case , scheduler=snake_case )
pipe.to(snake_case )
pipe.set_progress_bar_config(disable=snake_case )
A_ : Tuple = torch.manual_seed(0 )
A_ : Optional[int] = pipe(num_inference_steps=20 , generator=snake_case , output_type="numpy" ).images
A_ : Any = image[0, -3:, -3:, -1]
assert image.shape == (1, 256, 256, 3)
A_ : str = np.array([0.578, 0.5811, 0.5924, 0.5809, 0.587, 0.5886, 0.5861, 0.5802, 0.586] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 454
|
import json
from typing import List, Optional, Tuple
from tokenizers import pre_tokenizers, processors
from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bart import BartTokenizer
_lowerCAmelCase : Optional[Any] = logging.get_logger(__name__)
_lowerCAmelCase : List[str] = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}
# See all BART models at https://huggingface.co/models?filter=bart
_lowerCAmelCase : int = {
'''vocab_file''': {
'''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/vocab.json''',
'''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/vocab.json''',
'''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json''',
'''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json''',
'''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json''',
'''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json''',
},
'''merges_file''': {
'''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/merges.txt''',
'''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/merges.txt''',
'''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt''',
'''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt''',
'''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt''',
'''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt''',
},
'''tokenizer_file''': {
'''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/tokenizer.json''',
'''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/tokenizer.json''',
'''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/tokenizer.json''',
'''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/tokenizer.json''',
'''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/tokenizer.json''',
'''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/tokenizer.json''',
},
}
_lowerCAmelCase : Optional[int] = {
'''facebook/bart-base''': 1_024,
'''facebook/bart-large''': 1_024,
'''facebook/bart-large-mnli''': 1_024,
'''facebook/bart-large-cnn''': 1_024,
'''facebook/bart-large-xsum''': 1_024,
'''yjernite/bart_eli5''': 1_024,
}
class __magic_name__ ( lowerCamelCase__ ):
"""simple docstring"""
__UpperCamelCase = VOCAB_FILES_NAMES
__UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP
__UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
__UpperCamelCase = ['''input_ids''', '''attention_mask''']
__UpperCamelCase = BartTokenizer
def __init__( self :List[str] , snake_case :Tuple=None , snake_case :Union[str, Any]=None , snake_case :Union[str, Any]=None , snake_case :List[Any]="replace" , snake_case :List[str]="<s>" , snake_case :Optional[int]="</s>" , snake_case :Union[str, Any]="</s>" , snake_case :Optional[Any]="<s>" , snake_case :List[Any]="<unk>" , snake_case :Optional[Any]="<pad>" , snake_case :Dict="<mask>" , snake_case :int=False , snake_case :List[Any]=True , **snake_case :Union[str, Any] , ):
'''simple docstring'''
super().__init__(
snake_case , snake_case , tokenizer_file=snake_case , errors=snake_case , bos_token=snake_case , eos_token=snake_case , sep_token=snake_case , cls_token=snake_case , unk_token=snake_case , pad_token=snake_case , mask_token=snake_case , add_prefix_space=snake_case , trim_offsets=snake_case , **snake_case , )
A_ : Optional[Any] = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() )
if pre_tok_state.get("add_prefix_space" , snake_case ) != add_prefix_space:
A_ : Dict = getattr(snake_case , pre_tok_state.pop("type" ) )
A_ : List[str] = add_prefix_space
A_ : int = pre_tok_class(**snake_case )
A_ : Any = add_prefix_space
# the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
A_ : Tuple = "post_processor"
A_ : Union[str, Any] = getattr(self.backend_tokenizer , snake_case , snake_case )
if tokenizer_component_instance:
A_ : Any = json.loads(tokenizer_component_instance.__getstate__() )
# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
if "sep" in state:
A_ : List[Any] = tuple(state["sep"] )
if "cls" in state:
A_ : str = tuple(state["cls"] )
A_ : int = False
if state.get("add_prefix_space" , snake_case ) != add_prefix_space:
A_ : List[Any] = add_prefix_space
A_ : Union[str, Any] = True
if state.get("trim_offsets" , snake_case ) != trim_offsets:
A_ : int = trim_offsets
A_ : str = True
if changes_to_apply:
A_ : Tuple = getattr(snake_case , state.pop("type" ) )
A_ : Union[str, Any] = component_class(**snake_case )
setattr(self.backend_tokenizer , snake_case , snake_case )
@property
def SCREAMING_SNAKE_CASE ( self :List[Any] ):
'''simple docstring'''
if self._mask_token is None:
if self.verbose:
logger.error("Using mask_token, but it is not set yet." )
return None
return str(self._mask_token )
@mask_token.setter
def SCREAMING_SNAKE_CASE ( self :Tuple , snake_case :Dict ):
'''simple docstring'''
A_ : Optional[int] = AddedToken(snake_case , lstrip=snake_case , rstrip=snake_case ) if isinstance(snake_case , snake_case ) else value
A_ : List[Any] = value
def SCREAMING_SNAKE_CASE ( self :Tuple , *snake_case :str , **snake_case :str ):
'''simple docstring'''
A_ : Tuple = kwargs.get("is_split_into_words" , snake_case )
if is_split_into_words and not self.add_prefix_space:
raise ValueError(
f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
"to use it with pretokenized inputs." )
return super()._batch_encode_plus(*snake_case , **snake_case )
def SCREAMING_SNAKE_CASE ( self :Union[str, Any] , *snake_case :Any , **snake_case :Optional[Any] ):
'''simple docstring'''
A_ : List[Any] = kwargs.get("is_split_into_words" , snake_case )
if is_split_into_words and not self.add_prefix_space:
raise ValueError(
f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
"to use it with pretokenized inputs." )
return super()._encode_plus(*snake_case , **snake_case )
def SCREAMING_SNAKE_CASE ( self :int , snake_case :str , snake_case :Optional[str] = None ):
'''simple docstring'''
A_ : Any = self._tokenizer.model.save(snake_case , name=snake_case )
return tuple(snake_case )
def SCREAMING_SNAKE_CASE ( self :Dict , snake_case :List[str] , snake_case :Optional[int]=None ):
'''simple docstring'''
A_ : str = [self.bos_token_id] + token_ids_a + [self.eos_token_id]
if token_ids_a is None:
return output
return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]
def SCREAMING_SNAKE_CASE ( self :int , snake_case :List[int] , snake_case :Optional[List[int]] = None ):
'''simple docstring'''
A_ : Dict = [self.sep_token_id]
A_ : List[str] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
| 454
| 1
|
import warnings
from typing import List
from unittest.mock import Mock
import torch
from torch.utils.data import DataLoader, IterableDataset, TensorDataset
from accelerate.accelerator import Accelerator
from accelerate.utils.dataclasses import DistributedType
class _lowerCAmelCase ( A__ ):
"""simple docstring"""
def __init__( self : Tuple , __snake_case : List[Any] )-> Tuple:
snake_case = data
def __iter__( self : Union[str, Any] )-> str:
for element in self.data:
yield element
def __lowerCamelCase ( __lowerCAmelCase : Optional[Any]=True ) -> Dict:
snake_case = Accelerator(even_batches=_lowerCamelCase )
assert accelerator.num_processes == 2, "this script expects that two GPUs are available"
return accelerator
def __lowerCamelCase ( __lowerCAmelCase : Accelerator , __lowerCAmelCase : int , __lowerCAmelCase : int , __lowerCAmelCase : bool = False ) -> List[str]:
if iterable:
snake_case = DummyIterableDataset(torch.as_tensor(range(_lowerCamelCase ) ) )
else:
snake_case = TensorDataset(torch.as_tensor(range(_lowerCamelCase ) ) )
snake_case = DataLoader(_lowerCamelCase , batch_size=_lowerCamelCase )
snake_case = accelerator.prepare(_lowerCamelCase )
return dl
def __lowerCamelCase ( __lowerCAmelCase : Accelerator , __lowerCAmelCase : int , __lowerCAmelCase : int , __lowerCAmelCase : List[int] , __lowerCAmelCase : List[int] , ) -> Optional[Any]:
snake_case = create_dataloader(accelerator=_lowerCamelCase , dataset_size=_lowerCamelCase , batch_size=_lowerCamelCase )
snake_case = [len(batch[0] ) for batch in dl]
if accelerator.process_index == 0:
assert batch_sizes == process_0_expected_batch_sizes
elif accelerator.process_index == 1:
assert batch_sizes == process_1_expected_batch_sizes
def __lowerCamelCase ( ) -> Union[str, Any]:
snake_case = create_accelerator()
# without padding, we would expect a different number of batches
verify_dataloader_batch_sizes(
_lowerCamelCase , dataset_size=3 , batch_size=1 , process_0_expected_batch_sizes=[1, 1] , process_1_expected_batch_sizes=[1, 1] , )
# without padding, we would expect the same number of batches, but different sizes
verify_dataloader_batch_sizes(
_lowerCamelCase , dataset_size=7 , batch_size=2 , process_0_expected_batch_sizes=[2, 2] , process_1_expected_batch_sizes=[2, 2] , )
def __lowerCamelCase ( ) -> List[str]:
snake_case = create_accelerator(even_batches=_lowerCamelCase )
verify_dataloader_batch_sizes(
_lowerCamelCase , dataset_size=3 , batch_size=1 , process_0_expected_batch_sizes=[1, 1] , process_1_expected_batch_sizes=[1] , )
verify_dataloader_batch_sizes(
_lowerCamelCase , dataset_size=7 , batch_size=2 , process_0_expected_batch_sizes=[2, 2] , process_1_expected_batch_sizes=[2, 1] , )
def __lowerCamelCase ( ) -> List[Any]:
snake_case = create_accelerator(even_batches=_lowerCamelCase )
snake_case = torch.nn.Linear(1 , 1 )
snake_case = accelerator.prepare(_lowerCamelCase )
snake_case = create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 )
snake_case = []
with accelerator.join_uneven_inputs([ddp_model] ):
for batch_idx, batch in enumerate(_lowerCamelCase ):
snake_case = ddp_model(batch[0].float() )
snake_case = output.sum()
loss.backward()
batch_idxs.append(_lowerCamelCase )
accelerator.wait_for_everyone()
if accelerator.process_index == 0:
assert batch_idxs == [0, 1]
elif accelerator.process_index == 1:
assert batch_idxs == [0]
def __lowerCamelCase ( __lowerCAmelCase : int ) -> str:
with warnings.catch_warnings(record=_lowerCamelCase ) as w:
with accelerator.join_uneven_inputs([Mock()] ):
pass
assert issubclass(w[-1].category , _lowerCamelCase )
assert "only supported for multi-GPU" in str(w[-1].message )
def __lowerCamelCase ( ) -> str:
snake_case = True
snake_case = False
snake_case = create_accelerator(even_batches=_lowerCamelCase )
snake_case = torch.nn.Linear(1 , 1 )
snake_case = accelerator.prepare(_lowerCamelCase )
snake_case = create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 )
snake_case = create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 )
with accelerator.join_uneven_inputs([ddp_model] , even_batches=_lowerCamelCase ):
snake_case = train_dl.batch_sampler.even_batches
snake_case = valid_dl.batch_sampler.even_batches
assert train_dl_overridden_value == overridden_even_batches
assert valid_dl_overridden_value == overridden_even_batches
assert train_dl.batch_sampler.even_batches == default_even_batches
assert valid_dl.batch_sampler.even_batches == default_even_batches
def __lowerCamelCase ( ) -> Any:
snake_case = True
snake_case = False
snake_case = create_accelerator(even_batches=_lowerCamelCase )
snake_case = torch.nn.Linear(1 , 1 )
snake_case = accelerator.prepare(_lowerCamelCase )
create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 , iterable=_lowerCamelCase )
snake_case = create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 )
with warnings.catch_warnings():
warnings.filterwarnings("""ignore""" )
try:
with accelerator.join_uneven_inputs([ddp_model] , even_batches=_lowerCamelCase ):
snake_case = batch_dl.batch_sampler.even_batches
except AttributeError:
# ensure attribute error is not raised when processing iterable dl
raise AssertionError
assert batch_dl_overridden_value == overridden_even_batches
assert batch_dl.batch_sampler.even_batches == default_even_batches
def __lowerCamelCase ( ) -> Dict:
snake_case = create_accelerator()
snake_case = torch.nn.Linear(1 , 1 )
snake_case = accelerator.prepare(_lowerCamelCase )
create_dataloader(_lowerCamelCase , dataset_size=3 , batch_size=1 , iterable=_lowerCamelCase )
with warnings.catch_warnings(record=_lowerCamelCase ) as w:
with accelerator.join_uneven_inputs([ddp_model] , even_batches=_lowerCamelCase ):
pass
assert issubclass(w[-1].category , _lowerCamelCase )
assert "only supported for map-style datasets" in str(w[-1].message )
def __lowerCamelCase ( ) -> Union[str, Any]:
snake_case = create_accelerator()
accelerator.print("""Test that even_batches variable ensures uniform batches across processes""" )
test_default_ensures_even_batch_sizes()
accelerator.print("""Run tests with even_batches disabled""" )
test_can_disable_even_batches()
accelerator.print("""Test joining uneven inputs""" )
test_can_join_uneven_inputs()
accelerator.print("""Test overriding even_batches when joining uneven inputs""" )
test_join_can_override_even_batches()
accelerator.print("""Test overriding even_batches for mixed dataloader types""" )
test_join_can_override_for_mixed_type_dataloaders()
accelerator.print("""Test overriding even_batches raises a warning for iterable dataloaders""" )
test_join_raises_warning_for_iterable_when_overriding_even_batches()
accelerator.print("""Test join with non DDP distributed raises warning""" )
snake_case = accelerator.state.distributed_type
snake_case = DistributedType.FSDP
test_join_raises_warning_for_non_ddp_distributed(_lowerCamelCase )
snake_case = original_state
if __name__ == "__main__":
main()
| 700
|
'''simple docstring'''
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class _lowerCAmelCase ( ctypes.Structure ):
"""simple docstring"""
snake_case_ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def __lowerCamelCase ( ) -> Optional[int]:
if os.name == "nt":
snake_case = CursorInfo()
snake_case = ctypes.windll.kernelaa.GetStdHandle(-11 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(__lowerCAmelCase , ctypes.byref(__lowerCAmelCase ) )
snake_case = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(__lowerCAmelCase , ctypes.byref(__lowerCAmelCase ) )
elif os.name == "posix":
sys.stdout.write("""\033[?25l""" )
sys.stdout.flush()
def __lowerCamelCase ( ) -> Tuple:
if os.name == "nt":
snake_case = CursorInfo()
snake_case = ctypes.windll.kernelaa.GetStdHandle(-11 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(__lowerCAmelCase , ctypes.byref(__lowerCAmelCase ) )
snake_case = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(__lowerCAmelCase , ctypes.byref(__lowerCAmelCase ) )
elif os.name == "posix":
sys.stdout.write("""\033[?25h""" )
sys.stdout.flush()
@contextmanager
def __lowerCamelCase ( ) -> Optional[Any]:
try:
hide_cursor()
yield
finally:
show_cursor()
| 517
| 0
|
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_torch_available,
)
SCREAMING_SNAKE_CASE : str = {
"configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
SCREAMING_SNAKE_CASE : int = [
"GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST",
"GPTBigCodeForSequenceClassification",
"GPTBigCodeForTokenClassification",
"GPTBigCodeForCausalLM",
"GPTBigCodeModel",
"GPTBigCodePreTrainedModel",
]
if TYPE_CHECKING:
from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_gpt_bigcode import (
GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
GPTBigCodeForCausalLM,
GPTBigCodeForSequenceClassification,
GPTBigCodeForTokenClassification,
GPTBigCodeModel,
GPTBigCodePreTrainedModel,
)
else:
import sys
SCREAMING_SNAKE_CASE : List[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
| 89
|
'''simple docstring'''
import copy
from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings
lowerCAmelCase : Tuple = r"""
[`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and
can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.
Args:
title_sep (`str`, *optional*, defaults to `\" / \"`):
Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].
doc_sep (`str`, *optional*, defaults to `\" // \"`):
Separator inserted between the text of the retrieved document and the original input when calling
[`RagRetriever`].
n_docs (`int`, *optional*, defaults to 5):
Number of documents to retrieve.
max_combined_length (`int`, *optional*, defaults to 300):
Max length of contextualized input returned by [`~RagRetriever.__call__`].
retrieval_vector_size (`int`, *optional*, defaults to 768):
Dimensionality of the document embeddings indexed by [`RagRetriever`].
retrieval_batch_size (`int`, *optional*, defaults to 8):
Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated
[`RagRetriever`].
dataset (`str`, *optional*, defaults to `\"wiki_dpr\"`):
A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids
using `datasets.list_datasets()`).
dataset_split (`str`, *optional*, defaults to `\"train\"`)
Which split of the `dataset` to load.
index_name (`str`, *optional*, defaults to `\"compressed\"`)
The index name of the index associated with the `dataset`. One can choose between `\"legacy\"`, `\"exact\"` and
`\"compressed\"`.
index_path (`str`, *optional*)
The path to the serialized faiss index on disk.
passages_path (`str`, *optional*):
A path to text passages compatible with the faiss index. Required if using
[`~models.rag.retrieval_rag.LegacyIndex`]
use_dummy_dataset (`bool`, *optional*, defaults to `False`)
Whether to load a \"dummy\" variant of the dataset specified by `dataset`.
label_smoothing (`float`, *optional*, defaults to 0.0):
Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing
in the loss calculation. If set to 0, no label smoothing is performed.
do_marginalize (`bool`, *optional*, defaults to `False`):
If `True`, the logits are marginalized over all documents by making use of
`torch.nn.functional.log_softmax`.
reduce_loss (`bool`, *optional*, defaults to `False`):
Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.
do_deduplication (`bool`, *optional*, defaults to `True`):
Whether or not to deduplicate the generations from different context documents for a given input. Has to be
set to `False` if used while training with distributed backend.
exclude_bos_score (`bool`, *optional*, defaults to `False`):
Whether or not to disregard the BOS token when computing the loss.
output_retrieved(`bool`, *optional*, defaults to `False`):
If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and
`context_attention_mask` are returned. See returned tensors for more detail.
use_cache (`bool`, *optional*, defaults to `True`):
Whether or not the model should return the last key/values attentions (not used by all models).
forced_eos_token_id (`int`, *optional*):
The id of the token to force as the last generated token when `max_length` is reached. Usually set to
`eos_token_id`.
"""
@add_start_docstrings(SCREAMING_SNAKE_CASE_ )
class UpperCamelCase__ ( SCREAMING_SNAKE_CASE_ ):
"""simple docstring"""
__magic_name__ = "rag"
__magic_name__ = True
def __init__( self , snake_case__=None , snake_case__=True , snake_case__=None , snake_case__=None , snake_case__=None , snake_case__=None , snake_case__=None , snake_case__=" / " , snake_case__=" // " , snake_case__=5 , snake_case__=300 , snake_case__=768 , snake_case__=8 , snake_case__="wiki_dpr" , snake_case__="train" , snake_case__="compressed" , snake_case__=None , snake_case__=None , snake_case__=False , snake_case__=False , snake_case__=0.0 , snake_case__=True , snake_case__=False , snake_case__=False , snake_case__=False , snake_case__=True , snake_case__=None , **snake_case__ , ):
'''simple docstring'''
super().__init__(
bos_token_id=snake_case__ , pad_token_id=snake_case__ , eos_token_id=snake_case__ , decoder_start_token_id=snake_case__ , forced_eos_token_id=snake_case__ , is_encoder_decoder=snake_case__ , prefix=snake_case__ , vocab_size=snake_case__ , **snake_case__ , )
assert (
"question_encoder" in kwargs and "generator" in kwargs
), "Config has to be initialized with question_encoder and generator config"
_lowerCAmelCase : Optional[Any] = kwargs.pop('question_encoder' )
_lowerCAmelCase : List[Any] = question_encoder_config.pop('model_type' )
_lowerCAmelCase : List[str] = kwargs.pop('generator' )
_lowerCAmelCase : Tuple = decoder_config.pop('model_type' )
from ..auto.configuration_auto import AutoConfig
_lowerCAmelCase : Union[str, Any] = AutoConfig.for_model(snake_case__ , **snake_case__ )
_lowerCAmelCase : List[str] = AutoConfig.for_model(snake_case__ , **snake_case__ )
_lowerCAmelCase : Optional[int] = reduce_loss
_lowerCAmelCase : Optional[Any] = label_smoothing
_lowerCAmelCase : Dict = exclude_bos_score
_lowerCAmelCase : Optional[int] = do_marginalize
_lowerCAmelCase : List[str] = title_sep
_lowerCAmelCase : Optional[Any] = doc_sep
_lowerCAmelCase : str = n_docs
_lowerCAmelCase : Optional[int] = max_combined_length
_lowerCAmelCase : Dict = dataset
_lowerCAmelCase : Optional[int] = dataset_split
_lowerCAmelCase : str = index_name
_lowerCAmelCase : Tuple = retrieval_vector_size
_lowerCAmelCase : Any = retrieval_batch_size
_lowerCAmelCase : Any = passages_path
_lowerCAmelCase : Tuple = index_path
_lowerCAmelCase : Any = use_dummy_dataset
_lowerCAmelCase : Union[str, Any] = output_retrieved
_lowerCAmelCase : List[str] = do_deduplication
_lowerCAmelCase : Optional[int] = use_cache
if self.forced_eos_token_id is None:
_lowerCAmelCase : Tuple = getattr(self.generator , 'forced_eos_token_id' , snake_case__ )
@classmethod
def a ( cls , snake_case__ , snake_case__ , **snake_case__ ):
'''simple docstring'''
return cls(question_encoder=question_encoder_config.to_dict() , generator=generator_config.to_dict() , **snake_case__ )
def a ( self ):
'''simple docstring'''
_lowerCAmelCase : Union[str, Any] = copy.deepcopy(self.__dict__ )
_lowerCAmelCase : List[str] = self.question_encoder.to_dict()
_lowerCAmelCase : Optional[Any] = self.generator.to_dict()
_lowerCAmelCase : Optional[int] = self.__class__.model_type
return output
| 444
| 0
|
import qiskit
def SCREAMING_SNAKE_CASE ( lowercase_ , lowercase_ ) -> qiskit.result.counts.Counts:
"""simple docstring"""
A__ = qiskit.Aer.get_backend('''aer_simulator''' )
# Create a Quantum Circuit acting on the q register
A__ = qiskit.QuantumCircuit(lowercase_ , lowercase_ )
# Map the quantum measurement to the classical bits
circuit.measure([0] , [0] )
# Execute the circuit on the simulator
A__ = qiskit.execute(lowercase_ , lowercase_ , shots=1_000 )
# Return the histogram data of the results of the experiment.
return job.result().get_counts(lowercase_ )
if __name__ == "__main__":
print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')
| 707
|
import random
import unittest
import torch
from diffusers import IFInpaintingPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device
from ..pipeline_params import (
TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class UpperCamelCase_ ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ):
'''simple docstring'''
UpperCAmelCase__ = IFInpaintingPipeline
UpperCAmelCase__ = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''width''', '''height'''}
UpperCAmelCase__ = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
UpperCAmelCase__ = PipelineTesterMixin.required_optional_params - {'''latents'''}
def SCREAMING_SNAKE_CASE ( self : Any) ->Dict:
'''simple docstring'''
return self._get_dummy_components()
def SCREAMING_SNAKE_CASE ( self : int , UpperCAmelCase__ : Dict , UpperCAmelCase__ : int=0) ->int:
'''simple docstring'''
if str(UpperCAmelCase__).startswith('''mps'''):
A__ = torch.manual_seed(UpperCAmelCase__)
else:
A__ = torch.Generator(device=UpperCAmelCase__).manual_seed(UpperCAmelCase__)
A__ = floats_tensor((1, 3, 32, 32) , rng=random.Random(UpperCAmelCase__)).to(UpperCAmelCase__)
A__ = floats_tensor((1, 3, 32, 32) , rng=random.Random(UpperCAmelCase__)).to(UpperCAmelCase__)
A__ = {
'''prompt''': '''A painting of a squirrel eating a burger''',
'''image''': image,
'''mask_image''': mask_image,
'''generator''': generator,
'''num_inference_steps''': 2,
'''output_type''': '''numpy''',
}
return inputs
@unittest.skipIf(
torch_device != '''cuda''' or not is_xformers_available() , reason='''XFormers attention is only available with CUDA and `xformers` installed''' , )
def SCREAMING_SNAKE_CASE ( self : List[str]) ->List[Any]:
'''simple docstring'''
self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3)
def SCREAMING_SNAKE_CASE ( self : Dict) ->int:
'''simple docstring'''
self._test_save_load_optional_components()
@unittest.skipIf(torch_device != '''cuda''' , reason='''float16 requires CUDA''')
def SCREAMING_SNAKE_CASE ( self : Optional[Any]) ->List[str]:
'''simple docstring'''
super().test_save_load_floataa(expected_max_diff=1e-1)
def SCREAMING_SNAKE_CASE ( self : int) ->List[Any]:
'''simple docstring'''
self._test_attention_slicing_forward_pass(expected_max_diff=1e-2)
def SCREAMING_SNAKE_CASE ( self : Union[str, Any]) ->Any:
'''simple docstring'''
self._test_save_load_local()
def SCREAMING_SNAKE_CASE ( self : int) ->Union[str, Any]:
'''simple docstring'''
self._test_inference_batch_single_identical(
expected_max_diff=1e-2 , )
| 177
| 0
|
import os
from collections import namedtuple
import pytest
from datasets import ClassLabel, Features, Sequence, Value
from datasets.commands.test import TestCommand
from datasets.info import DatasetInfo, DatasetInfosDict
UpperCAmelCase : List[str] = namedtuple(
'''_TestCommandArgs''',
[
'''dataset''',
'''name''',
'''cache_dir''',
'''data_dir''',
'''all_configs''',
'''save_infos''',
'''ignore_verifications''',
'''force_redownload''',
'''clear_cache''',
],
defaults=[None, None, None, False, False, False, False, False],
)
def _SCREAMING_SNAKE_CASE ( a , a ) -> Any:
return (abs(source - target ) / target) < 0.01
@pytest.mark.integration
def _SCREAMING_SNAKE_CASE ( a ) -> Dict:
__A : str = _TestCommandArgs(dataset=a , all_configs=a , save_infos=a )
__A : int = TestCommand(*a )
test_command.run()
__A : List[str] = os.path.join(a , 'README.md' )
assert os.path.exists(a )
__A : Optional[Any] = DatasetInfosDict.from_directory(a )
__A : List[str] = DatasetInfosDict(
{
'default': DatasetInfo(
features=Features(
{
'tokens': Sequence(Value('string' ) ),
'ner_tags': Sequence(
ClassLabel(names=['O', 'B-PER', 'I-PER', 'B-ORG', 'I-ORG', 'B-LOC', 'I-LOC'] ) ),
'langs': Sequence(Value('string' ) ),
'spans': Sequence(Value('string' ) ),
} ) , splits=[
{
'name': 'train',
'num_bytes': 2_35_15_63,
'num_examples': 1_00_00,
},
{
'name': 'validation',
'num_bytes': 23_84_18,
'num_examples': 10_00,
},
] , download_size=3_94_06_80 , dataset_size=2_58_99_81 , )
} )
assert dataset_infos.keys() == expected_dataset_infos.keys()
for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
__A , __A : List[str] = getattr(dataset_infos['default'] , a ), getattr(expected_dataset_infos['default'] , a )
if key == "num_bytes":
assert is_apercent_close(a , a )
elif key == "splits":
assert list(a ) == list(a )
for split in result:
assert result[split].name == expected[split].name
assert result[split].num_examples == expected[split].num_examples
assert is_apercent_close(result[split].num_bytes , expected[split].num_bytes )
else:
result == expected
| 239
|
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 _SCREAMING_SNAKE_CASE ( a ) -> tuple:
return (data["data"], data["target"])
def _SCREAMING_SNAKE_CASE ( a , a ) -> XGBClassifier:
__A : List[Any] = XGBClassifier()
classifier.fit(a , a )
return classifier
def _SCREAMING_SNAKE_CASE ( ) -> None:
__A : Any = load_iris()
__A , __A : Optional[int] = data_handling(a )
__A , __A , __A , __A : List[Any] = train_test_split(
a , a , test_size=0.25 )
__A : Optional[Any] = iris['target_names']
# Create an XGBoost Classifier from the training data
__A : str = xgboost(a , a )
# Display the confusion matrix of the classifier with both training and test sets
ConfusionMatrixDisplay.from_estimator(
a , a , a , display_labels=a , cmap='Blues' , normalize='true' , )
plt.title('Normalized Confusion Matrix - IRIS Dataset' )
plt.show()
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
main()
| 239
| 1
|
'''simple docstring'''
def _A ( __snake_case :list , __snake_case :list , __snake_case :int ) -> list:
"""simple docstring"""
__SCREAMING_SNAKE_CASE = len(__snake_case )
__SCREAMING_SNAKE_CASE = [[0] * n for i in range(__snake_case )]
for i in range(__snake_case ):
__SCREAMING_SNAKE_CASE = y_points[i]
for i in range(2 , __snake_case ):
for j in range(__snake_case , __snake_case ):
__SCREAMING_SNAKE_CASE = (
(xa - x_points[j - i + 1]) * q[j][i - 1]
- (xa - x_points[j]) * q[j - 1][i - 1]
) / (x_points[j] - x_points[j - i + 1])
return [q[n - 1][n - 1], q]
if __name__ == "__main__":
import doctest
doctest.testmod()
| 713
|
import copy
from ...configuration_utils import PretrainedConfig
from ...utils import logging
_snake_case : Any = logging.get_logger(__name__)
class __SCREAMING_SNAKE_CASE ( __SCREAMING_SNAKE_CASE ):
SCREAMING_SNAKE_CASE__ ="""encoder-decoder"""
SCREAMING_SNAKE_CASE__ =True
def __init__( self, **_a ) -> Optional[Any]:
super().__init__(**_a )
assert (
"encoder" in kwargs and "decoder" in kwargs
), "Config has to be initialized with encoder and decoder config"
__SCREAMING_SNAKE_CASE = kwargs.pop("encoder" )
__SCREAMING_SNAKE_CASE = encoder_config.pop("model_type" )
__SCREAMING_SNAKE_CASE = kwargs.pop("decoder" )
__SCREAMING_SNAKE_CASE = decoder_config.pop("model_type" )
from ..auto.configuration_auto import AutoConfig
__SCREAMING_SNAKE_CASE = AutoConfig.for_model(_a, **_a )
__SCREAMING_SNAKE_CASE = AutoConfig.for_model(_a, **_a )
__SCREAMING_SNAKE_CASE = True
@classmethod
def __lowerCAmelCase ( cls, _a, _a, **_a ) -> PretrainedConfig:
logger.info("Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config" )
__SCREAMING_SNAKE_CASE = True
__SCREAMING_SNAKE_CASE = True
return cls(encoder=encoder_config.to_dict(), decoder=decoder_config.to_dict(), **_a )
def __lowerCAmelCase ( self ) -> Dict:
__SCREAMING_SNAKE_CASE = copy.deepcopy(self.__dict__ )
__SCREAMING_SNAKE_CASE = self.encoder.to_dict()
__SCREAMING_SNAKE_CASE = self.decoder.to_dict()
__SCREAMING_SNAKE_CASE = self.__class__.model_type
return output
| 214
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.