code stringlengths 81 54k | code_codestyle int64 0 721 | style_context stringlengths 91 41.9k | style_context_codestyle int64 0 699 | label int64 0 1 |
|---|---|---|---|---|
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_sentencepiece_available,
is_tokenizers_available,
is_torch_available,
)
lowerCAmelCase__ : Union[str, Any] = {
'configuration_llama': ['LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LlamaConfig'],
}
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : int = ['LlamaTokenizer']
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : str = ['LlamaTokenizerFast']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'LlamaForCausalLM',
'LlamaModel',
'LlamaPreTrainedModel',
'LlamaForSequenceClassification',
]
if TYPE_CHECKING:
from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_llama import LlamaTokenizer
try:
if not is_tokenizers_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_llama_fast import LlamaTokenizerFast
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel
else:
import sys
lowerCAmelCase__ : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | """simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import os
from shutil import copyfile
from typing import List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
lowerCAmelCase__ : str = logging.get_logger(__name__)
lowerCAmelCase__ : Dict = {'vocab_file': 'sentencepiece.model'}
lowerCAmelCase__ : str = {
'vocab_file': {
'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model',
},
}
lowerCAmelCase__ : str = {
'google/rembert': 256,
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = VOCAB_FILES_NAMES
snake_case__ = PRETRAINED_VOCAB_FILES_MAP
snake_case__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
def __init__( self : List[str] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Tuple=False ,lowerCamelCase__ : Dict=True ,lowerCamelCase__ : Optional[int]=True ,lowerCamelCase__ : List[str]="[CLS]" ,lowerCamelCase__ : Optional[Any]="[SEP]" ,lowerCamelCase__ : int="[UNK]" ,lowerCamelCase__ : List[str]="[SEP]" ,lowerCamelCase__ : Union[str, Any]="[PAD]" ,lowerCamelCase__ : Union[str, Any]="[CLS]" ,lowerCamelCase__ : Any="[MASK]" ,**lowerCamelCase__ : Union[str, Any] ,):
super().__init__(
do_lower_case=lowerCamelCase__ ,remove_space=lowerCamelCase__ ,keep_accents=lowerCamelCase__ ,bos_token=lowerCamelCase__ ,eos_token=lowerCamelCase__ ,unk_token=lowerCamelCase__ ,sep_token=lowerCamelCase__ ,pad_token=lowerCamelCase__ ,cls_token=lowerCamelCase__ ,mask_token=lowerCamelCase__ ,**lowerCamelCase__ ,)
UpperCAmelCase__ = do_lower_case
UpperCAmelCase__ = remove_space
UpperCAmelCase__ = keep_accents
UpperCAmelCase__ = vocab_file
UpperCAmelCase__ = spm.SentencePieceProcessor()
self.sp_model.Load(lowerCamelCase__ )
@property
def __lowerCAmelCase ( self : Tuple ):
return len(self.sp_model )
def __lowerCAmelCase ( self : Dict ):
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 : List[str] ):
UpperCAmelCase__ = self.__dict__.copy()
UpperCAmelCase__ = None
return state
def __setstate__( self : Dict ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = d
UpperCAmelCase__ = spm.SentencePieceProcessor()
self.sp_model.Load(self.vocab_file )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : Tuple=False ):
UpperCAmelCase__ = self.sp_model.EncodeAsPieces(lowerCamelCase__ )
return pieces
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : List[str] ):
return self.sp_model.PieceToId(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : str ):
return self.sp_model.IdToPiece(lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : List[Any] ):
UpperCAmelCase__ = self.sp_model.decode_pieces(lowerCamelCase__ )
return out_string
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
UpperCAmelCase__ = [self.sep_token_id]
UpperCAmelCase__ = [self.cls_token_id]
if token_ids_a is None:
return cls + token_ids_a + sep
return cls + token_ids_a + sep + token_ids_a + sep
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ,lowerCamelCase__ : bool = False ):
if already_has_special_tokens:
if token_ids_a is not None:
raise ValueError(
'You should not supply a second sequence if the provided sequence of '
'ids is already formatted with special tokens for the model.' )
return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]
if token_ids_a is not None:
return [1] + ([0] * len(lowerCamelCase__ )) + [1] + ([0] * len(lowerCamelCase__ )) + [1]
return [1] + ([0] * len(lowerCamelCase__ )) + [1]
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
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 ) * [0] + len(token_ids_a + sep ) * [1]
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[str] = None ):
if not os.path.isdir(lowerCamelCase__ ):
logger.error('Vocabulary path ({}) should be a directory'.format(lowerCamelCase__ ) )
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__ ):
copyfile(self.vocab_file ,lowerCamelCase__ )
return (out_vocab_file,)
| 632 | """simple docstring"""
import random
class snake_case :
"""simple docstring"""
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : str ):
UpperCAmelCase__ = [ord(lowerCamelCase__ ) for i in text]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i in plain:
UpperCAmelCase__ = random.randint(1 ,300 )
UpperCAmelCase__ = (i + k) * k
cipher.append(lowerCamelCase__ )
key.append(lowerCamelCase__ )
return cipher, key
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = int((cipher[i] - (key[i]) ** 2) / key[i] )
plain.append(chr(lowerCamelCase__ ) )
return "".join(lowerCamelCase__ )
if __name__ == "__main__":
lowerCAmelCase__ , lowerCAmelCase__ : Dict = Onepad().encrypt('Hello')
print(c, k)
print(Onepad().decrypt(c, k))
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = 1
for i in range(1 , num + 1 ):
fact *= i
return fact
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = 0
while number > 0:
UpperCAmelCase__ = number % 1_0
sum_of_digits += last_digit
UpperCAmelCase__ = number // 1_0 # Removing the last_digit from the given number
return sum_of_digits
def a_ ( lowerCamelCase = 1_0_0 ):
UpperCAmelCase__ = factorial(lowerCamelCase )
UpperCAmelCase__ = split_and_add(lowerCamelCase )
return result
if __name__ == "__main__":
print(solution(int(input('Enter the Number: ').strip())))
| 632 | """simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
lowerCAmelCase__ : Any = {
'configuration_mctct': ['MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MCTCTConfig'],
'feature_extraction_mctct': ['MCTCTFeatureExtractor'],
'processing_mctct': ['MCTCTProcessor'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST',
'MCTCTForCTC',
'MCTCTModel',
'MCTCTPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
from .feature_extraction_mctct import MCTCTFeatureExtractor
from .processing_mctct import MCTCTProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel
else:
import sys
lowerCAmelCase__ : Optional[int] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | """simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | 1 |
"""simple docstring"""
import warnings
from ...utils import logging
from .image_processing_poolformer import PoolFormerImageProcessor
lowerCAmelCase__ : Any = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : Any ,*lowerCamelCase__ : List[Any] ,**lowerCamelCase__ : Union[str, Any] ):
warnings.warn(
'The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
' Please use PoolFormerImageProcessor instead.' ,lowerCamelCase__ ,)
super().__init__(*lowerCamelCase__ ,**lowerCamelCase__ )
| 632 | """simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | 1 |
"""simple docstring"""
from math import ceil
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(range(0 , lowerCamelCase ) )
UpperCAmelCase__ = [item for sublist in list(device_map.values() ) for item in sublist]
# Duplicate check
UpperCAmelCase__ = []
for i in device_map_blocks:
if device_map_blocks.count(lowerCamelCase ) > 1 and i not in duplicate_blocks:
duplicate_blocks.append(lowerCamelCase )
# Missing blocks
UpperCAmelCase__ = [i for i in blocks if i not in device_map_blocks]
UpperCAmelCase__ = [i for i in device_map_blocks if i not in blocks]
if len(lowerCamelCase ) != 0:
raise ValueError(
'Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'
' These attention blocks were specified more than once: ' + str(lowerCamelCase ) )
if len(lowerCamelCase ) != 0:
raise ValueError(
'There are attention blocks for this model that are not specified in the device_map. Add these attention '
'blocks to a device on the device_map: ' + str(lowerCamelCase ) )
if len(lowerCamelCase ) != 0:
raise ValueError(
'The device_map contains more attention blocks than this model has. Remove these from the device_map:'
+ str(lowerCamelCase ) )
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(range(lowerCamelCase ) )
UpperCAmelCase__ = int(ceil(n_layers / len(lowerCamelCase ) ) )
UpperCAmelCase__ = [layers[i : i + n_blocks] for i in range(0 , lowerCamelCase , lowerCamelCase )]
return dict(zip(lowerCamelCase , lowerCamelCase ) )
| 632 | """simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import os
from accelerate.utils import ComputeEnvironment
from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401
from .sagemaker import get_sagemaker_input
lowerCAmelCase__ : Dict = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'
def a_ ( ):
UpperCAmelCase__ = _ask_options(
'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , )
if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
UpperCAmelCase__ = get_sagemaker_input()
else:
UpperCAmelCase__ = get_cluster_input()
return config
def a_ ( lowerCamelCase=None ):
if subparsers is not None:
UpperCAmelCase__ = subparsers.add_parser('config' , description=lowerCamelCase )
else:
UpperCAmelCase__ = argparse.ArgumentParser('Accelerate config command' , description=lowerCamelCase )
parser.add_argument(
'--config_file' , default=lowerCamelCase , help=(
'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
'with \'huggingface\'.'
) , )
if subparsers is not None:
parser.set_defaults(func=lowerCamelCase )
return parser
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_user_input()
if args.config_file is not None:
UpperCAmelCase__ = args.config_file
else:
if not os.path.isdir(lowerCamelCase ):
os.makedirs(lowerCamelCase )
UpperCAmelCase__ = default_yaml_config_file
if config_file.endswith('.json' ):
config.to_json_file(lowerCamelCase )
else:
config.to_yaml_file(lowerCamelCase )
print(f'''accelerate configuration saved at {config_file}''' )
def a_ ( ):
UpperCAmelCase__ = config_command_parser()
UpperCAmelCase__ = parser.parse_args()
config_command(lowerCamelCase )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
from copy import deepcopy
class snake_case :
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : list[int] | None = None ,lowerCamelCase__ : int | None = None ):
if arr is None and size is not None:
UpperCAmelCase__ = size
UpperCAmelCase__ = [0] * size
elif arr is not None:
self.init(lowerCamelCase__ )
else:
raise ValueError('Either arr or size must be specified' )
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = len(lowerCamelCase__ )
UpperCAmelCase__ = deepcopy(lowerCamelCase__ )
for i in range(1 ,self.size ):
UpperCAmelCase__ = self.next_(lowerCamelCase__ )
if j < self.size:
self.tree[j] += self.tree[i]
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.tree[:]
for i in range(self.size - 1 ,0 ,-1 ):
UpperCAmelCase__ = self.next_(lowerCamelCase__ )
if j < self.size:
arr[j] -= arr[i]
return arr
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : int ):
return index + (index & (-index))
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : int ):
return index - (index & (-index))
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if index == 0:
self.tree[0] += value
return
while index < self.size:
self.tree[index] += value
UpperCAmelCase__ = self.next_(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
self.add(lowerCamelCase__ ,value - self.get(lowerCamelCase__ ) )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ):
if right == 0:
return 0
UpperCAmelCase__ = self.tree[0]
right -= 1 # make right inclusive
while right > 0:
result += self.tree[right]
UpperCAmelCase__ = self.prev(lowerCamelCase__ )
return result
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
return self.prefix(lowerCamelCase__ ) - self.prefix(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : int ):
return self.query(lowerCamelCase__ ,index + 1 )
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : int ):
value -= self.tree[0]
if value < 0:
return -1
UpperCAmelCase__ = 1 # Largest power of 2 <= size
while j * 2 < self.size:
j *= 2
UpperCAmelCase__ = 0
while j > 0:
if i + j < self.size and self.tree[i + j] <= value:
value -= self.tree[i + j]
i += j
j //= 2
return i
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | """simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import copy
import tempfile
import unittest
from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError
from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@parameterized.expand([(None,), ('foo.json',)] )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : int ):
UpperCAmelCase__ = GenerationConfig(
do_sample=lowerCamelCase__ ,temperature=0.7 ,length_penalty=1.0 ,bad_words_ids=[[1, 2, 3], [4, 5]] ,)
with tempfile.TemporaryDirectory() as tmp_dir:
config.save_pretrained(lowerCamelCase__ ,config_name=lowerCamelCase__ )
UpperCAmelCase__ = GenerationConfig.from_pretrained(lowerCamelCase__ ,config_name=lowerCamelCase__ )
# Checks parameters that were specified
self.assertEqual(loaded_config.do_sample ,lowerCamelCase__ )
self.assertEqual(loaded_config.temperature ,0.7 )
self.assertEqual(loaded_config.length_penalty ,1.0 )
self.assertEqual(loaded_config.bad_words_ids ,[[1, 2, 3], [4, 5]] )
# Checks parameters that were not specified (defaults)
self.assertEqual(loaded_config.top_k ,50 )
self.assertEqual(loaded_config.max_length ,20 )
self.assertEqual(loaded_config.max_time ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = AutoConfig.from_pretrained('gpt2' )
UpperCAmelCase__ = GenerationConfig.from_model_config(lowerCamelCase__ )
UpperCAmelCase__ = GenerationConfig()
# The generation config has loaded a few non-default parameters from the model config
self.assertNotEqual(lowerCamelCase__ ,lowerCamelCase__ )
# One of those parameters is eos_token_id -- check if it matches
self.assertNotEqual(generation_config_from_model.eos_token_id ,default_generation_config.eos_token_id )
self.assertEqual(generation_config_from_model.eos_token_id ,model_config.eos_token_id )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = GenerationConfig()
UpperCAmelCase__ = {
'max_new_tokens': 1_024,
'foo': 'bar',
}
UpperCAmelCase__ = copy.deepcopy(lowerCamelCase__ )
UpperCAmelCase__ = generation_config.update(**lowerCamelCase__ )
# update_kwargs was not modified (no side effects)
self.assertEqual(lowerCamelCase__ ,lowerCamelCase__ )
# update_kwargs was used to update the config on valid attributes
self.assertEqual(generation_config.max_new_tokens ,1_024 )
# `.update()` returns a dictionary of unused kwargs
self.assertEqual(lowerCamelCase__ ,{'foo': 'bar'} )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = GenerationConfig()
UpperCAmelCase__ = 'bar'
with tempfile.TemporaryDirectory('test-generation-config' ) as tmp_dir:
generation_config.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = GenerationConfig.from_pretrained(lowerCamelCase__ )
# update_kwargs was used to update the config on valid attributes
self.assertEqual(new_config.foo ,'bar' )
UpperCAmelCase__ = GenerationConfig.from_model_config(lowerCamelCase__ )
assert not hasattr(lowerCamelCase__ ,'foo' ) # no new kwargs should be initialized if from config
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = GenerationConfig()
self.assertEqual(default_config.temperature ,1.0 )
self.assertEqual(default_config.do_sample ,lowerCamelCase__ )
self.assertEqual(default_config.num_beams ,1 )
UpperCAmelCase__ = GenerationConfig(
do_sample=lowerCamelCase__ ,temperature=0.7 ,length_penalty=1.0 ,bad_words_ids=[[1, 2, 3], [4, 5]] ,)
self.assertEqual(config.temperature ,0.7 )
self.assertEqual(config.do_sample ,lowerCamelCase__ )
self.assertEqual(config.num_beams ,1 )
with tempfile.TemporaryDirectory() as tmp_dir:
config.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = GenerationConfig.from_pretrained(lowerCamelCase__ ,temperature=1.0 )
self.assertEqual(loaded_config.temperature ,1.0 )
self.assertEqual(loaded_config.do_sample ,lowerCamelCase__ )
self.assertEqual(loaded_config.num_beams ,1 ) # default value
@is_staging_test
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@classmethod
def __lowerCAmelCase ( cls : Optional[int] ):
UpperCAmelCase__ = TOKEN
HfFolder.save_token(lowerCamelCase__ )
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ):
try:
delete_repo(token=cls._token ,repo_id='test-generation-config' )
except HTTPError:
pass
try:
delete_repo(token=cls._token ,repo_id='valid_org/test-generation-config-org' )
except HTTPError:
pass
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = GenerationConfig(
do_sample=lowerCamelCase__ ,temperature=0.7 ,length_penalty=1.0 ,)
config.push_to_hub('test-generation-config' ,use_auth_token=self._token )
UpperCAmelCase__ = GenerationConfig.from_pretrained(f'''{USER}/test-generation-config''' )
for k, v in config.to_dict().items():
if k != "transformers_version":
self.assertEqual(lowerCamelCase__ ,getattr(lowerCamelCase__ ,lowerCamelCase__ ) )
# Reset repo
delete_repo(token=self._token ,repo_id='test-generation-config' )
# Push to hub via save_pretrained
with tempfile.TemporaryDirectory() as tmp_dir:
config.save_pretrained(
lowerCamelCase__ ,repo_id='test-generation-config' ,push_to_hub=lowerCamelCase__ ,use_auth_token=self._token )
UpperCAmelCase__ = GenerationConfig.from_pretrained(f'''{USER}/test-generation-config''' )
for k, v in config.to_dict().items():
if k != "transformers_version":
self.assertEqual(lowerCamelCase__ ,getattr(lowerCamelCase__ ,lowerCamelCase__ ) )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = GenerationConfig(
do_sample=lowerCamelCase__ ,temperature=0.7 ,length_penalty=1.0 ,)
config.push_to_hub('valid_org/test-generation-config-org' ,use_auth_token=self._token )
UpperCAmelCase__ = GenerationConfig.from_pretrained('valid_org/test-generation-config-org' )
for k, v in config.to_dict().items():
if k != "transformers_version":
self.assertEqual(lowerCamelCase__ ,getattr(lowerCamelCase__ ,lowerCamelCase__ ) )
# Reset repo
delete_repo(token=self._token ,repo_id='valid_org/test-generation-config-org' )
# Push to hub via save_pretrained
with tempfile.TemporaryDirectory() as tmp_dir:
config.save_pretrained(
lowerCamelCase__ ,repo_id='valid_org/test-generation-config-org' ,push_to_hub=lowerCamelCase__ ,use_auth_token=self._token )
UpperCAmelCase__ = GenerationConfig.from_pretrained('valid_org/test-generation-config-org' )
for k, v in config.to_dict().items():
if k != "transformers_version":
self.assertEqual(lowerCamelCase__ ,getattr(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | """simple docstring"""
import warnings
from functools import wraps
from typing import Callable
def a_ ( lowerCamelCase ):
@wraps(lowerCamelCase )
def _inner_fn(*lowerCamelCase , **lowerCamelCase ):
warnings.warn(
(f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''') , lowerCamelCase , )
return fn(*lowerCamelCase , **lowerCamelCase )
return _inner_fn
| 632 | 1 |
"""simple docstring"""
import itertools
import random
import unittest
import numpy as np
from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available
from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin
if is_torch_available():
import torch
lowerCAmelCase__ : Any = random.Random()
def a_ ( lowerCamelCase , lowerCamelCase=1.0 , lowerCamelCase=None , lowerCamelCase=None ):
if rng is None:
UpperCAmelCase__ = global_rng
UpperCAmelCase__ = []
for batch_idx in range(shape[0] ):
values.append([] )
for _ in range(shape[1] ):
values[-1].append(rng.random() * scale )
return values
@require_torch
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : str ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Dict=7 ,lowerCamelCase__ : Optional[int]=400 ,lowerCamelCase__ : List[str]=2_000 ,lowerCamelCase__ : Any=1 ,lowerCamelCase__ : Any=0.0 ,lowerCamelCase__ : str=16_000 ,lowerCamelCase__ : str=True ,lowerCamelCase__ : Union[str, Any]=80 ,lowerCamelCase__ : List[Any]=16 ,lowerCamelCase__ : List[str]=64 ,lowerCamelCase__ : Union[str, Any]="hann_window" ,lowerCamelCase__ : Optional[Any]=80 ,lowerCamelCase__ : Dict=7_600 ,lowerCamelCase__ : List[Any]=1e-10 ,lowerCamelCase__ : Union[str, Any]=True ,):
UpperCAmelCase__ = parent
UpperCAmelCase__ = batch_size
UpperCAmelCase__ = min_seq_length
UpperCAmelCase__ = max_seq_length
UpperCAmelCase__ = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
UpperCAmelCase__ = feature_size
UpperCAmelCase__ = padding_value
UpperCAmelCase__ = sampling_rate
UpperCAmelCase__ = do_normalize
UpperCAmelCase__ = num_mel_bins
UpperCAmelCase__ = hop_length
UpperCAmelCase__ = win_length
UpperCAmelCase__ = win_function
UpperCAmelCase__ = fmin
UpperCAmelCase__ = fmax
UpperCAmelCase__ = mel_floor
UpperCAmelCase__ = return_attention_mask
def __lowerCAmelCase ( self : Tuple ):
return {
"feature_size": self.feature_size,
"padding_value": self.padding_value,
"sampling_rate": self.sampling_rate,
"do_normalize": self.do_normalize,
"num_mel_bins": self.num_mel_bins,
"hop_length": self.hop_length,
"win_length": self.win_length,
"win_function": self.win_function,
"fmin": self.fmin,
"fmax": self.fmax,
"mel_floor": self.mel_floor,
"return_attention_mask": self.return_attention_mask,
}
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : List[str]=False ,lowerCamelCase__ : Tuple=False ):
def _flatten(lowerCamelCase__ : List[Any] ):
return list(itertools.chain(*lowerCamelCase__ ) )
if equal_length:
UpperCAmelCase__ = floats_list((self.batch_size, self.max_seq_length) )
else:
# make sure that inputs increase in size
UpperCAmelCase__ = [
_flatten(floats_list((x, self.feature_size) ) )
for x in range(self.min_seq_length ,self.max_seq_length ,self.seq_length_diff )
]
if numpify:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for x in speech_inputs]
return speech_inputs
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : Union[str, Any]=False ,lowerCamelCase__ : Optional[Any]=False ):
if equal_length:
UpperCAmelCase__ = [floats_list((self.max_seq_length, self.num_mel_bins) ) for _ in range(self.batch_size )]
else:
# make sure that inputs increase in size
UpperCAmelCase__ = [
floats_list((x, self.num_mel_bins) )
for x in range(self.min_seq_length ,self.max_seq_length ,self.seq_length_diff )
]
if numpify:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for x in speech_inputs]
return speech_inputs
@require_torch
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = SpeechTaFeatureExtractor
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = SpeechTaFeatureExtractionTester(self )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Optional[Any] ):
self.assertTrue(np.all(np.mean(lowerCamelCase__ ,axis=0 ) < 1e-3 ) )
self.assertTrue(np.all(np.abs(np.var(lowerCamelCase__ ,axis=0 ) - 1 ) < 1e-3 ) )
def __lowerCAmelCase ( self : Any ):
# Tests that all call wrap to encode_plus and batch_encode_plus
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
# create three inputs of length 800, 1000, and 1200
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for speech_input in speech_inputs]
# Test not batched input
UpperCAmelCase__ = feat_extract(speech_inputs[0] ,return_tensors='np' ).input_values
UpperCAmelCase__ = feat_extract(np_speech_inputs[0] ,return_tensors='np' ).input_values
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) )
# Test batched
UpperCAmelCase__ = feat_extract(lowerCamelCase__ ,return_tensors='np' ).input_values
UpperCAmelCase__ = feat_extract(lowerCamelCase__ ,return_tensors='np' ).input_values
for enc_seq_a, enc_seq_a in zip(lowerCamelCase__ ,lowerCamelCase__ ):
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) )
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = ['longest', 'max_length', 'do_not_pad']
UpperCAmelCase__ = [None, 1_600, None]
for max_length, padding in zip(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = feat_extract(lowerCamelCase__ ,padding=lowerCamelCase__ ,max_length=lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processed.input_values
self._check_zero_mean_unit_variance(input_values[0][:800] )
self.assertTrue(input_values[0][800:].sum() < 1e-6 )
self._check_zero_mean_unit_variance(input_values[1][:1_000] )
self.assertTrue(input_values[0][1_000:].sum() < 1e-6 )
self._check_zero_mean_unit_variance(input_values[2][:1_200] )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
UpperCAmelCase__ = range(800 ,1_400 ,200 )
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in lengths]
UpperCAmelCase__ = ['longest', 'max_length', 'do_not_pad']
UpperCAmelCase__ = [None, 1_600, None]
for max_length, padding in zip(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = feat_extract(lowerCamelCase__ ,max_length=lowerCamelCase__ ,padding=lowerCamelCase__ )
UpperCAmelCase__ = processed.input_values
self._check_zero_mean_unit_variance(input_values[0][:800] )
self._check_zero_mean_unit_variance(input_values[1][:1_000] )
self._check_zero_mean_unit_variance(input_values[2][:1_200] )
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = feat_extract(
lowerCamelCase__ ,truncation=lowerCamelCase__ ,max_length=1_000 ,padding='max_length' ,return_tensors='np' )
UpperCAmelCase__ = processed.input_values
self._check_zero_mean_unit_variance(input_values[0, :800] )
self._check_zero_mean_unit_variance(input_values[1] )
self._check_zero_mean_unit_variance(input_values[2] )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = feat_extract(
lowerCamelCase__ ,truncation=lowerCamelCase__ ,max_length=1_000 ,padding='longest' ,return_tensors='np' )
UpperCAmelCase__ = processed.input_values
self._check_zero_mean_unit_variance(input_values[0, :800] )
self._check_zero_mean_unit_variance(input_values[1, :1_000] )
self._check_zero_mean_unit_variance(input_values[2] )
# make sure that if max_length < longest -> then pad to max_length
self.assertTrue(input_values.shape == (3, 1_000) )
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = feat_extract(
lowerCamelCase__ ,truncation=lowerCamelCase__ ,max_length=2_000 ,padding='longest' ,return_tensors='np' )
UpperCAmelCase__ = processed.input_values
self._check_zero_mean_unit_variance(input_values[0, :800] )
self._check_zero_mean_unit_variance(input_values[1, :1_000] )
self._check_zero_mean_unit_variance(input_values[2] )
# make sure that if max_length > longest -> then pad to longest
self.assertTrue(input_values.shape == (3, 1_200) )
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
UpperCAmelCase__ = np.random.rand(100 ).astype(np.floataa )
UpperCAmelCase__ = np_speech_inputs.tolist()
for inputs in [py_speech_inputs, np_speech_inputs]:
UpperCAmelCase__ = feature_extractor.pad([{'input_values': inputs}] ,return_tensors='np' )
self.assertTrue(np_processed.input_values.dtype == np.floataa )
UpperCAmelCase__ = feature_extractor.pad([{'input_values': inputs}] ,return_tensors='pt' )
self.assertTrue(pt_processed.input_values.dtype == torch.floataa )
def __lowerCAmelCase ( self : str ):
# Tests that all call wrap to encode_plus and batch_encode_plus
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
# create three inputs of length 800, 1000, and 1200
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in range(800 ,1_400 ,200 )]
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ) for speech_input in speech_inputs]
# Test feature size
UpperCAmelCase__ = feature_extractor(audio_target=lowerCamelCase__ ,padding=lowerCamelCase__ ,return_tensors='np' ).input_values
self.assertTrue(input_values.ndim == 3 )
self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins )
# Test not batched input
UpperCAmelCase__ = feature_extractor(speech_inputs[0] ,return_tensors='np' ).input_values
UpperCAmelCase__ = feature_extractor(np_speech_inputs[0] ,return_tensors='np' ).input_values
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) )
# Test batched
UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_values
UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_values
for enc_seq_a, enc_seq_a in zip(lowerCamelCase__ ,lowerCamelCase__ ):
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) )
# Test 2-D numpy arrays are batched.
UpperCAmelCase__ = [floats_list((1, x) )[0] for x in (800, 800, 800)]
UpperCAmelCase__ = np.asarray(lowerCamelCase__ )
UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_values
UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='np' ).input_values
for enc_seq_a, enc_seq_a in zip(lowerCamelCase__ ,lowerCamelCase__ ):
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) )
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target()
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
self.assertTrue(all(len(lowerCamelCase__ ) == len(lowerCamelCase__ ) for x, y in zip(lowerCamelCase__ ,processed_features[input_name] ) ) )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase__ )
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} ,tensor_type='np' )
UpperCAmelCase__ = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
UpperCAmelCase__ = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.num_mel_bins) )
@require_torch
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase__ )
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} ,tensor_type='pt' )
UpperCAmelCase__ = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
UpperCAmelCase__ = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.num_mel_bins) )
@require_torch
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target()
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = feat_extract.num_mel_bins # hack!
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='pt' )[input_name]
self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_pt.numpy().astype(np.floataa ).sum() ) < 1e-2 )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.feat_extract_dict
UpperCAmelCase__ = True
UpperCAmelCase__ = self.feature_extraction_class(**lowerCamelCase__ )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target()
UpperCAmelCase__ = [len(lowerCamelCase__ ) for x in speech_inputs]
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = feat_extract.num_mel_bins # hack!
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )
self.assertIn('attention_mask' ,lowerCamelCase__ )
self.assertListEqual(list(processed.attention_mask.shape ) ,list(processed[input_name].shape[:2] ) )
self.assertListEqual(processed.attention_mask.sum(-1 ).tolist() ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = self.feat_extract_dict
UpperCAmelCase__ = True
UpperCAmelCase__ = self.feature_extraction_class(**lowerCamelCase__ )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_target()
UpperCAmelCase__ = [len(lowerCamelCase__ ) for x in speech_inputs]
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = min(lowerCamelCase__ )
UpperCAmelCase__ = feat_extract.num_mel_bins # hack!
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=lowerCamelCase__ ,truncation=lowerCamelCase__ ,return_tensors='np' )
self.assertIn('attention_mask' ,lowerCamelCase__ )
self.assertListEqual(
list(processed_pad.attention_mask.shape ) ,[processed_pad[input_name].shape[0], max_length] )
self.assertListEqual(
processed_pad.attention_mask[:, :max_length].sum(-1 ).tolist() ,[max_length for x in speech_inputs] )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : Optional[int] ):
from datasets import load_dataset
UpperCAmelCase__ = load_dataset('hf-internal-testing/librispeech_asr_dummy' ,'clean' ,split='validation' )
# automatic decoding with librispeech
UpperCAmelCase__ = ds.sort('id' ).select(range(lowerCamelCase__ ) )[:num_samples]['audio']
return [x["array"] for x in speech_samples]
def __lowerCAmelCase ( self : Any ):
# fmt: off
UpperCAmelCase__ = torch.tensor(
[2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03] )
# fmt: on
UpperCAmelCase__ = self._load_datasamples(1 )
UpperCAmelCase__ = SpeechTaFeatureExtractor()
UpperCAmelCase__ = feature_extractor(lowerCamelCase__ ,return_tensors='pt' ).input_values
self.assertEquals(input_values.shape ,(1, 93_680) )
self.assertTrue(torch.allclose(input_values[0, :30] ,lowerCamelCase__ ,atol=1e-6 ) )
def __lowerCAmelCase ( self : Optional[Any] ):
# fmt: off
UpperCAmelCase__ = torch.tensor(
[-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
-3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
-3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
-3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8] )
# fmt: on
UpperCAmelCase__ = self._load_datasamples(1 )
UpperCAmelCase__ = SpeechTaFeatureExtractor()
UpperCAmelCase__ = feature_extractor(audio_target=lowerCamelCase__ ,return_tensors='pt' ).input_values
self.assertEquals(input_values.shape ,(1, 366, 80) )
self.assertTrue(torch.allclose(input_values[0, 0, :30] ,lowerCamelCase__ ,atol=1e-4 ) )
| 632 | """simple docstring"""
from __future__ import annotations
import string
from itertools import cycle, product
from pathlib import Path
lowerCAmelCase__ : str = (
string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__ : list[int] = [ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__ : set[int] = {ord(char) for char in VALID_CHARS}
lowerCAmelCase__ : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"]
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = ""
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
for keychar, cipherchar in zip(cycle(lowerCamelCase ) , lowerCamelCase ):
UpperCAmelCase__ = cipherchar ^ keychar
if decodedchar not in VALID_INTS:
return None
decoded += chr(lowerCamelCase )
return decoded
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
for key in product(lowerCamelCase , repeat=3 ):
UpperCAmelCase__ = try_key(lowerCamelCase , lowerCamelCase )
if encoded is not None:
possibles.append(lowerCamelCase )
return possibles
def a_ ( lowerCamelCase , lowerCamelCase ):
return [possible for possible in possibles if common_word in possible.lower()]
def a_ ( lowerCamelCase = "p059_cipher.txt" ):
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )
UpperCAmelCase__ = [int(lowerCamelCase ) for number in data.strip().split(',' )]
UpperCAmelCase__ = filter_valid_chars(lowerCamelCase )
for common_word in COMMON_WORDS:
UpperCAmelCase__ = filter_common_word(lowerCamelCase , lowerCamelCase )
if len(lowerCamelCase ) == 1:
break
UpperCAmelCase__ = possibles[0]
return sum(ord(lowerCamelCase ) for char in decoded_text )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import gc
import unittest
from diffusers import FlaxControlNetModel, FlaxStableDiffusionControlNetPipeline
from diffusers.utils import is_flax_available, load_image, slow
from diffusers.utils.testing_utils import require_flax
if is_flax_available():
import jax
import jax.numpy as jnp
from flax.jax_utils import replicate
from flax.training.common_utils import shard
@slow
@require_flax
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
# clean up the VRAM after each test
super().tearDown()
gc.collect()
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ , UpperCAmelCase__ = FlaxControlNetModel.from_pretrained(
'lllyasviel/sd-controlnet-canny' ,from_pt=lowerCamelCase__ ,dtype=jnp.bfloataa )
UpperCAmelCase__ , UpperCAmelCase__ = FlaxStableDiffusionControlNetPipeline.from_pretrained(
'runwayml/stable-diffusion-v1-5' ,controlnet=lowerCamelCase__ ,from_pt=lowerCamelCase__ ,dtype=jnp.bfloataa )
UpperCAmelCase__ = controlnet_params
UpperCAmelCase__ = 'bird'
UpperCAmelCase__ = jax.device_count()
UpperCAmelCase__ = pipe.prepare_text_inputs([prompts] * num_samples )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png' )
UpperCAmelCase__ = pipe.prepare_image_inputs([canny_image] * num_samples )
UpperCAmelCase__ = jax.random.PRNGKey(0 )
UpperCAmelCase__ = jax.random.split(lowerCamelCase__ ,jax.device_count() )
UpperCAmelCase__ = replicate(lowerCamelCase__ )
UpperCAmelCase__ = shard(lowerCamelCase__ )
UpperCAmelCase__ = shard(lowerCamelCase__ )
UpperCAmelCase__ = pipe(
prompt_ids=lowerCamelCase__ ,image=lowerCamelCase__ ,params=lowerCamelCase__ ,prng_seed=lowerCamelCase__ ,num_inference_steps=50 ,jit=lowerCamelCase__ ,).images
assert images.shape == (jax.device_count(), 1, 768, 512, 3)
UpperCAmelCase__ = images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] )
UpperCAmelCase__ = images[0, 253:256, 253:256, -1]
UpperCAmelCase__ = jnp.asarray(jax.device_get(image_slice.flatten() ) )
UpperCAmelCase__ = jnp.array(
[0.1_6_7_9_6_9, 0.1_1_6_6_9_9, 0.0_8_1_5_4_3, 0.1_5_4_2_9_7, 0.1_3_2_8_1_2, 0.1_0_8_8_8_7, 0.1_6_9_9_2_2, 0.1_6_9_9_2_2, 0.2_0_5_0_7_8] )
print(f'''output_slice: {output_slice}''' )
assert jnp.abs(output_slice - expected_slice ).max() < 1e-2
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ , UpperCAmelCase__ = FlaxControlNetModel.from_pretrained(
'lllyasviel/sd-controlnet-openpose' ,from_pt=lowerCamelCase__ ,dtype=jnp.bfloataa )
UpperCAmelCase__ , UpperCAmelCase__ = FlaxStableDiffusionControlNetPipeline.from_pretrained(
'runwayml/stable-diffusion-v1-5' ,controlnet=lowerCamelCase__ ,from_pt=lowerCamelCase__ ,dtype=jnp.bfloataa )
UpperCAmelCase__ = controlnet_params
UpperCAmelCase__ = 'Chef in the kitchen'
UpperCAmelCase__ = jax.device_count()
UpperCAmelCase__ = pipe.prepare_text_inputs([prompts] * num_samples )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/pose.png' )
UpperCAmelCase__ = pipe.prepare_image_inputs([pose_image] * num_samples )
UpperCAmelCase__ = jax.random.PRNGKey(0 )
UpperCAmelCase__ = jax.random.split(lowerCamelCase__ ,jax.device_count() )
UpperCAmelCase__ = replicate(lowerCamelCase__ )
UpperCAmelCase__ = shard(lowerCamelCase__ )
UpperCAmelCase__ = shard(lowerCamelCase__ )
UpperCAmelCase__ = pipe(
prompt_ids=lowerCamelCase__ ,image=lowerCamelCase__ ,params=lowerCamelCase__ ,prng_seed=lowerCamelCase__ ,num_inference_steps=50 ,jit=lowerCamelCase__ ,).images
assert images.shape == (jax.device_count(), 1, 768, 512, 3)
UpperCAmelCase__ = images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] )
UpperCAmelCase__ = images[0, 253:256, 253:256, -1]
UpperCAmelCase__ = jnp.asarray(jax.device_get(image_slice.flatten() ) )
UpperCAmelCase__ = jnp.array(
[[0.2_7_1_4_8_4, 0.2_6_1_7_1_9, 0.2_7_5_3_9_1, 0.2_7_7_3_4_4, 0.2_7_9_2_9_7, 0.2_9_1_0_1_6, 0.2_9_4_9_2_2, 0.3_0_2_7_3_4, 0.3_0_2_7_3_4]] )
print(f'''output_slice: {output_slice}''' )
assert jnp.abs(output_slice - expected_slice ).max() < 1e-2
| 632 | """simple docstring"""
import unittest
from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : Any = get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = XLMProphetNetTokenizer
snake_case__ = False
snake_case__ = True
def __lowerCAmelCase ( self : Any ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = '[PAD]'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'[PAD]' )
self.assertEqual(vocab_keys[1] ,'[CLS]' )
self.assertEqual(vocab_keys[-1] ,'j' )
self.assertEqual(len(lowerCamelCase__ ) ,1_012 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,1_012 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowerCamelCase__ ,['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,)
UpperCAmelCase__ = 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',
'é',
'.',
] ,)
UpperCAmelCase__ = tokenizer.convert_tokens_to_ids(lowerCamelCase__ )
self.assertListEqual(
lowerCamelCase__ ,[
value + tokenizer.fairseq_offset
for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
] ,)
UpperCAmelCase__ = 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 __lowerCAmelCase ( self : Dict ):
return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )
@slow
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello World!'
UpperCAmelCase__ = [35_389, 6_672, 49, 2]
self.assertListEqual(lowerCamelCase__ ,self.big_tokenizer.encode(lowerCamelCase__ ) )
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/xprophetnet-large-wiki100-cased' ,revision='1acad1643ddd54a44df6a1b797ada8373685d90e' ,)
| 632 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
lowerCAmelCase__ : int = {
'configuration_upernet': ['UperNetConfig'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : int = [
'UperNetForSemanticSegmentation',
'UperNetPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_upernet import UperNetConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel
else:
import sys
lowerCAmelCase__ : int = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | """simple docstring"""
from __future__ import annotations
import collections
import pprint
from pathlib import Path
def a_ ( lowerCamelCase ):
return "".join(sorted(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
return word_by_signature[signature(lowerCamelCase )]
lowerCAmelCase__ : str = Path(__file__).parent.joinpath('words.txt').read_text(encoding='utf-8')
lowerCAmelCase__ : str = sorted({word.strip().lower() for word in data.splitlines()})
lowerCAmelCase__ : Optional[Any] = collections.defaultdict(list)
for word in word_list:
word_by_signature[signature(word)].append(word)
if __name__ == "__main__":
lowerCAmelCase__ : int = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
with open('anagrams.txt', 'w') as file:
file.write('all_anagrams = \n ')
file.write(pprint.pformat(all_anagrams))
| 632 | 1 |
"""simple docstring"""
import argparse
import requests
import torch
# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image
from transformers import (
AutoTokenizer,
BlipaConfig,
BlipaForConditionalGeneration,
BlipaProcessor,
BlipaVisionConfig,
BlipImageProcessor,
OPTConfig,
TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
def a_ ( ):
UpperCAmelCase__ = 'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
UpperCAmelCase__ = Image.open(requests.get(lowerCamelCase , stream=lowerCamelCase ).raw ).convert('RGB' )
return image
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
# fmt: off
# vision encoder
rename_keys.append(('visual_encoder.cls_token', 'vision_model.embeddings.class_embedding') )
rename_keys.append(('visual_encoder.pos_embed', 'vision_model.embeddings.position_embedding') )
rename_keys.append(('visual_encoder.patch_embed.proj.weight', 'vision_model.embeddings.patch_embedding.weight') )
rename_keys.append(('visual_encoder.patch_embed.proj.bias', 'vision_model.embeddings.patch_embedding.bias') )
rename_keys.append(('ln_vision.weight', 'vision_model.post_layernorm.weight') )
rename_keys.append(('ln_vision.bias', 'vision_model.post_layernorm.bias') )
for i in range(config.vision_config.num_hidden_layers ):
rename_keys.append((f'''visual_encoder.blocks.{i}.norm1.weight''', f'''vision_model.encoder.layers.{i}.layer_norm1.weight''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.norm1.bias''', f'''vision_model.encoder.layers.{i}.layer_norm1.bias''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.norm2.weight''', f'''vision_model.encoder.layers.{i}.layer_norm2.weight''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.norm2.bias''', f'''vision_model.encoder.layers.{i}.layer_norm2.bias''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.attn.qkv.weight''', f'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.attn.proj.weight''', f'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',) )
rename_keys.append((f'''visual_encoder.blocks.{i}.attn.proj.bias''', f'''vision_model.encoder.layers.{i}.self_attn.projection.bias''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.mlp.fc1.weight''', f'''vision_model.encoder.layers.{i}.mlp.fc1.weight''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.mlp.fc1.bias''', f'''vision_model.encoder.layers.{i}.mlp.fc1.bias''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.mlp.fc2.weight''', f'''vision_model.encoder.layers.{i}.mlp.fc2.weight''') )
rename_keys.append((f'''visual_encoder.blocks.{i}.mlp.fc2.bias''', f'''vision_model.encoder.layers.{i}.mlp.fc2.bias''') )
# QFormer
rename_keys.append(('Qformer.bert.embeddings.LayerNorm.weight', 'qformer.layernorm.weight') )
rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.layernorm.bias') )
# fmt: on
return rename_keys
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = dct.pop(lowerCamelCase )
UpperCAmelCase__ = val
def a_ ( lowerCamelCase , lowerCamelCase ):
for i in range(config.vision_config.num_hidden_layers ):
# read in original q and v biases
UpperCAmelCase__ = state_dict.pop(f'''visual_encoder.blocks.{i}.attn.q_bias''' )
UpperCAmelCase__ = state_dict.pop(f'''visual_encoder.blocks.{i}.attn.v_bias''' )
# next, set bias in the state dict
UpperCAmelCase__ = torch.cat((q_bias, torch.zeros_like(lowerCamelCase , requires_grad=lowerCamelCase ), v_bias) )
UpperCAmelCase__ = qkv_bias
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = 3_6_4 if 'coco' in model_name else 2_2_4
UpperCAmelCase__ = BlipaVisionConfig(image_size=lowerCamelCase ).to_dict()
# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
# seems like flan-T5 models don't have bos_token_id properly set?
if "opt-2.7b" in model_name:
UpperCAmelCase__ = OPTConfig.from_pretrained('facebook/opt-2.7b' , eos_token_id=lowerCamelCase ).to_dict()
elif "opt-6.7b" in model_name:
UpperCAmelCase__ = OPTConfig.from_pretrained('facebook/opt-6.7b' , eos_token_id=lowerCamelCase ).to_dict()
elif "t5-xl" in model_name:
UpperCAmelCase__ = TaConfig.from_pretrained('google/flan-t5-xl' , dense_act_fn='gelu' , bos_token_id=1 ).to_dict()
elif "t5-xxl" in model_name:
UpperCAmelCase__ = TaConfig.from_pretrained('google/flan-t5-xxl' , dense_act_fn='gelu' , bos_token_id=1 ).to_dict()
UpperCAmelCase__ = BlipaConfig(vision_config=lowerCamelCase , text_config=lowerCamelCase )
return config, image_size
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=False ):
UpperCAmelCase__ = (
AutoTokenizer.from_pretrained('facebook/opt-2.7b' )
if 'opt' in model_name
else AutoTokenizer.from_pretrained('google/flan-t5-xl' )
)
UpperCAmelCase__ = tokenizer('\n' , add_special_tokens=lowerCamelCase ).input_ids[0]
UpperCAmelCase__ , UpperCAmelCase__ = get_blipa_config(lowerCamelCase , eos_token_id=lowerCamelCase )
UpperCAmelCase__ = BlipaForConditionalGeneration(lowerCamelCase ).eval()
UpperCAmelCase__ = {
'blip2-opt-2.7b': ('blip2_opt', 'pretrain_opt2.7b'),
'blip2-opt-6.7b': ('blip2_opt', 'pretrain_opt6.7b'),
'blip2-opt-2.7b-coco': ('blip2_opt', 'caption_coco_opt2.7b'),
'blip2-opt-6.7b-coco': ('blip2_opt', 'caption_coco_opt6.7b'),
'blip2-flan-t5-xl': ('blip2_t5', 'pretrain_flant5xl'),
'blip2-flan-t5-xl-coco': ('blip2_t5', 'caption_coco_flant5xl'),
'blip2-flan-t5-xxl': ('blip2_t5', 'pretrain_flant5xxl'),
}
UpperCAmelCase__ , UpperCAmelCase__ = model_name_to_original[model_name]
# load original model
print('Loading original model...' )
UpperCAmelCase__ = 'cuda' if torch.cuda.is_available() else 'cpu'
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = load_model_and_preprocess(
name=lowerCamelCase , model_type=lowerCamelCase , is_eval=lowerCamelCase , device=lowerCamelCase )
original_model.eval()
print('Done!' )
# update state dict keys
UpperCAmelCase__ = original_model.state_dict()
UpperCAmelCase__ = create_rename_keys(lowerCamelCase )
for src, dest in rename_keys:
rename_key(lowerCamelCase , lowerCamelCase , lowerCamelCase )
# some keys can be renamed efficiently
for key, val in state_dict.copy().items():
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
if key.startswith('Qformer.bert' ):
UpperCAmelCase__ = key.replace('Qformer.bert' , 'qformer' )
if "attention.self" in key:
UpperCAmelCase__ = key.replace('self' , 'attention' )
if "opt_proj" in key:
UpperCAmelCase__ = key.replace('opt_proj' , 'language_projection' )
if "t5_proj" in key:
UpperCAmelCase__ = key.replace('t5_proj' , 'language_projection' )
if key.startswith('opt' ):
UpperCAmelCase__ = key.replace('opt' , 'language' )
if key.startswith('t5' ):
UpperCAmelCase__ = key.replace('t5' , 'language' )
UpperCAmelCase__ = val
# read in qv biases
read_in_q_v_bias(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ , UpperCAmelCase__ = hf_model.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
assert len(lowerCamelCase ) == 0
assert unexpected_keys == ["qformer.embeddings.position_ids"]
UpperCAmelCase__ = load_demo_image()
UpperCAmelCase__ = vis_processors['eval'](lowerCamelCase ).unsqueeze(0 ).to(lowerCamelCase )
UpperCAmelCase__ = tokenizer(['\n'] , return_tensors='pt' ).input_ids.to(lowerCamelCase )
# create processor
UpperCAmelCase__ = BlipImageProcessor(
size={'height': image_size, 'width': image_size} , image_mean=lowerCamelCase , image_std=lowerCamelCase )
UpperCAmelCase__ = BlipaProcessor(image_processor=lowerCamelCase , tokenizer=lowerCamelCase )
UpperCAmelCase__ = processor(images=lowerCamelCase , return_tensors='pt' ).pixel_values.to(lowerCamelCase )
# make sure processor creates exact same pixel values
assert torch.allclose(lowerCamelCase , lowerCamelCase )
original_model.to(lowerCamelCase )
hf_model.to(lowerCamelCase )
with torch.no_grad():
if "opt" in model_name:
UpperCAmelCase__ = original_model({'image': original_pixel_values, 'text_input': ['']} ).logits
UpperCAmelCase__ = hf_model(lowerCamelCase , lowerCamelCase ).logits
else:
UpperCAmelCase__ = original_model(
{'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']} ).logits
UpperCAmelCase__ = input_ids.masked_fill(input_ids == tokenizer.pad_token_id , -1_0_0 )
UpperCAmelCase__ = hf_model(lowerCamelCase , lowerCamelCase , labels=lowerCamelCase ).logits
assert original_logits.shape == logits.shape
print('First values of original logits:' , original_logits[0, :3, :3] )
print('First values of HF logits:' , logits[0, :3, :3] )
# assert values
if model_name == "blip2-flan-t5-xl":
UpperCAmelCase__ = torch.tensor(
[[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]] , device=lowerCamelCase )
assert torch.allclose(logits[0, :3, :3] , lowerCamelCase , atol=1e-4 )
elif model_name == "blip2-flan-t5-xl-coco":
UpperCAmelCase__ = torch.tensor(
[[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]] , device=lowerCamelCase )
else:
# cast to same type
UpperCAmelCase__ = logits.dtype
assert torch.allclose(original_logits.to(lowerCamelCase ) , lowerCamelCase , atol=1e-2 )
print('Looks ok!' )
print('Generating a caption...' )
UpperCAmelCase__ = ''
UpperCAmelCase__ = tokenizer(lowerCamelCase , return_tensors='pt' ).input_ids.to(lowerCamelCase )
UpperCAmelCase__ = original_model.generate({'image': original_pixel_values} )
UpperCAmelCase__ = hf_model.generate(
lowerCamelCase , lowerCamelCase , do_sample=lowerCamelCase , num_beams=5 , max_length=3_0 , min_length=1 , top_p=0.9 , repetition_penalty=1.0 , length_penalty=1.0 , temperature=1 , )
print('Original generation:' , lowerCamelCase )
UpperCAmelCase__ = input_ids.shape[1]
UpperCAmelCase__ = processor.batch_decode(outputs[:, prompt_length:] , skip_special_tokens=lowerCamelCase )
UpperCAmelCase__ = [text.strip() for text in output_text]
print('HF generation:' , lowerCamelCase )
if pytorch_dump_folder_path is not None:
processor.save_pretrained(lowerCamelCase )
hf_model.save_pretrained(lowerCamelCase )
if push_to_hub:
processor.push_to_hub(f'''nielsr/{model_name}''' )
hf_model.push_to_hub(f'''nielsr/{model_name}''' )
if __name__ == "__main__":
lowerCAmelCase__ : Union[str, Any] = argparse.ArgumentParser()
lowerCAmelCase__ : List[Any] = [
'blip2-opt-2.7b',
'blip2-opt-6.7b',
'blip2-opt-2.7b-coco',
'blip2-opt-6.7b-coco',
'blip2-flan-t5-xl',
'blip2-flan-t5-xl-coco',
'blip2-flan-t5-xxl',
]
parser.add_argument(
'--model_name',
default='blip2-opt-2.7b',
choices=choices,
type=str,
help='Path to hf config.json of model to convert',
)
parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
parser.add_argument(
'--push_to_hub',
action='store_true',
help='Whether to push the model and processor to the hub after converting',
)
lowerCAmelCase__ : List[Any] = parser.parse_args()
convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
| 632 | """simple docstring"""
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class snake_case ( ctypes.Structure ):
"""simple docstring"""
snake_case__ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25l' )
sys.stdout.flush()
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25h' )
sys.stdout.flush()
@contextmanager
def a_ ( ):
try:
hide_cursor()
yield
finally:
show_cursor()
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase = 5_0 ):
UpperCAmelCase__ = [[0] * 3 for _ in range(length + 1 )]
for row_length in range(length + 1 ):
for tile_length in range(2 , 5 ):
for tile_start in range(row_length - tile_length + 1 ):
different_colour_ways_number[row_length][tile_length - 2] += (
different_colour_ways_number[row_length - tile_start - tile_length][
tile_length - 2
]
+ 1
)
return sum(different_colour_ways_number[length] )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | """simple docstring"""
import inspect
import tempfile
from collections import OrderedDict, UserDict
from collections.abc import MutableMapping
from contextlib import ExitStack, contextmanager
from dataclasses import fields
from enum import Enum
from typing import Any, ContextManager, List, Tuple
import numpy as np
from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy
if is_flax_available():
import jax.numpy as jnp
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __get__( self : Dict ,lowerCamelCase__ : str ,lowerCamelCase__ : str=None ):
# See docs.python.org/3/howto/descriptor.html#properties
if obj is None:
return self
if self.fget is None:
raise AttributeError('unreadable attribute' )
UpperCAmelCase__ = '__cached_' + self.fget.__name__
UpperCAmelCase__ = getattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
if cached is None:
UpperCAmelCase__ = self.fget(lowerCamelCase__ )
setattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
return cached
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = val.lower()
if val in {"y", "yes", "t", "true", "on", "1"}:
return 1
if val in {"n", "no", "f", "false", "off", "0"}:
return 0
raise ValueError(f'''invalid truth value {val!r}''' )
def a_ ( lowerCamelCase ):
if is_torch_fx_proxy(lowerCamelCase ):
return True
if is_torch_available():
import torch
if isinstance(lowerCamelCase , torch.Tensor ):
return True
if is_tf_available():
import tensorflow as tf
if isinstance(lowerCamelCase , tf.Tensor ):
return True
if is_flax_available():
import jax.numpy as jnp
from jax.core import Tracer
if isinstance(lowerCamelCase , (jnp.ndarray, Tracer) ):
return True
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return _is_numpy(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.device )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_device(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
if isinstance(lowerCamelCase , lowerCamelCase ):
if hasattr(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = getattr(lowerCamelCase , lowerCamelCase )
else:
return False
return isinstance(lowerCamelCase , torch.dtype )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_dtype(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
return isinstance(lowerCamelCase , tf.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tensorflow(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
# the `is_symbolic_tensor` predicate is only available starting with TF 2.14
if hasattr(lowerCamelCase , 'is_symbolic_tensor' ):
return tf.is_symbolic_tensor(lowerCamelCase )
return type(lowerCamelCase ) == tf.Tensor
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tf_symbolic_tensor(lowerCamelCase )
def a_ ( lowerCamelCase ):
import jax.numpy as jnp # noqa: F811
return isinstance(lowerCamelCase , jnp.ndarray )
def a_ ( lowerCamelCase ):
return False if not is_flax_available() else _is_jax(lowerCamelCase )
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_py_obj(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return [to_py_obj(lowerCamelCase ) for o in obj]
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy().tolist()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().tolist()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase ).tolist()
elif isinstance(lowerCamelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays
return obj.tolist()
else:
return obj
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_numpy(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return np.array(lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().numpy()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase )
else:
return obj
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = fields(self )
# Safety and consistency checks
if not len(lowerCamelCase__ ):
raise ValueError(f'''{self.__class__.__name__} has no fields.''' )
if not all(field.default is None for field in class_fields[1:] ):
raise ValueError(f'''{self.__class__.__name__} should not have more than one required field.''' )
UpperCAmelCase__ = getattr(self ,class_fields[0].name )
UpperCAmelCase__ = all(getattr(self ,field.name ) is None for field in class_fields[1:] )
if other_fields_are_none and not is_tensor(lowerCamelCase__ ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = first_field.items()
UpperCAmelCase__ = True
else:
try:
UpperCAmelCase__ = iter(lowerCamelCase__ )
UpperCAmelCase__ = True
except TypeError:
UpperCAmelCase__ = False
# if we provided an iterator as first field and the iterator is a (key, value) iterator
# set the associated fields
if first_field_iterator:
for idx, element in enumerate(lowerCamelCase__ ):
if (
not isinstance(lowerCamelCase__ ,(list, tuple) )
or not len(lowerCamelCase__ ) == 2
or not isinstance(element[0] ,lowerCamelCase__ )
):
if idx == 0:
# If we do not have an iterator of key/values, set it as attribute
UpperCAmelCase__ = first_field
else:
# If we have a mixed iterator, raise an error
raise ValueError(
f'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' )
break
setattr(self ,element[0] ,element[1] )
if element[1] is not None:
UpperCAmelCase__ = element[1]
elif first_field is not None:
UpperCAmelCase__ = first_field
else:
for field in class_fields:
UpperCAmelCase__ = getattr(self ,field.name )
if v is not None:
UpperCAmelCase__ = v
def __delitem__( self : List[Any] ,*lowerCamelCase__ : Any ,**lowerCamelCase__ : Dict ):
raise Exception(f'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : str ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Optional[Any] ):
raise Exception(f'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : List[Any] ,*lowerCamelCase__ : int ,**lowerCamelCase__ : List[Any] ):
raise Exception(f'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : Optional[int] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Optional[int] ):
raise Exception(f'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' )
def __getitem__( self : Tuple ,lowerCamelCase__ : List[Any] ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = dict(self.items() )
return inner_dict[k]
else:
return self.to_tuple()[k]
def __setattr__( self : int ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if name in self.keys() and value is not None:
# Don't call self.__setitem__ to avoid recursion errors
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __setitem__( self : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : Any ):
# Will raise a KeyException if needed
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
# Don't call self.__setattr__ to avoid recursion errors
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
return tuple(self[k] for k in self.keys() )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
@classmethod
def __lowerCAmelCase ( cls : str ,lowerCamelCase__ : Optional[int] ):
raise ValueError(
f'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "longest"
snake_case__ = "max_length"
snake_case__ = "do_not_pad"
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "pt"
snake_case__ = "tf"
snake_case__ = "np"
snake_case__ = "jax"
class snake_case :
"""simple docstring"""
def __init__( self : int ,lowerCamelCase__ : List[ContextManager] ):
UpperCAmelCase__ = context_managers
UpperCAmelCase__ = ExitStack()
def __enter__( self : Union[str, Any] ):
for context_manager in self.context_managers:
self.stack.enter_context(lowerCamelCase__ )
def __exit__( self : List[Any] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Dict ):
self.stack.__exit__(*lowerCamelCase__ ,**lowerCamelCase__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
for p in signature.parameters:
if p == "return_loss" and signature.parameters[p].default is True:
return True
return False
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = model_class.__name__
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
if "QuestionAnswering" in model_name:
return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")]
else:
return [p for p in signature.parameters if "label" in p]
def a_ ( lowerCamelCase , lowerCamelCase = "" , lowerCamelCase = "." ):
def _flatten_dict(lowerCamelCase , lowerCamelCase="" , lowerCamelCase="." ):
for k, v in d.items():
UpperCAmelCase__ = str(lowerCamelCase ) + delimiter + str(lowerCamelCase ) if parent_key else k
if v and isinstance(lowerCamelCase , lowerCamelCase ):
yield from flatten_dict(lowerCamelCase , lowerCamelCase , delimiter=lowerCamelCase ).items()
else:
yield key, v
return dict(_flatten_dict(lowerCamelCase , lowerCamelCase , lowerCamelCase ) )
@contextmanager
def a_ ( lowerCamelCase , lowerCamelCase = False ):
if use_temp_dir:
with tempfile.TemporaryDirectory() as tmp_dir:
yield tmp_dir
else:
yield working_dir
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.transpose(lowerCamelCase , axes=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.T if axes is None else array.permute(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.transpose(lowerCamelCase , perm=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.transpose(lowerCamelCase , axes=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for transpose: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.reshape(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.reshape(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.reshape(lowerCamelCase , lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.reshape(lowerCamelCase , lowerCamelCase )
else:
raise ValueError(f'''Type not supported for reshape: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.squeeze() if axis is None else array.squeeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.squeeze(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for squeeze: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.expand_dims(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.unsqueeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.expand_dims(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.expand_dims(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.size(lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.numel()
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.size(lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return array.size
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
for key, value in auto_map.items():
if isinstance(lowerCamelCase , (tuple, list) ):
UpperCAmelCase__ = [f'''{repo_id}--{v}''' if (v is not None and '--' not in v) else v for v in value]
elif value is not None and "--" not in value:
UpperCAmelCase__ = f'''{repo_id}--{value}'''
return auto_map
def a_ ( lowerCamelCase ):
for base_class in inspect.getmro(lowerCamelCase ):
UpperCAmelCase__ = base_class.__module__
UpperCAmelCase__ = base_class.__name__
if module.startswith('tensorflow' ) or module.startswith('keras' ) or name == "TFPreTrainedModel":
return "tf"
elif module.startswith('torch' ) or name == "PreTrainedModel":
return "pt"
elif module.startswith('flax' ) or module.startswith('jax' ) or name == "FlaxPreTrainedModel":
return "flax"
else:
raise TypeError(f'''Could not infer framework from class {model_class}.''' )
| 632 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
lowerCAmelCase__ : int = {
'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
'tokenization_tapas': ['TapasTokenizer'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Union[str, Any] = [
'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TapasForMaskedLM',
'TapasForQuestionAnswering',
'TapasForSequenceClassification',
'TapasModel',
'TapasPreTrainedModel',
'load_tf_weights_in_tapas',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFTapasForMaskedLM',
'TFTapasForQuestionAnswering',
'TFTapasForSequenceClassification',
'TFTapasModel',
'TFTapasPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
from .tokenization_tapas import TapasTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tapas import (
TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
TapasPreTrainedModel,
load_tf_weights_in_tapas,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_tapas import (
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTapasForMaskedLM,
TFTapasForQuestionAnswering,
TFTapasForSequenceClassification,
TFTapasModel,
TFTapasPreTrainedModel,
)
else:
import sys
lowerCAmelCase__ : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | """simple docstring"""
import gc
import tempfile
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
lowerCAmelCase__ : Union[str, Any] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@nightly
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='numpy' ,).images
with tempfile.TemporaryDirectory() as tmpdirname:
pipe.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained(lowerCamelCase__ ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = generator.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,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 __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'cyberpunk 2077'
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.1_4_4_8, 0.1_6_1_9, 0.1_7_4_1, 0.1_0_8_6, 0.1_1_4_7, 0.1_1_2_8, 0.1_1_9_9, 0.1_1_6_5, 0.1_0_0_1] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = 'A painting of a squirrel eating a burger '
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.text_to_image(
prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_3_6_7, 0.3_1_6_9, 0.2_6_5_6, 0.3_8_7_0, 0.4_7_9_0, 0.3_7_9_6, 0.4_0_0_9, 0.4_8_7_8, 0.4_7_7_8] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = pipe.image_variation(lowerCamelCase__ ,generator=lowerCamelCase__ ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_0_7_6, 0.3_1_2_3, 0.3_2_8_4, 0.3_7_8_2, 0.3_7_7_0, 0.3_8_9_4, 0.4_2_9_7, 0.4_3_3_1, 0.4_4_5_6] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
| 632 | 1 |
"""simple docstring"""
from typing import List, Optional, Tuple, Union
import torch
from ...utils import logging, randn_tensor
from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline
lowerCAmelCase__ : int = logging.get_logger(__name__) # pylint: disable=invalid-name
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : List[str] ,lowerCamelCase__ : int ,lowerCamelCase__ : Any ):
super().__init__()
self.register_modules(unet=lowerCamelCase__ ,scheduler=lowerCamelCase__ )
@torch.no_grad()
def __call__( self : List[str] ,lowerCamelCase__ : int = 1 ,lowerCamelCase__ : int = 100 ,lowerCamelCase__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None ,lowerCamelCase__ : Optional[float] = None ,lowerCamelCase__ : bool = True ,):
if audio_length_in_s is None:
UpperCAmelCase__ = self.unet.config.sample_size / self.unet.config.sample_rate
UpperCAmelCase__ = audio_length_in_s * self.unet.config.sample_rate
UpperCAmelCase__ = 2 ** len(self.unet.up_blocks )
if sample_size < 3 * down_scale_factor:
raise ValueError(
f'''{audio_length_in_s} is too small. Make sure it\'s bigger or equal to'''
f''' {3 * down_scale_factor / self.unet.config.sample_rate}.''' )
UpperCAmelCase__ = int(lowerCamelCase__ )
if sample_size % down_scale_factor != 0:
UpperCAmelCase__ = (
(audio_length_in_s * self.unet.config.sample_rate) // down_scale_factor + 1
) * down_scale_factor
logger.info(
f'''{audio_length_in_s} is increased to {sample_size / self.unet.config.sample_rate} so that it can be handled'''
f''' by the model. It will be cut to {original_sample_size / self.unet.config.sample_rate} after the denoising'''
' process.' )
UpperCAmelCase__ = int(lowerCamelCase__ )
UpperCAmelCase__ = next(iter(self.unet.parameters() ) ).dtype
UpperCAmelCase__ = (batch_size, self.unet.config.in_channels, sample_size)
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ) and len(lowerCamelCase__ ) != batch_size:
raise ValueError(
f'''You have passed a list of generators of length {len(lowerCamelCase__ )}, but requested an effective batch'''
f''' size of {batch_size}. Make sure the batch size matches the length of the generators.''' )
UpperCAmelCase__ = randn_tensor(lowerCamelCase__ ,generator=lowerCamelCase__ ,device=self.device ,dtype=lowerCamelCase__ )
# set step values
self.scheduler.set_timesteps(lowerCamelCase__ ,device=audio.device )
UpperCAmelCase__ = self.scheduler.timesteps.to(lowerCamelCase__ )
for t in self.progress_bar(self.scheduler.timesteps ):
# 1. predict noise model_output
UpperCAmelCase__ = self.unet(lowerCamelCase__ ,lowerCamelCase__ ).sample
# 2. compute previous image: x_t -> t_t-1
UpperCAmelCase__ = self.scheduler.step(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = audio.clamp(-1 ,1 ).float().cpu().numpy()
UpperCAmelCase__ = audio[:, :, :original_sample_size]
if not return_dict:
return (audio,)
return AudioPipelineOutput(audios=lowerCamelCase__ )
| 632 | """simple docstring"""
from typing import Optional
import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin
from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]
@register_to_config
def __init__( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : int = 50_257 ,lowerCamelCase__ : int = 1_024 ,lowerCamelCase__ : int = 768 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "gelu_new" ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 1e-5 ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
super().__init__()
UpperCAmelCase__ = prefix_length
if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
raise ValueError(
f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
f''' `n_embd`: {n_embd} are not equal.''' )
UpperCAmelCase__ = prefix_inner_dim
UpperCAmelCase__ = prefix_hidden_dim
UpperCAmelCase__ = (
nn.Linear(self.prefix_inner_dim ,self.prefix_hidden_dim )
if self.prefix_hidden_dim is not None
else nn.Identity()
)
UpperCAmelCase__ = (
nn.Linear(self.prefix_hidden_dim ,lowerCamelCase__ ) if self.prefix_hidden_dim is not None else nn.Identity()
)
UpperCAmelCase__ = GPTaConfig(
vocab_size=lowerCamelCase__ ,n_positions=lowerCamelCase__ ,n_embd=lowerCamelCase__ ,n_layer=lowerCamelCase__ ,n_head=lowerCamelCase__ ,n_inner=lowerCamelCase__ ,activation_function=lowerCamelCase__ ,resid_pdrop=lowerCamelCase__ ,embd_pdrop=lowerCamelCase__ ,attn_pdrop=lowerCamelCase__ ,layer_norm_epsilon=lowerCamelCase__ ,initializer_range=lowerCamelCase__ ,scale_attn_weights=lowerCamelCase__ ,use_cache=lowerCamelCase__ ,scale_attn_by_inverse_layer_idx=lowerCamelCase__ ,reorder_and_upcast_attn=lowerCamelCase__ ,)
UpperCAmelCase__ = GPTaLMHeadModel(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : Optional[torch.Tensor] = None ,lowerCamelCase__ : Optional[torch.Tensor] = None ,):
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
UpperCAmelCase__ = self.encode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = self.decode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = torch.cat((prefix_embeds, embedding_text) ,dim=1 )
if labels is not None:
UpperCAmelCase__ = self.get_dummy_token(input_ids.shape[0] ,input_ids.device )
UpperCAmelCase__ = torch.cat((dummy_token, input_ids) ,dim=1 )
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ ,labels=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
if self.prefix_hidden_dim is not None:
return out, hidden
else:
return out
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : torch.device ):
return torch.zeros(lowerCamelCase__ ,self.prefix_length ,dtype=torch.intaa ,device=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[str] ):
return self.encode_prefix(lowerCamelCase__ )
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = torch.split(lowerCamelCase__ ,1 ,dim=0 )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for feature in features:
UpperCAmelCase__ = self.decode_prefix(feature.to(lowerCamelCase__ ) ) # back to the clip feature
# Only support beam search for now
UpperCAmelCase__ , UpperCAmelCase__ = self.generate_beam(
input_embeds=lowerCamelCase__ ,device=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
generated_tokens.append(output_tokens[0] )
generated_seq_lengths.append(seq_lengths[0] )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
return generated_tokens, generated_seq_lengths
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int = 5 ,lowerCamelCase__ : int = 67 ,lowerCamelCase__ : float = 1.0 ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = eos_token_id
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = torch.ones(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.int )
UpperCAmelCase__ = torch.zeros(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.bool )
if input_embeds is not None:
UpperCAmelCase__ = input_embeds
else:
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ )
UpperCAmelCase__ = outputs.logits
UpperCAmelCase__ = logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
UpperCAmelCase__ = logits.softmax(-1 ).log()
if scores is None:
UpperCAmelCase__ , UpperCAmelCase__ = logits.topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = generated.expand(lowerCamelCase__ ,*generated.shape[1:] )
UpperCAmelCase__ , UpperCAmelCase__ = next_tokens.permute(1 ,0 ), scores.squeeze(0 )
if tokens is None:
UpperCAmelCase__ = next_tokens
else:
UpperCAmelCase__ = tokens.expand(lowerCamelCase__ ,*tokens.shape[1:] )
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
else:
UpperCAmelCase__ = -float(np.inf )
UpperCAmelCase__ = 0
UpperCAmelCase__ = scores[:, None] + logits
seq_lengths[~is_stopped] += 1
UpperCAmelCase__ = scores_sum / seq_lengths[:, None]
UpperCAmelCase__ , UpperCAmelCase__ = scores_sum_average.view(-1 ).topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = next_tokens // scores_sum.shape[1]
UpperCAmelCase__ = seq_lengths[next_tokens_source]
UpperCAmelCase__ = next_tokens % scores_sum.shape[1]
UpperCAmelCase__ = next_tokens.unsqueeze(1 )
UpperCAmelCase__ = tokens[next_tokens_source]
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
UpperCAmelCase__ = generated[next_tokens_source]
UpperCAmelCase__ = scores_sum_average * seq_lengths
UpperCAmelCase__ = is_stopped[next_tokens_source]
UpperCAmelCase__ = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] ,1 ,-1 )
UpperCAmelCase__ = torch.cat((generated, next_token_embed) ,dim=1 )
UpperCAmelCase__ = is_stopped + next_tokens.eq(lowerCamelCase__ ).squeeze()
if is_stopped.all():
break
UpperCAmelCase__ = scores / seq_lengths
UpperCAmelCase__ = scores.argsort(descending=lowerCamelCase__ )
# tokens tensors are already padded to max_seq_length
UpperCAmelCase__ = [tokens[i] for i in order]
UpperCAmelCase__ = torch.stack(lowerCamelCase__ ,dim=0 )
UpperCAmelCase__ = torch.tensor([seq_lengths[i] for i in order] ,dtype=seq_lengths.dtype )
return output_texts, seq_lengths
| 632 | 1 |
"""simple docstring"""
import os
import warnings
from typing import List, Optional
from ...tokenization_utils_base import BatchEncoding
from ...utils import logging
from .configuration_rag import RagConfig
lowerCAmelCase__ : Optional[Any] = logging.get_logger(__name__)
class snake_case :
"""simple docstring"""
def __init__( self : Tuple ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = question_encoder
UpperCAmelCase__ = generator
UpperCAmelCase__ = self.question_encoder
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : Any ):
if os.path.isfile(lowerCamelCase__ ):
raise ValueError(f'''Provided path ({save_directory}) should be a directory, not a file''' )
os.makedirs(lowerCamelCase__ ,exist_ok=lowerCamelCase__ )
UpperCAmelCase__ = os.path.join(lowerCamelCase__ ,'question_encoder_tokenizer' )
UpperCAmelCase__ = os.path.join(lowerCamelCase__ ,'generator_tokenizer' )
self.question_encoder.save_pretrained(lowerCamelCase__ )
self.generator.save_pretrained(lowerCamelCase__ )
@classmethod
def __lowerCAmelCase ( cls : str ,lowerCamelCase__ : Optional[int] ,**lowerCamelCase__ : Tuple ):
# dynamically import AutoTokenizer
from ..auto.tokenization_auto import AutoTokenizer
UpperCAmelCase__ = kwargs.pop('config' ,lowerCamelCase__ )
if config is None:
UpperCAmelCase__ = RagConfig.from_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = AutoTokenizer.from_pretrained(
lowerCamelCase__ ,config=config.question_encoder ,subfolder='question_encoder_tokenizer' )
UpperCAmelCase__ = AutoTokenizer.from_pretrained(
lowerCamelCase__ ,config=config.generator ,subfolder='generator_tokenizer' )
return cls(question_encoder=lowerCamelCase__ ,generator=lowerCamelCase__ )
def __call__( self : List[Any] ,*lowerCamelCase__ : Union[str, Any] ,**lowerCamelCase__ : Tuple ):
return self.current_tokenizer(*lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ,*lowerCamelCase__ : Optional[Any] ,**lowerCamelCase__ : Union[str, Any] ):
return self.generator.batch_decode(*lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Any ):
return self.generator.decode(*lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.question_encoder
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = self.generator
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Optional[List[str]] = None ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "longest" ,lowerCamelCase__ : str = None ,lowerCamelCase__ : bool = True ,**lowerCamelCase__ : Optional[Any] ,):
warnings.warn(
'`prepare_seq2seq_batch` is deprecated and will be removed in version 5 of 🤗 Transformers. Use the '
'regular `__call__` method to prepare your inputs and the tokenizer under the `with_target_tokenizer` '
'context manager to prepare your targets. See the documentation of your specific tokenizer for more '
'details' ,lowerCamelCase__ ,)
if max_length is None:
UpperCAmelCase__ = self.current_tokenizer.model_max_length
UpperCAmelCase__ = self(
lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ,return_tensors=lowerCamelCase__ ,max_length=lowerCamelCase__ ,padding=lowerCamelCase__ ,truncation=lowerCamelCase__ ,**lowerCamelCase__ ,)
if tgt_texts is None:
return model_inputs
# Process tgt_texts
if max_target_length is None:
UpperCAmelCase__ = self.current_tokenizer.model_max_length
UpperCAmelCase__ = self(
text_target=lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ,return_tensors=lowerCamelCase__ ,padding=lowerCamelCase__ ,max_length=lowerCamelCase__ ,truncation=lowerCamelCase__ ,**lowerCamelCase__ ,)
UpperCAmelCase__ = labels['input_ids']
return model_inputs
| 632 | """simple docstring"""
import argparse
import os
import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints
from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
lowerCAmelCase__ : str = 'base_with_context'
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['token_embedder']['embedding'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['input_proj']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['continuous_inputs_projection']['kernel'].T ) )
for lyr_num, lyr in enumerate(model.decoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_self_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_0']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['self_attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['MultiHeadDotProductAttention_0']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_cross_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_1']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['decoder_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['spec_out_dense']['kernel'].T ) )
return model
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = checkpoints.load_tax_checkpoint(args.checkpoint_path )
UpperCAmelCase__ = jnp.tree_util.tree_map(onp.array , lowerCamelCase )
UpperCAmelCase__ = [
'from __gin__ import dynamic_registration',
'from music_spectrogram_diffusion.models.diffusion import diffusion_utils',
'diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0',
'diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()',
]
UpperCAmelCase__ = os.path.join(args.checkpoint_path , '..' , 'config.gin' )
UpperCAmelCase__ = inference.parse_training_gin_file(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = inference.InferenceModel(args.checkpoint_path , lowerCamelCase )
UpperCAmelCase__ = DDPMScheduler(beta_schedule='squaredcos_cap_v2' , variance_type='fixed_large' )
UpperCAmelCase__ = SpectrogramNotesEncoder(
max_length=synth_model.sequence_length['inputs'] , vocab_size=synth_model.model.module.config.vocab_size , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = SpectrogramContEncoder(
input_dims=synth_model.audio_codec.n_dims , targets_context_length=synth_model.sequence_length['targets_context'] , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = TaFilmDecoder(
input_dims=synth_model.audio_codec.n_dims , targets_length=synth_model.sequence_length['targets_context'] , max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time , d_model=synth_model.model.module.config.emb_dim , num_layers=synth_model.model.module.config.num_decoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , dropout_rate=synth_model.model.module.config.dropout_rate , )
UpperCAmelCase__ = load_notes_encoder(ta_checkpoint['target']['token_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_continuous_encoder(ta_checkpoint['target']['continuous_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_decoder(ta_checkpoint['target']['decoder'] , lowerCamelCase )
UpperCAmelCase__ = OnnxRuntimeModel.from_pretrained('kashif/soundstream_mel_decoder' )
UpperCAmelCase__ = SpectrogramDiffusionPipeline(
notes_encoder=lowerCamelCase , continuous_encoder=lowerCamelCase , decoder=lowerCamelCase , scheduler=lowerCamelCase , melgan=lowerCamelCase , )
if args.save:
pipe.save_pretrained(args.output_path )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
parser.add_argument('--output_path', default=None, type=str, required=True, help='Path to the converted model.')
parser.add_argument(
'--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
)
parser.add_argument(
'--checkpoint_path',
default=F"""{MODEL}/checkpoint_500000""",
type=str,
required=False,
help='Path to the original jax model checkpoint.',
)
lowerCAmelCase__ : List[str] = parser.parse_args()
main(args)
| 632 | 1 |
"""simple docstring"""
from collections import OrderedDict
from typing import Mapping
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
lowerCAmelCase__ : Tuple = logging.get_logger(__name__)
lowerCAmelCase__ : List[Any] = {
'xlm-roberta-base': 'https://huggingface.co/xlm-roberta-base/resolve/main/config.json',
'xlm-roberta-large': 'https://huggingface.co/xlm-roberta-large/resolve/main/config.json',
'xlm-roberta-large-finetuned-conll02-dutch': (
'https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/config.json'
),
'xlm-roberta-large-finetuned-conll02-spanish': (
'https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/config.json'
),
'xlm-roberta-large-finetuned-conll03-english': (
'https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/config.json'
),
'xlm-roberta-large-finetuned-conll03-german': (
'https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/config.json'
),
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "xlm-roberta"
def __init__( self : Optional[Any] ,lowerCamelCase__ : str=30_522 ,lowerCamelCase__ : Optional[int]=768 ,lowerCamelCase__ : List[Any]=12 ,lowerCamelCase__ : Tuple=12 ,lowerCamelCase__ : int=3_072 ,lowerCamelCase__ : Any="gelu" ,lowerCamelCase__ : Optional[int]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : Any=512 ,lowerCamelCase__ : List[str]=2 ,lowerCamelCase__ : Any=0.0_2 ,lowerCamelCase__ : Any=1e-12 ,lowerCamelCase__ : List[str]=1 ,lowerCamelCase__ : List[str]=0 ,lowerCamelCase__ : Dict=2 ,lowerCamelCase__ : Dict="absolute" ,lowerCamelCase__ : Tuple=True ,lowerCamelCase__ : Dict=None ,**lowerCamelCase__ : Tuple ,):
super().__init__(pad_token_id=lowerCamelCase__ ,bos_token_id=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_dropout_prob
UpperCAmelCase__ = attention_probs_dropout_prob
UpperCAmelCase__ = max_position_embeddings
UpperCAmelCase__ = type_vocab_size
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = layer_norm_eps
UpperCAmelCase__ = position_embedding_type
UpperCAmelCase__ = use_cache
UpperCAmelCase__ = classifier_dropout
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
@property
def __lowerCAmelCase ( self : int ):
if self.task == "multiple-choice":
UpperCAmelCase__ = {0: 'batch', 1: 'choice', 2: 'sequence'}
else:
UpperCAmelCase__ = {0: 'batch', 1: 'sequence'}
return OrderedDict(
[
('input_ids', dynamic_axis),
('attention_mask', dynamic_axis),
] )
| 632 | """simple docstring"""
import socket
def a_ ( ):
UpperCAmelCase__ = socket.socket(socket.AF_INET , socket.SOCK_STREAM )
UpperCAmelCase__ = socket.gethostname()
UpperCAmelCase__ = 1_2_3_1_2
sock.connect((host, port) )
sock.send(b'Hello server!' )
with open('Received_file' , 'wb' ) as out_file:
print('File opened' )
print('Receiving data...' )
while True:
UpperCAmelCase__ = sock.recv(1_0_2_4 )
if not data:
break
out_file.write(lowerCamelCase )
print('Successfully received the file' )
sock.close()
print('Connection closed' )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
import importlib
import os
import sys
# This is required to make the module import works (when the python process is running from the root of the repo)
sys.path.append('.')
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = test_file.split(os.path.sep )
if components[0:2] != ["tests", "models"]:
raise ValueError(
'`test_file` should start with `tests/models/` (with `/` being the OS specific path separator). Got '
f'''{test_file} instead.''' )
UpperCAmelCase__ = components[-1]
if not test_fn.endswith('py' ):
raise ValueError(f'''`test_file` should be a python file. Got {test_fn} instead.''' )
if not test_fn.startswith('test_modeling_' ):
raise ValueError(
f'''`test_file` should point to a file name of the form `test_modeling_*.py`. Got {test_fn} instead.''' )
UpperCAmelCase__ = components[:-1] + [test_fn.replace('.py' , '' )]
UpperCAmelCase__ = '.'.join(lowerCamelCase )
return test_module_path
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_module_path(lowerCamelCase )
UpperCAmelCase__ = importlib.import_module(lowerCamelCase )
return test_module
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
UpperCAmelCase__ = get_test_module(lowerCamelCase )
for attr in dir(lowerCamelCase ):
if attr.endswith('ModelTester' ):
tester_classes.append(getattr(lowerCamelCase , lowerCamelCase ) )
# sort with class names
return sorted(lowerCamelCase , key=lambda lowerCamelCase : x.__name__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
UpperCAmelCase__ = get_test_module(lowerCamelCase )
for attr in dir(lowerCamelCase ):
UpperCAmelCase__ = getattr(lowerCamelCase , lowerCamelCase )
# (TF/Flax)ModelTesterMixin is also an attribute in specific model test module. Let's exclude them by checking
# `all_model_classes` is not empty (which also excludes other special classes).
UpperCAmelCase__ = getattr(lowerCamelCase , 'all_model_classes' , [] )
if len(lowerCamelCase ) > 0:
test_classes.append(lowerCamelCase )
# sort with class names
return sorted(lowerCamelCase , key=lambda lowerCamelCase : x.__name__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_test_classes(lowerCamelCase )
UpperCAmelCase__ = set()
for test_class in test_classes:
model_classes.update(test_class.all_model_classes )
# sort with class names
return sorted(lowerCamelCase , key=lambda lowerCamelCase : x.__name__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = test_class()
if hasattr(lowerCamelCase , 'setUp' ):
test.setUp()
UpperCAmelCase__ = None
if hasattr(lowerCamelCase , 'model_tester' ):
# `(TF/Flax)ModelTesterMixin` has this attribute default to `None`. Let's skip this case.
if test.model_tester is not None:
UpperCAmelCase__ = test.model_tester.__class__
return model_tester
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_test_classes(lowerCamelCase )
UpperCAmelCase__ = []
for test_class in test_classes:
if model_class in test_class.all_model_classes:
target_test_classes.append(lowerCamelCase )
# sort with class names
return sorted(lowerCamelCase , key=lambda lowerCamelCase : x.__name__ )
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_test_classes_for_model(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = []
for test_class in test_classes:
UpperCAmelCase__ = get_model_tester_from_test_class(lowerCamelCase )
if tester_class is not None:
tester_classes.append(lowerCamelCase )
# sort with class names
return sorted(lowerCamelCase , key=lambda lowerCamelCase : x.__name__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_test_classes(lowerCamelCase )
UpperCAmelCase__ = {test_class: get_model_tester_from_test_class(lowerCamelCase ) for test_class in test_classes}
return test_tester_mapping
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_model_classes(lowerCamelCase )
UpperCAmelCase__ = {
model_class: get_test_classes_for_model(lowerCamelCase , lowerCamelCase ) for model_class in model_classes
}
return model_test_mapping
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_model_classes(lowerCamelCase )
UpperCAmelCase__ = {
model_class: get_tester_classes_for_model(lowerCamelCase , lowerCamelCase ) for model_class in model_classes
}
return model_to_tester_mapping
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , lowerCamelCase ):
return o
elif isinstance(lowerCamelCase , lowerCamelCase ):
return o.__name__
elif isinstance(lowerCamelCase , (list, tuple) ):
return [to_json(lowerCamelCase ) for x in o]
elif isinstance(lowerCamelCase , lowerCamelCase ):
return {to_json(lowerCamelCase ): to_json(lowerCamelCase ) for k, v in o.items()}
else:
return o
| 632 | """simple docstring"""
from __future__ import annotations
class snake_case :
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : list[list[int]] ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = 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
UpperCAmelCase__ = rows
else:
UpperCAmelCase__ = []
def __lowerCAmelCase ( self : Union[str, Any] ):
return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]
@property
def __lowerCAmelCase ( self : str ):
return len(self.rows )
@property
def __lowerCAmelCase ( self : List[Any] ):
return len(self.rows[0] )
@property
def __lowerCAmelCase ( self : Any ):
return (self.num_rows, self.num_columns)
@property
def __lowerCAmelCase ( self : Optional[int] ):
return self.order[0] == self.order[1]
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = [
[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 __lowerCAmelCase ( self : str ):
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 __lowerCAmelCase ( self : List[str] ):
return bool(self.determinant() )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
UpperCAmelCase__ = [
[
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 __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if (row + column) % 2 == 0:
return self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
return -1 * self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
return Matrix(
[
[self.get_minor(lowerCamelCase__ ,lowerCamelCase__ ) for column in range(self.num_columns )]
for row in range(self.num_rows )
] )
def __lowerCAmelCase ( self : int ):
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 __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = [
[self.cofactors().rows[column][row] for column in range(self.num_columns )]
for row in range(self.num_rows )
]
return Matrix(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = 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 : Optional[Any] ):
return str(self.rows )
def __str__( self : List[str] ):
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 __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = self.rows[0:position] + [row] + self.rows[position:]
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = [self.rows[i] + [column[i]] for i in range(self.num_rows )]
else:
UpperCAmelCase__ = [
self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
for i in range(self.num_rows )
]
def __eq__( self : List[Any] ,lowerCamelCase__ : object ):
if not isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
return NotImplemented
return self.rows == other.rows
def __ne__( self : Any ,lowerCamelCase__ : object ):
return not self == other
def __neg__( self : Dict ):
return self * -1
def __add__( self : str ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix | int | float ):
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 ):
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' )
UpperCAmelCase__ = self
for _ in range(other - 1 ):
result *= self
return result
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
return sum(row[i] * column[i] for i in range(len(lowerCamelCase__ ) ) )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = len(lowerCamelCase )
print('The following activities are selected:' )
# The first activity is always selected
UpperCAmelCase__ = 0
print(lowerCamelCase , end=',' )
# Consider rest of the activities
for j in range(lowerCamelCase ):
# If this activity has start time greater than
# or equal to the finish time of previously
# selected activity, then select it
if start[j] >= finish[i]:
print(lowerCamelCase , end=',' )
UpperCAmelCase__ = j
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCAmelCase__ : Optional[int] = [1, 3, 0, 5, 8, 5]
lowerCAmelCase__ : int = [2, 4, 6, 7, 9, 9]
print_max_activities(start, finish)
| 632 | """simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
lowerCAmelCase__ : int = {
'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
'tokenization_tapas': ['TapasTokenizer'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Union[str, Any] = [
'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TapasForMaskedLM',
'TapasForQuestionAnswering',
'TapasForSequenceClassification',
'TapasModel',
'TapasPreTrainedModel',
'load_tf_weights_in_tapas',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFTapasForMaskedLM',
'TFTapasForQuestionAnswering',
'TFTapasForSequenceClassification',
'TFTapasModel',
'TFTapasPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
from .tokenization_tapas import TapasTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tapas import (
TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
TapasPreTrainedModel,
load_tf_weights_in_tapas,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_tapas import (
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTapasForMaskedLM,
TFTapasForQuestionAnswering,
TFTapasForSequenceClassification,
TFTapasModel,
TFTapasPreTrainedModel,
)
else:
import sys
lowerCAmelCase__ : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | 1 |
"""simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | """simple docstring"""
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device
lowerCAmelCase__ : Optional[int] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@slow
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe(
image=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.0_4_4_1, 0.0_4_6_9, 0.0_5_0_7, 0.0_5_7_5, 0.0_6_3_2, 0.0_6_5_0, 0.0_8_6_5, 0.0_9_0_9, 0.0_9_4_5] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 632 | 1 |
"""simple docstring"""
from __future__ import annotations
# This is the precision for this function which can be altered.
# It is recommended for users to keep this number greater than or equal to 10.
lowerCAmelCase__ : str = 10
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for i in range(lowerCamelCase , lowerCamelCase ):
if array[i] == target:
return i
return -1
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = 0
UpperCAmelCase__ = len(lowerCamelCase )
while left <= right:
if right - left < precision:
return lin_search(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = (left + right) // 3 + 1
UpperCAmelCase__ = 2 * (left + right) // 3 + 1
if array[one_third] == target:
return one_third
elif array[two_third] == target:
return two_third
elif target < array[one_third]:
UpperCAmelCase__ = one_third - 1
elif array[two_third] < target:
UpperCAmelCase__ = two_third + 1
else:
UpperCAmelCase__ = one_third + 1
UpperCAmelCase__ = two_third - 1
else:
return -1
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if left < right:
if right - left < precision:
return lin_search(lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = (left + right) // 3 + 1
UpperCAmelCase__ = 2 * (left + right) // 3 + 1
if array[one_third] == target:
return one_third
elif array[two_third] == target:
return two_third
elif target < array[one_third]:
return rec_ternary_search(lowerCamelCase , one_third - 1 , lowerCamelCase , lowerCamelCase )
elif array[two_third] < target:
return rec_ternary_search(two_third + 1 , lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
return rec_ternary_search(one_third + 1 , two_third - 1 , lowerCamelCase , lowerCamelCase )
else:
return -1
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCAmelCase__ : Union[str, Any] = input('Enter numbers separated by comma:\n').strip()
lowerCAmelCase__ : int = [int(item.strip()) for item in user_input.split(',')]
assert collection == sorted(collection), F"List must be ordered.\n{collection}."
lowerCAmelCase__ : List[Any] = int(input('Enter the number to be found in the list:\n').strip())
lowerCAmelCase__ : str = ite_ternary_search(collection, target)
lowerCAmelCase__ : Any = rec_ternary_search(0, len(collection) - 1, collection, target)
if resulta != -1:
print(F"""Iterative search: {target} found at positions: {resulta}""")
print(F"""Recursive search: {target} found at positions: {resulta}""")
else:
print('Not found')
| 632 | """simple docstring"""
from __future__ import annotations
from math import ceil, floor, sqrt
def a_ ( lowerCamelCase = 2_0_0_0_0_0_0 ):
UpperCAmelCase__ = [0]
UpperCAmelCase__ = 42
for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ):
triangle_numbers.append(triangle_numbers[-1] + idx )
# we want this to be as close as possible to target
UpperCAmelCase__ = 0
# the area corresponding to the grid that gives the product closest to target
UpperCAmelCase__ = 0
# an estimate of b, using the quadratic formula
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the triangle number corresponding to b_floor
UpperCAmelCase__ = 42
# the triangle number corresponding to b_ceil
UpperCAmelCase__ = 42
for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ):
UpperCAmelCase__ = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2
UpperCAmelCase__ = floor(lowerCamelCase )
UpperCAmelCase__ = ceil(lowerCamelCase )
UpperCAmelCase__ = triangle_numbers[b_floor]
UpperCAmelCase__ = triangle_numbers[b_ceil]
if abs(target - triangle_b_first_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_first_guess * triangle_a
UpperCAmelCase__ = idx_a * b_floor
if abs(target - triangle_b_second_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_second_guess * triangle_a
UpperCAmelCase__ = idx_a * b_ceil
return area
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
lowerCAmelCase__ : str = frozenset(
[
'prompt',
'height',
'width',
'guidance_scale',
'negative_prompt',
'prompt_embeds',
'negative_prompt_embeds',
'cross_attention_kwargs',
]
)
lowerCAmelCase__ : List[str] = frozenset(['prompt', 'negative_prompt'])
lowerCAmelCase__ : str = frozenset([])
lowerCAmelCase__ : Union[str, Any] = frozenset(['image'])
lowerCAmelCase__ : Any = frozenset(
[
'image',
'height',
'width',
'guidance_scale',
]
)
lowerCAmelCase__ : Optional[Any] = frozenset(['image'])
lowerCAmelCase__ : Union[str, Any] = frozenset(
[
'prompt',
'image',
'height',
'width',
'guidance_scale',
'negative_prompt',
'prompt_embeds',
'negative_prompt_embeds',
]
)
lowerCAmelCase__ : Dict = frozenset(['prompt', 'image', 'negative_prompt'])
lowerCAmelCase__ : List[str] = frozenset(
[
# Text guided image variation with an image mask
'prompt',
'image',
'mask_image',
'height',
'width',
'guidance_scale',
'negative_prompt',
'prompt_embeds',
'negative_prompt_embeds',
]
)
lowerCAmelCase__ : Tuple = frozenset(['prompt', 'image', 'mask_image', 'negative_prompt'])
lowerCAmelCase__ : List[Any] = frozenset(
[
# image variation with an image mask
'image',
'mask_image',
'height',
'width',
'guidance_scale',
]
)
lowerCAmelCase__ : Union[str, Any] = frozenset(['image', 'mask_image'])
lowerCAmelCase__ : int = frozenset(
[
'example_image',
'image',
'mask_image',
'height',
'width',
'guidance_scale',
]
)
lowerCAmelCase__ : Optional[int] = frozenset(['example_image', 'image', 'mask_image'])
lowerCAmelCase__ : str = frozenset(['class_labels'])
lowerCAmelCase__ : Dict = frozenset(['class_labels'])
lowerCAmelCase__ : Optional[Any] = frozenset(['batch_size'])
lowerCAmelCase__ : Optional[int] = frozenset([])
lowerCAmelCase__ : Optional[Any] = frozenset(['batch_size'])
lowerCAmelCase__ : int = frozenset([])
lowerCAmelCase__ : str = frozenset(
[
'prompt',
'audio_length_in_s',
'guidance_scale',
'negative_prompt',
'prompt_embeds',
'negative_prompt_embeds',
'cross_attention_kwargs',
]
)
lowerCAmelCase__ : List[Any] = frozenset(['prompt', 'negative_prompt'])
lowerCAmelCase__ : str = frozenset(['input_tokens'])
lowerCAmelCase__ : str = frozenset(['input_tokens'])
| 632 | """simple docstring"""
import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple
import torch
from audiocraft.models import MusicGen
from transformers import (
AutoFeatureExtractor,
AutoTokenizer,
EncodecModel,
MusicgenDecoderConfig,
MusicgenForConditionalGeneration,
MusicgenProcessor,
TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging
logging.set_verbosity_info()
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[Any] = ['model.decoder.embed_positions.weights']
def a_ ( lowerCamelCase ):
if "emb" in name:
UpperCAmelCase__ = name.replace('emb' , 'model.decoder.embed_tokens' )
if "transformer" in name:
UpperCAmelCase__ = name.replace('transformer' , 'model.decoder' )
if "cross_attention" in name:
UpperCAmelCase__ = name.replace('cross_attention' , 'encoder_attn' )
if "linear1" in name:
UpperCAmelCase__ = name.replace('linear1' , 'fc1' )
if "linear2" in name:
UpperCAmelCase__ = name.replace('linear2' , 'fc2' )
if "norm1" in name:
UpperCAmelCase__ = name.replace('norm1' , 'self_attn_layer_norm' )
if "norm_cross" in name:
UpperCAmelCase__ = name.replace('norm_cross' , 'encoder_attn_layer_norm' )
if "norm2" in name:
UpperCAmelCase__ = name.replace('norm2' , 'final_layer_norm' )
if "out_norm" in name:
UpperCAmelCase__ = name.replace('out_norm' , 'model.decoder.layer_norm' )
if "linears" in name:
UpperCAmelCase__ = name.replace('linears' , 'lm_heads' )
if "condition_provider.conditioners.description.output_proj" in name:
UpperCAmelCase__ = name.replace('condition_provider.conditioners.description.output_proj' , 'enc_to_dec_proj' )
return name
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(state_dict.keys() )
UpperCAmelCase__ = {}
for key in keys:
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
UpperCAmelCase__ = rename_keys(lowerCamelCase )
if "in_proj_weight" in key:
# split fused qkv proj
UpperCAmelCase__ = val[:hidden_size, :]
UpperCAmelCase__ = val[hidden_size : 2 * hidden_size, :]
UpperCAmelCase__ = val[-hidden_size:, :]
elif "enc_to_dec_proj" in key:
UpperCAmelCase__ = val
else:
UpperCAmelCase__ = val
return state_dict, enc_dec_proj_state_dict
def a_ ( lowerCamelCase ):
if checkpoint == "small":
# default config values
UpperCAmelCase__ = 1_0_2_4
UpperCAmelCase__ = 2_4
UpperCAmelCase__ = 1_6
elif checkpoint == "medium":
UpperCAmelCase__ = 1_5_3_6
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 2_4
elif checkpoint == "large":
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 3_2
else:
raise ValueError(f'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' )
UpperCAmelCase__ = MusicgenDecoderConfig(
hidden_size=lowerCamelCase , ffn_dim=hidden_size * 4 , num_hidden_layers=lowerCamelCase , num_attention_heads=lowerCamelCase , )
return config
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase="cpu" ):
UpperCAmelCase__ = MusicGen.get_pretrained(lowerCamelCase , device=lowerCamelCase )
UpperCAmelCase__ = decoder_config_from_checkpoint(lowerCamelCase )
UpperCAmelCase__ = fairseq_model.lm.state_dict()
UpperCAmelCase__ , UpperCAmelCase__ = rename_state_dict(
lowerCamelCase , hidden_size=decoder_config.hidden_size )
UpperCAmelCase__ = TaEncoderModel.from_pretrained('t5-base' )
UpperCAmelCase__ = EncodecModel.from_pretrained('facebook/encodec_32khz' )
UpperCAmelCase__ = MusicgenForCausalLM(lowerCamelCase ).eval()
# load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
UpperCAmelCase__ , UpperCAmelCase__ = decoder.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
for key in missing_keys.copy():
if key.startswith(('text_encoder', 'audio_encoder') ) or key in EXPECTED_MISSING_KEYS:
missing_keys.remove(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Missing key(s) in state_dict: {missing_keys}''' )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Unexpected key(s) in state_dict: {unexpected_keys}''' )
# init the composite model
UpperCAmelCase__ = MusicgenForConditionalGeneration(text_encoder=lowerCamelCase , audio_encoder=lowerCamelCase , decoder=lowerCamelCase )
# load the pre-trained enc-dec projection (from the decoder state dict)
model.enc_to_dec_proj.load_state_dict(lowerCamelCase )
# check we can do a forward pass
UpperCAmelCase__ = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 )
UpperCAmelCase__ = input_ids.reshape(2 * 4 , -1 )
with torch.no_grad():
UpperCAmelCase__ = model(input_ids=lowerCamelCase , decoder_input_ids=lowerCamelCase ).logits
if logits.shape != (8, 1, 2_0_4_8):
raise ValueError('Incorrect shape for logits' )
# now construct the processor
UpperCAmelCase__ = AutoTokenizer.from_pretrained('t5-base' )
UpperCAmelCase__ = AutoFeatureExtractor.from_pretrained('facebook/encodec_32khz' , padding_side='left' )
UpperCAmelCase__ = MusicgenProcessor(feature_extractor=lowerCamelCase , tokenizer=lowerCamelCase )
# set the appropriate bos/pad token ids
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 2_0_4_8
# set other default generation config params
UpperCAmelCase__ = int(3_0 * audio_encoder.config.frame_rate )
UpperCAmelCase__ = True
UpperCAmelCase__ = 3.0
if pytorch_dump_folder is not None:
Path(lowerCamelCase ).mkdir(exist_ok=lowerCamelCase )
logger.info(f'''Saving model {checkpoint} to {pytorch_dump_folder}''' )
model.save_pretrained(lowerCamelCase )
processor.save_pretrained(lowerCamelCase )
if repo_id:
logger.info(f'''Pushing model {checkpoint} to {repo_id}''' )
model.push_to_hub(lowerCamelCase )
processor.push_to_hub(lowerCamelCase )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--checkpoint',
default='small',
type=str,
help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
)
parser.add_argument(
'--pytorch_dump_folder',
required=True,
default=None,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
)
parser.add_argument(
'--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
)
lowerCAmelCase__ : List[str] = parser.parse_args()
convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase ):
if not isinstance(lowerCamelCase , lowerCamelCase ) or number < 0:
raise ValueError('Input must be a non-negative integer' )
UpperCAmelCase__ = 0
while number:
# This way we arrive at next set bit (next 1) instead of looping
# through each bit and checking for 1s hence the
# loop won't run 32 times it will only run the number of `1` times
number &= number - 1
count += 1
return count
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | """simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import json
import os
from collections import Counter
import torch
import torchvision
import torchvision.transforms as transforms
from PIL import Image
from torch import nn
from torch.utils.data import Dataset
lowerCAmelCase__ : Tuple = {1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (2, 2), 5: (5, 1), 6: (3, 2), 7: (7, 1), 8: (4, 2), 9: (3, 3)}
class snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : List[str] ,lowerCamelCase__ : Union[str, Any] ):
super().__init__()
UpperCAmelCase__ = torchvision.models.resnetaaa(pretrained=lowerCamelCase__ )
UpperCAmelCase__ = list(model.children() )[:-2]
UpperCAmelCase__ = nn.Sequential(*lowerCamelCase__ )
UpperCAmelCase__ = nn.AdaptiveAvgPoolad(POOLING_BREAKDOWN[args.num_image_embeds] )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str ):
# Bx3x224x224 -> Bx2048x7x7 -> Bx2048xN -> BxNx2048
UpperCAmelCase__ = self.pool(self.model(lowerCamelCase__ ) )
UpperCAmelCase__ = torch.flatten(lowerCamelCase__ ,start_dim=2 )
UpperCAmelCase__ = out.transpose(1 ,2 ).contiguous()
return out # BxNx2048
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : Tuple ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : str ,lowerCamelCase__ : Any ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Any ):
UpperCAmelCase__ = [json.loads(lowerCamelCase__ ) for l in open(lowerCamelCase__ )]
UpperCAmelCase__ = os.path.dirname(lowerCamelCase__ )
UpperCAmelCase__ = tokenizer
UpperCAmelCase__ = labels
UpperCAmelCase__ = len(lowerCamelCase__ )
UpperCAmelCase__ = max_seq_length
UpperCAmelCase__ = transforms
def __len__( self : Optional[Any] ):
return len(self.data )
def __getitem__( self : Tuple ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = torch.LongTensor(self.tokenizer.encode(self.data[index]['text'] ,add_special_tokens=lowerCamelCase__ ) )
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = sentence[0], sentence[1:-1], sentence[-1]
UpperCAmelCase__ = sentence[: self.max_seq_length]
UpperCAmelCase__ = torch.zeros(self.n_classes )
UpperCAmelCase__ = 1
UpperCAmelCase__ = Image.open(os.path.join(self.data_dir ,self.data[index]['img'] ) ).convert('RGB' )
UpperCAmelCase__ = self.transforms(lowerCamelCase__ )
return {
"image_start_token": start_token,
"image_end_token": end_token,
"sentence": sentence,
"image": image,
"label": label,
}
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = Counter()
for row in self.data:
label_freqs.update(row['label'] )
return label_freqs
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = [len(row['sentence'] ) for row in batch]
UpperCAmelCase__ , UpperCAmelCase__ = len(lowerCamelCase ), max(lowerCamelCase )
UpperCAmelCase__ = torch.zeros(lowerCamelCase , lowerCamelCase , dtype=torch.long )
UpperCAmelCase__ = torch.zeros(lowerCamelCase , lowerCamelCase , dtype=torch.long )
for i_batch, (input_row, length) in enumerate(zip(lowerCamelCase , lowerCamelCase ) ):
UpperCAmelCase__ = input_row['sentence']
UpperCAmelCase__ = 1
UpperCAmelCase__ = torch.stack([row['image'] for row in batch] )
UpperCAmelCase__ = torch.stack([row['label'] for row in batch] )
UpperCAmelCase__ = torch.stack([row['image_start_token'] for row in batch] )
UpperCAmelCase__ = torch.stack([row['image_end_token'] for row in batch] )
return text_tensor, mask_tensor, img_tensor, img_start_token, img_end_token, tgt_tensor
def a_ ( ):
return [
"Crime",
"Drama",
"Thriller",
"Action",
"Comedy",
"Romance",
"Documentary",
"Short",
"Mystery",
"History",
"Family",
"Adventure",
"Fantasy",
"Sci-Fi",
"Western",
"Horror",
"Sport",
"War",
"Music",
"Musical",
"Animation",
"Biography",
"Film-Noir",
]
def a_ ( ):
return transforms.Compose(
[
transforms.Resize(2_5_6 ),
transforms.CenterCrop(2_2_4 ),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.46777044, 0.44531429, 0.40661017] , std=[0.12221994, 0.12145835, 0.14380469] , ),
] )
| 632 | """simple docstring"""
import random
class snake_case :
"""simple docstring"""
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : str ):
UpperCAmelCase__ = [ord(lowerCamelCase__ ) for i in text]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i in plain:
UpperCAmelCase__ = random.randint(1 ,300 )
UpperCAmelCase__ = (i + k) * k
cipher.append(lowerCamelCase__ )
key.append(lowerCamelCase__ )
return cipher, key
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = int((cipher[i] - (key[i]) ** 2) / key[i] )
plain.append(chr(lowerCamelCase__ ) )
return "".join(lowerCamelCase__ )
if __name__ == "__main__":
lowerCAmelCase__ , lowerCAmelCase__ : Dict = Onepad().encrypt('Hello')
print(c, k)
print(Onepad().decrypt(c, k))
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase ):
# bit count represents no. of bits in the gray code
if bit_count < 0:
raise ValueError('The given input must be positive' )
# get the generated string sequence
UpperCAmelCase__ = gray_code_sequence_string(lowerCamelCase )
#
# convert them to integers
for i in range(len(lowerCamelCase ) ):
UpperCAmelCase__ = int(sequence[i] , 2 )
return sequence
def a_ ( lowerCamelCase ):
# The approach is a recursive one
# Base case achieved when either n = 0 or n=1
if bit_count == 0:
return ["0"]
if bit_count == 1:
return ["0", "1"]
UpperCAmelCase__ = 1 << bit_count # defines the length of the sequence
# 1<< n is equivalent to 2^n
# recursive answer will generate answer for n-1 bits
UpperCAmelCase__ = gray_code_sequence_string(bit_count - 1 )
UpperCAmelCase__ = []
# append 0 to first half of the smaller sequence generated
for i in range(seq_len // 2 ):
UpperCAmelCase__ = '0' + smaller_sequence[i]
sequence.append(lowerCamelCase )
# append 1 to second half ... start from the end of the list
for i in reversed(range(seq_len // 2 ) ):
UpperCAmelCase__ = '1' + smaller_sequence[i]
sequence.append(lowerCamelCase )
return sequence
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | """simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | 1 |
"""simple docstring"""
from argparse import ArgumentParser
from .env import EnvironmentCommand
def a_ ( ):
UpperCAmelCase__ = ArgumentParser('Diffusers CLI tool' , usage='diffusers-cli <command> [<args>]' )
UpperCAmelCase__ = parser.add_subparsers(help='diffusers-cli command helpers' )
# Register commands
EnvironmentCommand.register_subcommand(lowerCamelCase )
# Let's go
UpperCAmelCase__ = parser.parse_args()
if not hasattr(lowerCamelCase , 'func' ):
parser.print_help()
exit(1 )
# Run
UpperCAmelCase__ = args.func(lowerCamelCase )
service.run()
if __name__ == "__main__":
main()
| 632 | """simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | 1 |
"""simple docstring"""
import copy
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {
'Intel/dpt-large': 'https://huggingface.co/Intel/dpt-large/resolve/main/config.json',
# See all DPT models at https://huggingface.co/models?filter=dpt
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "dpt"
def __init__( self : List[str] ,lowerCamelCase__ : int=768 ,lowerCamelCase__ : List[Any]=12 ,lowerCamelCase__ : Union[str, Any]=12 ,lowerCamelCase__ : List[Any]=3_072 ,lowerCamelCase__ : List[str]="gelu" ,lowerCamelCase__ : Optional[Any]=0.0 ,lowerCamelCase__ : Union[str, Any]=0.0 ,lowerCamelCase__ : Any=0.0_2 ,lowerCamelCase__ : Dict=1e-12 ,lowerCamelCase__ : Union[str, Any]=384 ,lowerCamelCase__ : str=16 ,lowerCamelCase__ : int=3 ,lowerCamelCase__ : List[Any]=False ,lowerCamelCase__ : List[Any]=True ,lowerCamelCase__ : Optional[int]=[2, 5, 8, 11] ,lowerCamelCase__ : Union[str, Any]="project" ,lowerCamelCase__ : str=[4, 2, 1, 0.5] ,lowerCamelCase__ : str=[96, 192, 384, 768] ,lowerCamelCase__ : Optional[int]=256 ,lowerCamelCase__ : Tuple=-1 ,lowerCamelCase__ : Optional[Any]=False ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : Optional[int]=0.4 ,lowerCamelCase__ : Any=255 ,lowerCamelCase__ : List[Any]=0.1 ,lowerCamelCase__ : List[Any]=[1, 1_024, 24, 24] ,lowerCamelCase__ : Any=[0, 1] ,lowerCamelCase__ : List[Any]=None ,**lowerCamelCase__ : List[str] ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = is_hybrid
if self.is_hybrid:
if backbone_config is None:
logger.info('Initializing the config with a `BiT` backbone.' )
UpperCAmelCase__ = {
'global_padding': 'same',
'layer_type': 'bottleneck',
'depths': [3, 4, 9],
'out_features': ['stage1', 'stage2', 'stage3'],
'embedding_dynamic_padding': True,
}
UpperCAmelCase__ = BitConfig(**lowerCamelCase__ )
elif isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
logger.info('Initializing the config with a `BiT` backbone.' )
UpperCAmelCase__ = BitConfig(**lowerCamelCase__ )
elif isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = backbone_config
else:
raise ValueError(
f'''backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}.''' )
UpperCAmelCase__ = backbone_featmap_shape
UpperCAmelCase__ = neck_ignore_stages
if readout_type != "project":
raise ValueError('Readout type must be \'project\' when using `DPT-hybrid` mode.' )
else:
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = []
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = hidden_dropout_prob
UpperCAmelCase__ = attention_probs_dropout_prob
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = layer_norm_eps
UpperCAmelCase__ = image_size
UpperCAmelCase__ = patch_size
UpperCAmelCase__ = num_channels
UpperCAmelCase__ = qkv_bias
UpperCAmelCase__ = backbone_out_indices
if readout_type not in ["ignore", "add", "project"]:
raise ValueError('Readout_type must be one of [\'ignore\', \'add\', \'project\']' )
UpperCAmelCase__ = readout_type
UpperCAmelCase__ = reassemble_factors
UpperCAmelCase__ = neck_hidden_sizes
UpperCAmelCase__ = fusion_hidden_size
UpperCAmelCase__ = head_in_index
UpperCAmelCase__ = use_batch_norm_in_fusion_residual
# auxiliary head attributes (semantic segmentation)
UpperCAmelCase__ = use_auxiliary_head
UpperCAmelCase__ = auxiliary_loss_weight
UpperCAmelCase__ = semantic_loss_ignore_index
UpperCAmelCase__ = semantic_classifier_dropout
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = copy.deepcopy(self.__dict__ )
if output["backbone_config"] is not None:
UpperCAmelCase__ = self.backbone_config.to_dict()
UpperCAmelCase__ = self.__class__.model_type
return output
| 632 | """simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | 1 |
"""simple docstring"""
from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder
# @@protoc_insertion_point(imports)
lowerCAmelCase__ : int = _symbol_database.Default()
lowerCAmelCase__ : List[Any] = _descriptor_pool.Default().AddSerializedFile(
b'\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18 \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'
)
lowerCAmelCase__ : Union[str, Any] = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'sentencepiece_model_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
lowerCAmelCase__ : Union[str, Any] = None
lowerCAmelCase__ : int = b'H\003'
# (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
# _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
# _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
lowerCAmelCase__ : Optional[int] = 45
lowerCAmelCase__ : Any = 1_581
lowerCAmelCase__ : int = 1_517
lowerCAmelCase__ : Optional[int] = 1_570
lowerCAmelCase__ : int = 1_584
lowerCAmelCase__ : Dict = 1_793
lowerCAmelCase__ : Optional[int] = 1_795
lowerCAmelCase__ : Dict = 1_916
lowerCAmelCase__ : Any = 1_864
lowerCAmelCase__ : Optional[Any] = 1_905
lowerCAmelCase__ : Union[str, Any] = 1_919
lowerCAmelCase__ : Optional[int] = 2_429
lowerCAmelCase__ : Union[str, Any] = 2_208
lowerCAmelCase__ : List[Any] = 2_418
lowerCAmelCase__ : Optional[Any] = 2_323
lowerCAmelCase__ : Dict = 2_407
# @@protoc_insertion_point(module_scope)
| 632 | """simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import os
from accelerate.utils import ComputeEnvironment
from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401
from .sagemaker import get_sagemaker_input
lowerCAmelCase__ : Dict = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'
def a_ ( ):
UpperCAmelCase__ = _ask_options(
'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , )
if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
UpperCAmelCase__ = get_sagemaker_input()
else:
UpperCAmelCase__ = get_cluster_input()
return config
def a_ ( lowerCamelCase=None ):
if subparsers is not None:
UpperCAmelCase__ = subparsers.add_parser('config' , description=lowerCamelCase )
else:
UpperCAmelCase__ = argparse.ArgumentParser('Accelerate config command' , description=lowerCamelCase )
parser.add_argument(
'--config_file' , default=lowerCamelCase , help=(
'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
'with \'huggingface\'.'
) , )
if subparsers is not None:
parser.set_defaults(func=lowerCamelCase )
return parser
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_user_input()
if args.config_file is not None:
UpperCAmelCase__ = args.config_file
else:
if not os.path.isdir(lowerCamelCase ):
os.makedirs(lowerCamelCase )
UpperCAmelCase__ = default_yaml_config_file
if config_file.endswith('.json' ):
config.to_json_file(lowerCamelCase )
else:
config.to_yaml_file(lowerCamelCase )
print(f'''accelerate configuration saved at {config_file}''' )
def a_ ( ):
UpperCAmelCase__ = config_command_parser()
UpperCAmelCase__ = parser.parse_args()
config_command(lowerCamelCase )
if __name__ == "__main__":
main()
| 632 | 1 |
"""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, BatchEncoding, PreTrainedTokenizer
from ...utils import logging
lowerCAmelCase__ : str = logging.get_logger(__name__)
lowerCAmelCase__ : int = '▁'
lowerCAmelCase__ : List[Any] = {'vocab_file': 'sentencepiece.bpe.model'}
lowerCAmelCase__ : List[Any] = {
'vocab_file': {
'facebook/nllb-200-distilled-600M': (
'https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model'
),
}
}
lowerCAmelCase__ : Union[str, Any] = {
'facebook/nllb-200-distilled-600M': 1_024,
}
# fmt: off
lowerCAmelCase__ : Union[str, Any] = ['ace_Arab', 'ace_Latn', 'acm_Arab', 'acq_Arab', 'aeb_Arab', 'afr_Latn', 'ajp_Arab', 'aka_Latn', 'amh_Ethi', 'apc_Arab', 'arb_Arab', 'ars_Arab', 'ary_Arab', 'arz_Arab', 'asm_Beng', 'ast_Latn', 'awa_Deva', 'ayr_Latn', 'azb_Arab', 'azj_Latn', 'bak_Cyrl', 'bam_Latn', 'ban_Latn', 'bel_Cyrl', 'bem_Latn', 'ben_Beng', 'bho_Deva', 'bjn_Arab', 'bjn_Latn', 'bod_Tibt', 'bos_Latn', 'bug_Latn', 'bul_Cyrl', 'cat_Latn', 'ceb_Latn', 'ces_Latn', 'cjk_Latn', 'ckb_Arab', 'crh_Latn', 'cym_Latn', 'dan_Latn', 'deu_Latn', 'dik_Latn', 'dyu_Latn', 'dzo_Tibt', 'ell_Grek', 'eng_Latn', 'epo_Latn', 'est_Latn', 'eus_Latn', 'ewe_Latn', 'fao_Latn', 'pes_Arab', 'fij_Latn', 'fin_Latn', 'fon_Latn', 'fra_Latn', 'fur_Latn', 'fuv_Latn', 'gla_Latn', 'gle_Latn', 'glg_Latn', 'grn_Latn', 'guj_Gujr', 'hat_Latn', 'hau_Latn', 'heb_Hebr', 'hin_Deva', 'hne_Deva', 'hrv_Latn', 'hun_Latn', 'hye_Armn', 'ibo_Latn', 'ilo_Latn', 'ind_Latn', 'isl_Latn', 'ita_Latn', 'jav_Latn', 'jpn_Jpan', 'kab_Latn', 'kac_Latn', 'kam_Latn', 'kan_Knda', 'kas_Arab', 'kas_Deva', 'kat_Geor', 'knc_Arab', 'knc_Latn', 'kaz_Cyrl', 'kbp_Latn', 'kea_Latn', 'khm_Khmr', 'kik_Latn', 'kin_Latn', 'kir_Cyrl', 'kmb_Latn', 'kon_Latn', 'kor_Hang', 'kmr_Latn', 'lao_Laoo', 'lvs_Latn', 'lij_Latn', 'lim_Latn', 'lin_Latn', 'lit_Latn', 'lmo_Latn', 'ltg_Latn', 'ltz_Latn', 'lua_Latn', 'lug_Latn', 'luo_Latn', 'lus_Latn', 'mag_Deva', 'mai_Deva', 'mal_Mlym', 'mar_Deva', 'min_Latn', 'mkd_Cyrl', 'plt_Latn', 'mlt_Latn', 'mni_Beng', 'khk_Cyrl', 'mos_Latn', 'mri_Latn', 'zsm_Latn', 'mya_Mymr', 'nld_Latn', 'nno_Latn', 'nob_Latn', 'npi_Deva', 'nso_Latn', 'nus_Latn', 'nya_Latn', 'oci_Latn', 'gaz_Latn', 'ory_Orya', 'pag_Latn', 'pan_Guru', 'pap_Latn', 'pol_Latn', 'por_Latn', 'prs_Arab', 'pbt_Arab', 'quy_Latn', 'ron_Latn', 'run_Latn', 'rus_Cyrl', 'sag_Latn', 'san_Deva', 'sat_Beng', 'scn_Latn', 'shn_Mymr', 'sin_Sinh', 'slk_Latn', 'slv_Latn', 'smo_Latn', 'sna_Latn', 'snd_Arab', 'som_Latn', 'sot_Latn', 'spa_Latn', 'als_Latn', 'srd_Latn', 'srp_Cyrl', 'ssw_Latn', 'sun_Latn', 'swe_Latn', 'swh_Latn', 'szl_Latn', 'tam_Taml', 'tat_Cyrl', 'tel_Telu', 'tgk_Cyrl', 'tgl_Latn', 'tha_Thai', 'tir_Ethi', 'taq_Latn', 'taq_Tfng', 'tpi_Latn', 'tsn_Latn', 'tso_Latn', 'tuk_Latn', 'tum_Latn', 'tur_Latn', 'twi_Latn', 'tzm_Tfng', 'uig_Arab', 'ukr_Cyrl', 'umb_Latn', 'urd_Arab', 'uzn_Latn', 'vec_Latn', 'vie_Latn', 'war_Latn', 'wol_Latn', 'xho_Latn', 'ydd_Hebr', 'yor_Latn', 'yue_Hant', 'zho_Hans', 'zho_Hant', 'zul_Latn']
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = VOCAB_FILES_NAMES
snake_case__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
snake_case__ = PRETRAINED_VOCAB_FILES_MAP
snake_case__ = ["input_ids", "attention_mask"]
snake_case__ = []
snake_case__ = []
def __init__( self : List[str] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Optional[int]="<s>" ,lowerCamelCase__ : Tuple="</s>" ,lowerCamelCase__ : Dict="</s>" ,lowerCamelCase__ : Optional[int]="<s>" ,lowerCamelCase__ : Optional[Any]="<unk>" ,lowerCamelCase__ : int="<pad>" ,lowerCamelCase__ : Optional[Any]="<mask>" ,lowerCamelCase__ : Optional[Any]=None ,lowerCamelCase__ : Union[str, Any]=None ,lowerCamelCase__ : Optional[Any]=None ,lowerCamelCase__ : Optional[Dict[str, Any]] = None ,lowerCamelCase__ : List[str]=None ,lowerCamelCase__ : Any=False ,**lowerCamelCase__ : Dict ,):
# Mask token behave like a normal word, i.e. include the space before it
UpperCAmelCase__ = AddedToken(lowerCamelCase__ ,lstrip=lowerCamelCase__ ,rstrip=lowerCamelCase__ ) if isinstance(lowerCamelCase__ ,lowerCamelCase__ ) else mask_token
UpperCAmelCase__ = {} if sp_model_kwargs is None else sp_model_kwargs
UpperCAmelCase__ = legacy_behaviour
super().__init__(
bos_token=lowerCamelCase__ ,eos_token=lowerCamelCase__ ,unk_token=lowerCamelCase__ ,sep_token=lowerCamelCase__ ,cls_token=lowerCamelCase__ ,pad_token=lowerCamelCase__ ,mask_token=lowerCamelCase__ ,tokenizer_file=lowerCamelCase__ ,src_lang=lowerCamelCase__ ,tgt_lang=lowerCamelCase__ ,additional_special_tokens=lowerCamelCase__ ,sp_model_kwargs=self.sp_model_kwargs ,legacy_behaviour=lowerCamelCase__ ,**lowerCamelCase__ ,)
UpperCAmelCase__ = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(str(lowerCamelCase__ ) )
UpperCAmelCase__ = 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>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a'
# spm | '<unk>' | '<s>' | '</s>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s'
# Mimic fairseq token-to-id alignment for the first 4 token
UpperCAmelCase__ = {'<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
UpperCAmelCase__ = 1
UpperCAmelCase__ = len(self.sp_model )
UpperCAmelCase__ = {
code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(lowerCamelCase__ )
}
UpperCAmelCase__ = {v: k for k, v in self.lang_code_to_id.items()}
UpperCAmelCase__ = len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset
self.fairseq_tokens_to_ids.update(self.lang_code_to_id )
UpperCAmelCase__ = {v: k for k, v in self.fairseq_tokens_to_ids.items()}
UpperCAmelCase__ = list(self.lang_code_to_id.keys() )
if additional_special_tokens is not None:
# Only add those special tokens if they are not already there.
self._additional_special_tokens.extend(
[t for t in additional_special_tokens if t not in self._additional_special_tokens] )
UpperCAmelCase__ = src_lang if src_lang is not None else 'eng_Latn'
UpperCAmelCase__ = self.lang_code_to_id[self._src_lang]
UpperCAmelCase__ = tgt_lang
self.set_src_lang_special_tokens(self._src_lang )
def __getstate__( self : List[str] ):
UpperCAmelCase__ = self.__dict__.copy()
UpperCAmelCase__ = None
UpperCAmelCase__ = self.sp_model.serialized_model_proto()
return state
def __setstate__( self : int ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = d
# for backward compatibility
if not hasattr(self ,'sp_model_kwargs' ):
UpperCAmelCase__ = {}
UpperCAmelCase__ = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.LoadFromSerializedProto(self.sp_model_proto )
@property
def __lowerCAmelCase ( self : Optional[Any] ):
return len(self.sp_model ) + len(self.lang_code_to_id ) + self.fairseq_offset + 1 # Plus 1 for the mask token
@property
def __lowerCAmelCase ( self : str ):
return self._src_lang
@src_lang.setter
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : str ):
UpperCAmelCase__ = new_src_lang
self.set_src_lang_special_tokens(self._src_lang )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ,lowerCamelCase__ : bool = False ):
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=lowerCamelCase__ ,token_ids_a=lowerCamelCase__ ,already_has_special_tokens=lowerCamelCase__ )
UpperCAmelCase__ = [1] * len(self.prefix_tokens )
UpperCAmelCase__ = [1] * len(self.suffix_tokens )
if token_ids_a is None:
return prefix_ones + ([0] * len(lowerCamelCase__ )) + suffix_ones
return prefix_ones + ([0] * len(lowerCamelCase__ )) + ([0] * len(lowerCamelCase__ )) + suffix_ones
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
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 : Tuple ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
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 : Any ,lowerCamelCase__ : Any ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[str] ,lowerCamelCase__ : Optional[str] ,**lowerCamelCase__ : Optional[int] ):
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(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ,return_tensors=lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = self.convert_tokens_to_ids(lowerCamelCase__ )
UpperCAmelCase__ = tgt_lang_id
return inputs
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = {self.convert_ids_to_tokens(lowerCamelCase__ ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : str ):
return self.sp_model.encode(lowerCamelCase__ ,out_type=lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : Optional[int] ):
if token in self.fairseq_tokens_to_ids:
return self.fairseq_tokens_to_ids[token]
UpperCAmelCase__ = self.sp_model.PieceToId(lowerCamelCase__ )
# 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 : Optional[int] ,lowerCamelCase__ : Dict ):
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 : Any ,lowerCamelCase__ : List[Any] ):
UpperCAmelCase__ = ''.join(lowerCamelCase__ ).replace(lowerCamelCase__ ,' ' ).strip()
return out_string
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[str] = 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,)
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : str = "eng_Latn" ,lowerCamelCase__ : Optional[List[str]] = None ,lowerCamelCase__ : str = "fra_Latn" ,**lowerCamelCase__ : Tuple ,):
UpperCAmelCase__ = src_lang
UpperCAmelCase__ = tgt_lang
return super().prepare_seqaseq_batch(lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : str ):
return self.set_src_lang_special_tokens(self.src_lang )
def __lowerCAmelCase ( self : List[Any] ):
return self.set_tgt_lang_special_tokens(self.tgt_lang )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = self.lang_code_to_id[src_lang]
if self.legacy_behaviour:
UpperCAmelCase__ = []
UpperCAmelCase__ = [self.eos_token_id, self.cur_lang_code]
else:
UpperCAmelCase__ = [self.cur_lang_code]
UpperCAmelCase__ = [self.eos_token_id]
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : str ):
UpperCAmelCase__ = self.lang_code_to_id[lang]
if self.legacy_behaviour:
UpperCAmelCase__ = []
UpperCAmelCase__ = [self.eos_token_id, self.cur_lang_code]
else:
UpperCAmelCase__ = [self.cur_lang_code]
UpperCAmelCase__ = [self.eos_token_id]
| 632 | """simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import argparse
import logging
import os
import time
import timeit
import datasets
import numpy as np
import pycuda.autoinit # noqa: F401
import pycuda.driver as cuda
import tensorrt as trt
import torch
from absl import logging as absl_logging
from accelerate import Accelerator
from datasets import load_dataset, load_metric
from torch.utils.data import DataLoader
from utils_qa import postprocess_qa_predictions
import transformers
from transformers import AutoTokenizer, EvalPrediction, default_data_collator, set_seed
from transformers.trainer_pt_utils import nested_concat, nested_truncate
lowerCAmelCase__ : Dict = trt.Logger(trt.Logger.WARNING)
lowerCAmelCase__ : Optional[int] = absl_logging.get_absl_logger()
absl_logger.setLevel(logging.WARNING)
lowerCAmelCase__ : Optional[int] = logging.getLogger(__name__)
lowerCAmelCase__ : int = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--onnx_model_path',
default=None,
type=str,
required=True,
help='Path to ONNX model: ',
)
parser.add_argument(
'--output_dir',
default=None,
type=str,
required=True,
help='The output directory where the model checkpoints and predictions will be written.',
)
# Other parameters
parser.add_argument(
'--tokenizer_name',
default='',
type=str,
required=True,
help='Pretrained tokenizer name or path if not the same as model_name',
)
parser.add_argument(
'--version_2_with_negative',
action='store_true',
help='If true, the SQuAD examples contain some that do not have an answer.',
)
parser.add_argument(
'--null_score_diff_threshold',
type=float,
default=0.0,
help='If null_score - best_non_null is greater than the threshold predict null.',
)
parser.add_argument(
'--max_seq_length',
default=384,
type=int,
help=(
'The maximum total input sequence length after WordPiece tokenization. Sequences '
'longer than this will be truncated, and sequences shorter than this will be padded.'
),
)
parser.add_argument(
'--doc_stride',
default=128,
type=int,
help='When splitting up a long document into chunks, how much stride to take between chunks.',
)
parser.add_argument('--per_device_eval_batch_size', default=8, type=int, help='Batch size per GPU/CPU for evaluation.')
parser.add_argument(
'--n_best_size',
default=20,
type=int,
help='The total number of n-best predictions to generate in the nbest_predictions.json output file.',
)
parser.add_argument(
'--max_answer_length',
default=30,
type=int,
help=(
'The maximum length of an answer that can be generated. This is needed because the start '
'and end predictions are not conditioned on one another.'
),
)
parser.add_argument('--seed', type=int, default=42, help='random seed for initialization')
parser.add_argument(
'--dataset_name',
type=str,
default=None,
required=True,
help='The name of the dataset to use (via the datasets library).',
)
parser.add_argument(
'--dataset_config_name',
type=str,
default=None,
help='The configuration name of the dataset to use (via the datasets library).',
)
parser.add_argument(
'--preprocessing_num_workers', type=int, default=4, help='A csv or a json file containing the training data.'
)
parser.add_argument('--overwrite_cache', action='store_true', help='Overwrite the cached training and evaluation sets')
parser.add_argument(
'--fp16',
action='store_true',
help='Whether to use 16-bit (mixed) precision instead of 32-bit',
)
parser.add_argument(
'--int8',
action='store_true',
help='Whether to use INT8',
)
lowerCAmelCase__ : Optional[Any] = parser.parse_args()
if args.tokenizer_name:
lowerCAmelCase__ : str = AutoTokenizer.from_pretrained(args.tokenizer_name, use_fast=True)
else:
raise ValueError(
'You are instantiating a new tokenizer from scratch. This is not supported by this script.'
'You can do it from another script, save it, and load it from here, using --tokenizer_name.'
)
logger.info('Training/evaluation parameters %s', args)
lowerCAmelCase__ : Dict = args.per_device_eval_batch_size
lowerCAmelCase__ : Optional[int] = (args.eval_batch_size, args.max_seq_length)
# TRT Engine properties
lowerCAmelCase__ : int = True
lowerCAmelCase__ : Tuple = 'temp_engine/bert-fp32.engine'
if args.fpaa:
lowerCAmelCase__ : int = 'temp_engine/bert-fp16.engine'
if args.inta:
lowerCAmelCase__ : Any = 'temp_engine/bert-int8.engine'
# import ONNX file
if not os.path.exists('temp_engine'):
os.makedirs('temp_engine')
lowerCAmelCase__ : List[Any] = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, trt.OnnxParser(
network, TRT_LOGGER
) as parser:
with open(args.onnx_model_path, 'rb') as model:
if not parser.parse(model.read()):
for error in range(parser.num_errors):
print(parser.get_error(error))
# Query input names and shapes from parsed TensorRT network
lowerCAmelCase__ : Optional[Any] = [network.get_input(i) for i in range(network.num_inputs)]
lowerCAmelCase__ : Any = [_input.name for _input in network_inputs] # ex: ["actual_input1"]
with builder.create_builder_config() as config:
lowerCAmelCase__ : Union[str, Any] = 1 << 50
if STRICT_TYPES:
config.set_flag(trt.BuilderFlag.STRICT_TYPES)
if args.fpaa:
config.set_flag(trt.BuilderFlag.FPaa)
if args.inta:
config.set_flag(trt.BuilderFlag.INTa)
lowerCAmelCase__ : Tuple = builder.create_optimization_profile()
config.add_optimization_profile(profile)
for i in range(len(input_names)):
profile.set_shape(input_names[i], INPUT_SHAPE, INPUT_SHAPE, INPUT_SHAPE)
lowerCAmelCase__ : Any = builder.build_engine(network, config)
# serialize_engine and store in file (can be directly loaded and deserialized):
with open(engine_name, 'wb') as f:
f.write(engine.serialize())
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = np.asarray(inputs['input_ids'] , dtype=np.intaa )
UpperCAmelCase__ = np.asarray(inputs['attention_mask'] , dtype=np.intaa )
UpperCAmelCase__ = np.asarray(inputs['token_type_ids'] , dtype=np.intaa )
# Copy inputs
cuda.memcpy_htod_async(d_inputs[0] , input_ids.ravel() , lowerCamelCase )
cuda.memcpy_htod_async(d_inputs[1] , attention_mask.ravel() , lowerCamelCase )
cuda.memcpy_htod_async(d_inputs[2] , token_type_ids.ravel() , lowerCamelCase )
# start time
UpperCAmelCase__ = time.time()
# Run inference
context.execute_async(
bindings=[int(lowerCamelCase ) for d_inp in d_inputs] + [int(lowerCamelCase ), int(lowerCamelCase )] , stream_handle=stream.handle )
# Transfer predictions back from GPU
cuda.memcpy_dtoh_async(lowerCamelCase , lowerCamelCase , lowerCamelCase )
cuda.memcpy_dtoh_async(lowerCamelCase , lowerCamelCase , lowerCamelCase )
# Synchronize the stream and take time
stream.synchronize()
# end time
UpperCAmelCase__ = time.time()
UpperCAmelCase__ = end_time - start_time
UpperCAmelCase__ = (h_outputa, h_outputa)
# print(outputs)
return outputs, infer_time
# Initialize the accelerator. We will let the accelerator handle device placement for us in this example.
lowerCAmelCase__ : List[str] = Accelerator()
# Make one log on every process with the configuration for debugging.
logging.basicConfig(
format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
level=logging.INFO,
)
# Setup logging, we only want one process per machine to log things on the screen.
# accelerator.is_local_main_process is only True for one process per machine.
logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR)
if accelerator.is_local_main_process:
datasets.utils.logging.set_verbosity_warning()
transformers.utils.logging.set_verbosity_info()
else:
datasets.utils.logging.set_verbosity_error()
transformers.utils.logging.set_verbosity_error()
# If passed along, set the training seed now.
if args.seed is not None:
set_seed(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).
if args.dataset_name is not None:
# Downloading and loading a dataset from the hub.
lowerCAmelCase__ : Tuple = load_dataset(args.dataset_name, args.dataset_config_name)
else:
raise ValueError('Evaluation requires a dataset name')
# 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.
# Preprocessing the datasets.
# Preprocessing is slighlty different for training and evaluation.
lowerCAmelCase__ : Tuple = raw_datasets['validation'].column_names
lowerCAmelCase__ : Optional[Any] = 'question' if 'question' in column_names else column_names[0]
lowerCAmelCase__ : Tuple = 'context' if 'context' in column_names else column_names[1]
lowerCAmelCase__ : List[str] = 'answers' if 'answers' in column_names else column_names[2]
# Padding side determines if we do (question|context) or (context|question).
lowerCAmelCase__ : Any = tokenizer.padding_side == 'right'
if args.max_seq_length > tokenizer.model_max_length:
logger.warning(
F"""The max_seq_length passed ({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}."""
)
lowerCAmelCase__ : Dict = min(args.max_seq_length, tokenizer.model_max_length)
def a_ ( lowerCamelCase ):
# Some of the questions have lots of whitespace on the left, which is not useful and will make the
# truncation of the context fail (the tokenized question will take a lots of space). So we remove that
# left whitespace
UpperCAmelCase__ = [q.lstrip() for q in examples[question_column_name]]
# Tokenize our examples with truncation and maybe padding, but keep the overflows using a stride. This results
# in one example possible giving several features when a context is long, each of those features having a
# context that overlaps a bit the context of the previous feature.
UpperCAmelCase__ = tokenizer(
examples[question_column_name if pad_on_right else context_column_name] , examples[context_column_name if pad_on_right else question_column_name] , truncation='only_second' if pad_on_right else 'only_first' , max_length=lowerCamelCase , stride=args.doc_stride , return_overflowing_tokens=lowerCamelCase , return_offsets_mapping=lowerCamelCase , padding='max_length' , )
# Since one example might give us several features if it has a long context, we need a map from a feature to
# its corresponding example. This key gives us just that.
UpperCAmelCase__ = tokenized_examples.pop('overflow_to_sample_mapping' )
# For evaluation, we will need to convert our predictions to substrings of the context, so we keep the
# corresponding example_id and we will store the offset mappings.
UpperCAmelCase__ = []
for i in range(len(tokenized_examples['input_ids'] ) ):
# Grab the sequence corresponding to that example (to know what is the context and what is the question).
UpperCAmelCase__ = tokenized_examples.sequence_ids(lowerCamelCase )
UpperCAmelCase__ = 1 if pad_on_right else 0
# One example can give several spans, this is the index of the example containing this span of text.
UpperCAmelCase__ = sample_mapping[i]
tokenized_examples["example_id"].append(examples['id'][sample_index] )
# Set to None the offset_mapping that are not part of the context so it's easy to determine if a token
# position is part of the context or not.
UpperCAmelCase__ = [
(o if sequence_ids[k] == context_index else None)
for k, o in enumerate(tokenized_examples['offset_mapping'][i] )
]
return tokenized_examples
lowerCAmelCase__ : Optional[int] = raw_datasets['validation']
# Validation Feature Creation
lowerCAmelCase__ : Tuple = eval_examples.map(
prepare_validation_features,
batched=True,
num_proc=args.preprocessing_num_workers,
remove_columns=column_names,
load_from_cache_file=not args.overwrite_cache,
desc='Running tokenizer on validation dataset',
)
lowerCAmelCase__ : str = default_data_collator
lowerCAmelCase__ : Union[str, Any] = eval_dataset.remove_columns(['example_id', 'offset_mapping'])
lowerCAmelCase__ : Dict = DataLoader(
eval_dataset_for_model, collate_fn=data_collator, batch_size=args.per_device_eval_batch_size
)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase="eval" ):
# Post-processing: we match the start logits and end logits to answers in the original context.
UpperCAmelCase__ = postprocess_qa_predictions(
examples=lowerCamelCase , features=lowerCamelCase , predictions=lowerCamelCase , version_2_with_negative=args.version_2_with_negative , n_best_size=args.n_best_size , max_answer_length=args.max_answer_length , null_score_diff_threshold=args.null_score_diff_threshold , output_dir=args.output_dir , prefix=lowerCamelCase , )
# Format the result to the format the metric expects.
if args.version_2_with_negative:
UpperCAmelCase__ = [
{'id': k, 'prediction_text': v, 'no_answer_probability': 0.0} for k, v in predictions.items()
]
else:
UpperCAmelCase__ = [{'id': k, 'prediction_text': v} for k, v in predictions.items()]
UpperCAmelCase__ = [{'id': ex['id'], 'answers': ex[answer_column_name]} for ex in examples]
return EvalPrediction(predictions=lowerCamelCase , label_ids=lowerCamelCase )
lowerCAmelCase__ : str = load_metric('squad_v2' if args.version_2_with_negative else 'squad')
# Evaluation!
logger.info('Loading ONNX model %s for evaluation', args.onnx_model_path)
with open(engine_name, 'rb') as f, trt.Runtime(TRT_LOGGER) as runtime, runtime.deserialize_cuda_engine(
f.read()
) as engine, engine.create_execution_context() as context:
# setup for TRT inferrence
for i in range(len(input_names)):
context.set_binding_shape(i, INPUT_SHAPE)
assert context.all_binding_shapes_specified
def a_ ( lowerCamelCase ):
return trt.volume(engine.get_binding_shape(lowerCamelCase ) ) * engine.get_binding_dtype(lowerCamelCase ).itemsize
# Allocate device memory for inputs and outputs.
lowerCAmelCase__ : Tuple = [cuda.mem_alloc(binding_nbytes(binding)) for binding in engine if engine.binding_is_input(binding)]
# Allocate output buffer
lowerCAmelCase__ : Dict = cuda.pagelocked_empty(tuple(context.get_binding_shape(3)), dtype=np.floataa)
lowerCAmelCase__ : Dict = cuda.pagelocked_empty(tuple(context.get_binding_shape(4)), dtype=np.floataa)
lowerCAmelCase__ : Any = cuda.mem_alloc(h_outputa.nbytes)
lowerCAmelCase__ : str = cuda.mem_alloc(h_outputa.nbytes)
# Create a stream in which to copy inputs/outputs and run inference.
lowerCAmelCase__ : Any = cuda.Stream()
# Evaluation
logger.info('***** Running Evaluation *****')
logger.info(F""" Num examples = {len(eval_dataset)}""")
logger.info(F""" Batch size = {args.per_device_eval_batch_size}""")
lowerCAmelCase__ : Any = 0.0
lowerCAmelCase__ : Optional[Any] = 0
lowerCAmelCase__ : List[Any] = timeit.default_timer()
lowerCAmelCase__ : Dict = None
for step, batch in enumerate(eval_dataloader):
lowerCAmelCase__ , lowerCAmelCase__ : Union[str, Any] = model_infer(batch, context, d_inputs, h_outputa, h_outputa, d_outputa, d_outputa, stream)
total_time += infer_time
niter += 1
lowerCAmelCase__ , lowerCAmelCase__ : List[Any] = outputs
lowerCAmelCase__ : Optional[int] = torch.tensor(start_logits)
lowerCAmelCase__ : List[str] = torch.tensor(end_logits)
# necessary to pad predictions and labels for being gathered
lowerCAmelCase__ : str = accelerator.pad_across_processes(start_logits, dim=1, pad_index=-100)
lowerCAmelCase__ : Any = accelerator.pad_across_processes(end_logits, dim=1, pad_index=-100)
lowerCAmelCase__ : Union[str, Any] = (accelerator.gather(start_logits).cpu().numpy(), accelerator.gather(end_logits).cpu().numpy())
lowerCAmelCase__ : Union[str, Any] = logits if all_preds is None else nested_concat(all_preds, logits, padding_index=-100)
if all_preds is not None:
lowerCAmelCase__ : Dict = nested_truncate(all_preds, len(eval_dataset))
lowerCAmelCase__ : int = timeit.default_timer() - start_time
logger.info(' Evaluation done in total %f secs (%f sec per example)', evalTime, evalTime / len(eval_dataset))
# Inference time from TRT
logger.info('Average Inference Time = {:.3f} ms'.format(total_time * 1_000 / niter))
logger.info('Total Inference Time = {:.3f} ms'.format(total_time * 1_000))
logger.info('Total Number of Inference = %d', niter)
lowerCAmelCase__ : Tuple = post_processing_function(eval_examples, eval_dataset, all_preds)
lowerCAmelCase__ : Dict = metric.compute(predictions=prediction.predictions, references=prediction.label_ids)
logger.info(F"""Evaluation metrics: {eval_metric}""")
| 632 | """simple docstring"""
import warnings
from functools import wraps
from typing import Callable
def a_ ( lowerCamelCase ):
@wraps(lowerCamelCase )
def _inner_fn(*lowerCamelCase , **lowerCamelCase ):
warnings.warn(
(f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''') , lowerCamelCase , )
return fn(*lowerCamelCase , **lowerCamelCase )
return _inner_fn
| 632 | 1 |
"""simple docstring"""
import inspect
import unittest
from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from torch import nn
from transformers import RegNetForImageClassification, RegNetModel
from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
from PIL import Image
from transformers import AutoImageProcessor
class snake_case :
"""simple docstring"""
def __init__( self : List[str] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Tuple=3 ,lowerCamelCase__ : Union[str, Any]=32 ,lowerCamelCase__ : str=3 ,lowerCamelCase__ : List[Any]=10 ,lowerCamelCase__ : str=[10, 20, 30, 40] ,lowerCamelCase__ : int=[1, 1, 2, 1] ,lowerCamelCase__ : Tuple=True ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : Optional[int]="relu" ,lowerCamelCase__ : Dict=3 ,lowerCamelCase__ : List[str]=None ,):
UpperCAmelCase__ = parent
UpperCAmelCase__ = batch_size
UpperCAmelCase__ = image_size
UpperCAmelCase__ = num_channels
UpperCAmelCase__ = embeddings_size
UpperCAmelCase__ = hidden_sizes
UpperCAmelCase__ = depths
UpperCAmelCase__ = is_training
UpperCAmelCase__ = use_labels
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = num_labels
UpperCAmelCase__ = scope
UpperCAmelCase__ = len(lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
UpperCAmelCase__ = None
if self.use_labels:
UpperCAmelCase__ = ids_tensor([self.batch_size] ,self.num_labels )
UpperCAmelCase__ = self.get_config()
return config, pixel_values, labels
def __lowerCAmelCase ( self : Optional[Any] ):
return RegNetConfig(
num_channels=self.num_channels ,embeddings_size=self.embeddings_size ,hidden_sizes=self.hidden_sizes ,depths=self.depths ,hidden_act=self.hidden_act ,num_labels=self.num_labels ,)
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = RegNetModel(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
UpperCAmelCase__ = model(lowerCamelCase__ )
# expected last hidden states: B, C, H // 32, W // 32
self.parent.assertEqual(
result.last_hidden_state.shape ,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,)
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Any ):
UpperCAmelCase__ = self.num_labels
UpperCAmelCase__ = RegNetForImageClassification(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
UpperCAmelCase__ = model(lowerCamelCase__ ,labels=lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels) )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = config_and_inputs
UpperCAmelCase__ = {'pixel_values': pixel_values}
return config, inputs_dict
@require_torch
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
snake_case__ = (
{"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
if is_torch_available()
else {}
)
snake_case__ = False
snake_case__ = False
snake_case__ = False
snake_case__ = False
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = RegNetModelTester(self )
UpperCAmelCase__ = ConfigTester(self ,config_class=lowerCamelCase__ ,has_text_modality=lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __lowerCAmelCase ( self : Tuple ):
return
@unittest.skip(reason='RegNet does not use inputs_embeds' )
def __lowerCAmelCase ( self : Any ):
pass
@unittest.skip(reason='RegNet does not support input and output embeddings' )
def __lowerCAmelCase ( self : Optional[int] ):
pass
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase__ = model_class(lowerCamelCase__ )
UpperCAmelCase__ = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
UpperCAmelCase__ = [*signature.parameters.keys()]
UpperCAmelCase__ = ['pixel_values']
self.assertListEqual(arg_names[:1] ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase__ = model_class(config=lowerCamelCase__ )
for name, module in model.named_modules():
if isinstance(lowerCamelCase__ ,(nn.BatchNormad, nn.GroupNorm) ):
self.assertTrue(
torch.all(module.weight == 1 ) ,msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' ,)
self.assertTrue(
torch.all(module.bias == 0 ) ,msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' ,)
def __lowerCAmelCase ( self : Dict ):
def check_hidden_states_output(lowerCamelCase__ : Dict ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
with torch.no_grad():
UpperCAmelCase__ = model(**self._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ) )
UpperCAmelCase__ = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
UpperCAmelCase__ = self.model_tester.num_stages
self.assertEqual(len(lowerCamelCase__ ) ,expected_num_stages + 1 )
# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
self.assertListEqual(
list(hidden_states[0].shape[-2:] ) ,[self.model_tester.image_size // 2, self.model_tester.image_size // 2] ,)
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
UpperCAmelCase__ = ['basic', 'bottleneck']
for model_class in self.all_model_classes:
for layer_type in layers_type:
UpperCAmelCase__ = layer_type
UpperCAmelCase__ = True
check_hidden_states_output(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
UpperCAmelCase__ = True
check_hidden_states_output(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__ )
@slow
def __lowerCAmelCase ( self : Tuple ):
for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
UpperCAmelCase__ = RegNetModel.from_pretrained(lowerCamelCase__ )
self.assertIsNotNone(lowerCamelCase__ )
def a_ ( ):
UpperCAmelCase__ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
return image
@require_torch
@require_vision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@cached_property
def __lowerCAmelCase ( self : Dict ):
return (
AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
if is_vision_available()
else None
)
@slow
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(lowerCamelCase__ )
UpperCAmelCase__ = self.default_image_processor
UpperCAmelCase__ = prepare_img()
UpperCAmelCase__ = image_processor(images=lowerCamelCase__ ,return_tensors='pt' ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
UpperCAmelCase__ = model(**lowerCamelCase__ )
# verify the logits
UpperCAmelCase__ = torch.Size((1, 1_000) )
self.assertEqual(outputs.logits.shape ,lowerCamelCase__ )
UpperCAmelCase__ = torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(outputs.logits[0, :3] ,lowerCamelCase__ ,atol=1e-4 ) )
| 632 | """simple docstring"""
from __future__ import annotations
import string
from itertools import cycle, product
from pathlib import Path
lowerCAmelCase__ : str = (
string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__ : list[int] = [ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__ : set[int] = {ord(char) for char in VALID_CHARS}
lowerCAmelCase__ : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"]
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = ""
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
for keychar, cipherchar in zip(cycle(lowerCamelCase ) , lowerCamelCase ):
UpperCAmelCase__ = cipherchar ^ keychar
if decodedchar not in VALID_INTS:
return None
decoded += chr(lowerCamelCase )
return decoded
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
for key in product(lowerCamelCase , repeat=3 ):
UpperCAmelCase__ = try_key(lowerCamelCase , lowerCamelCase )
if encoded is not None:
possibles.append(lowerCamelCase )
return possibles
def a_ ( lowerCamelCase , lowerCamelCase ):
return [possible for possible in possibles if common_word in possible.lower()]
def a_ ( lowerCamelCase = "p059_cipher.txt" ):
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )
UpperCAmelCase__ = [int(lowerCamelCase ) for number in data.strip().split(',' )]
UpperCAmelCase__ = filter_valid_chars(lowerCamelCase )
for common_word in COMMON_WORDS:
UpperCAmelCase__ = filter_common_word(lowerCamelCase , lowerCamelCase )
if len(lowerCamelCase ) == 1:
break
UpperCAmelCase__ = possibles[0]
return sum(ord(lowerCamelCase ) for char in decoded_text )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import unittest
from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : int = get_tests_dir('fixtures/spiece.model')
@require_sentencepiece
@require_tokenizers
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = DebertaVaTokenizer
snake_case__ = DebertaVaTokenizerFast
snake_case__ = True
snake_case__ = True
def __lowerCAmelCase ( self : Tuple ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,unk_token='<unk>' )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = 'this is a test'
UpperCAmelCase__ = 'this is a test'
return input_text, output_text
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = '<pad>'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'<pad>' )
self.assertEqual(vocab_keys[1] ,'<unk>' )
self.assertEqual(vocab_keys[-1] ,'[PAD]' )
self.assertEqual(len(lowerCamelCase__ ) ,30_001 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,30_000 )
def __lowerCAmelCase ( self : Dict ):
# fmt: off
UpperCAmelCase__ = ' \tHeLLo!how \n Are yoU? '
UpperCAmelCase__ = ['▁hello', '!', 'how', '▁are', '▁you', '?']
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.' )
def __lowerCAmelCase ( self : List[str] ):
pass
@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.' )
def __lowerCAmelCase ( self : int ):
pass
def __lowerCAmelCase ( self : Optional[Any] ):
# fmt: off
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
# fmt: off
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
# fmt: off
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
# fmt: off
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : int ):
# fmt: off
UpperCAmelCase__ = ' \tHeLLo!how \n Are yoU? '
UpperCAmelCase__ = ['▁', '<unk>', 'e', '<unk>', 'o', '!', 'how', '▁', '<unk>', 're', '▁yo', '<unk>', '?']
# fmt: on
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,do_lower_case=lowerCamelCase__ ,split_by_punct=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_tokenizer()
UpperCAmelCase__ = self.get_rust_tokenizer()
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ) )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = self.get_rust_tokenizer()
UpperCAmelCase__ = tokenizer.encode(lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.encode(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = 'This is a test'
UpperCAmelCase__ = [13, 1, 4_398, 25, 21, 1_289]
UpperCAmelCase__ = ['▁', 'T', 'his', '▁is', '▁a', '▁test']
UpperCAmelCase__ = ['▁', '<unk>', 'his', '▁is', '▁a', '▁test']
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = DebertaVaTokenizerFast(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.tokenize(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
# fmt: off
UpperCAmelCase__ = 'I was born in 92000, and this is falsé.'
UpperCAmelCase__ = [13, 1, 23, 386, 19, 561, 3_050, 15, 17, 48, 25, 8_256, 18, 1, 9]
UpperCAmelCase__ = ['▁', 'I', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.', ]
UpperCAmelCase__ = ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
# fmt: on
UpperCAmelCase__ = tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.convert_ids_to_tokens(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.encode(lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.tokenize(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = rust_tokenizer.convert_ids_to_tokens(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = DebertaVaTokenizer(lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode('sequence builders' )
UpperCAmelCase__ = tokenizer.encode('multi-sequence build' )
UpperCAmelCase__ = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] ,lowerCamelCase__ )
self.assertEqual(
[tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id] ,lowerCamelCase__ ,)
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[1, 39_867, 36, 19_390, 486, 27, 35_052, 81_436, 18, 60_685, 1_225, 7, 35_052, 81_436, 18, 9_367, 16_899, 18, 15_937, 53, 594, 773, 18, 16_287, 30_465, 36, 15_937, 6, 41_139, 38, 36_979, 60_763, 191, 6, 34_132, 99, 6, 50_538, 390, 43_230, 6, 34_132, 2_779, 20_850, 14, 699, 1_072, 1_194, 36, 382, 10_901, 53, 7, 699, 1_072, 2_084, 36, 20_422, 630, 53, 19, 105, 3_049, 1_896, 1_053, 16_899, 1_506, 11, 37_978, 4_243, 7, 1_237, 31_869, 200, 16_566, 654, 6, 35_052, 81_436, 7, 55_630, 13_593, 4, 2], [1, 26, 15_011, 13, 667, 8, 1_053, 18, 23_611, 1_237, 72_356, 12_820, 34, 104_134, 1_209, 35, 13_313, 6_627, 21, 202, 347, 7, 164, 2_399, 11, 46, 4_485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1_232, 2_864, 15_785, 14_951, 105, 5, 8_581, 1_250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/deberta-v2-xlarge' ,revision='ad6e42c1532ddf3a15c39246b63f5559d558b670' ,)
| 632 | """simple docstring"""
import unittest
from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : Any = get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = XLMProphetNetTokenizer
snake_case__ = False
snake_case__ = True
def __lowerCAmelCase ( self : Any ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = '[PAD]'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'[PAD]' )
self.assertEqual(vocab_keys[1] ,'[CLS]' )
self.assertEqual(vocab_keys[-1] ,'j' )
self.assertEqual(len(lowerCamelCase__ ) ,1_012 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,1_012 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowerCamelCase__ ,['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,)
UpperCAmelCase__ = 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',
'é',
'.',
] ,)
UpperCAmelCase__ = tokenizer.convert_tokens_to_ids(lowerCamelCase__ )
self.assertListEqual(
lowerCamelCase__ ,[
value + tokenizer.fairseq_offset
for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
] ,)
UpperCAmelCase__ = 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 __lowerCAmelCase ( self : Dict ):
return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )
@slow
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello World!'
UpperCAmelCase__ = [35_389, 6_672, 49, 2]
self.assertListEqual(lowerCamelCase__ ,self.big_tokenizer.encode(lowerCamelCase__ ) )
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/xprophetnet-large-wiki100-cased' ,revision='1acad1643ddd54a44df6a1b797ada8373685d90e' ,)
| 632 | 1 |
"""simple docstring"""
from typing import List, Optional, Union
import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging
lowerCAmelCase__ : Union[str, Any] = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ["input_features", "attention_mask"]
def __init__( self : Optional[int] ,lowerCamelCase__ : int=80 ,lowerCamelCase__ : Any=16_000 ,lowerCamelCase__ : int=80 ,lowerCamelCase__ : str=0.0 ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : str=True ,lowerCamelCase__ : Optional[Any]=True ,**lowerCamelCase__ : str ,):
super().__init__(feature_size=lowerCamelCase__ ,sampling_rate=lowerCamelCase__ ,padding_value=lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = num_mel_bins
UpperCAmelCase__ = do_ceptral_normalize
UpperCAmelCase__ = normalize_means
UpperCAmelCase__ = normalize_vars
UpperCAmelCase__ = True
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : np.ndarray ,):
UpperCAmelCase__ = waveform * (2**15) # Kaldi compliance: 16-bit signed integers
UpperCAmelCase__ = torch.from_numpy(lowerCamelCase__ ).unsqueeze(0 )
UpperCAmelCase__ = ta_kaldi.fbank(lowerCamelCase__ ,num_mel_bins=self.num_mel_bins ,sample_frequency=self.sampling_rate )
return features.numpy()
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[bool] = True ,lowerCamelCase__ : Optional[bool] = True ,lowerCamelCase__ : float = 0.0 ,):
# make sure we normalize float32 arrays
if normalize_means:
UpperCAmelCase__ = x[:input_length].mean(axis=0 )
UpperCAmelCase__ = np.subtract(lowerCamelCase__ ,lowerCamelCase__ )
if normalize_vars:
UpperCAmelCase__ = x[:input_length].std(axis=0 )
UpperCAmelCase__ = np.divide(lowerCamelCase__ ,lowerCamelCase__ )
if input_length < x.shape[0]:
UpperCAmelCase__ = padding_value
# make sure array is in float32
UpperCAmelCase__ = x.astype(np.floataa )
return x
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : List[np.ndarray] ,lowerCamelCase__ : Optional[np.ndarray] = None ):
UpperCAmelCase__ = attention_mask.sum(-1 ) if attention_mask is not None else [x.shape[0] for x in input_features]
return [
self.utterance_cmvn(lowerCamelCase__ ,lowerCamelCase__ ,self.normalize_means ,self.normalize_vars ,self.padding_value )
for x, n in zip(lowerCamelCase__ ,lowerCamelCase__ )
]
def __call__( self : Dict ,lowerCamelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCamelCase__ : Union[bool, str, PaddingStrategy] = False ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : Optional[Union[str, TensorType]] = None ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : Optional[bool] = None ,**lowerCamelCase__ : Union[str, Any] ,):
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
f''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
f''' {self.sampling_rate} and not {sampling_rate}.''' )
else:
logger.warning(
'It is strongly recommended to pass the `sampling_rate` argument to this function. '
'Failing to do so can result in silent errors that might be hard to debug.' )
UpperCAmelCase__ = isinstance(lowerCamelCase__ ,np.ndarray ) and len(raw_speech.shape ) > 1
if is_batched_numpy and len(raw_speech.shape ) > 2:
raise ValueError(f'''Only mono-channel audio is supported for input to {self}''' )
UpperCAmelCase__ = is_batched_numpy or (
isinstance(lowerCamelCase__ ,(list, tuple) ) and (isinstance(raw_speech[0] ,(np.ndarray, tuple, list) ))
)
if is_batched:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ,dtype=np.floataa ) for speech in raw_speech]
elif not is_batched and not isinstance(lowerCamelCase__ ,np.ndarray ):
UpperCAmelCase__ = np.asarray(lowerCamelCase__ ,dtype=np.floataa )
elif isinstance(lowerCamelCase__ ,np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ):
UpperCAmelCase__ = raw_speech.astype(np.floataa )
# always return batch
if not is_batched:
UpperCAmelCase__ = [raw_speech]
# extract fbank features
UpperCAmelCase__ = [self._extract_fbank_features(lowerCamelCase__ ) for waveform in raw_speech]
# convert into correct format for padding
UpperCAmelCase__ = BatchFeature({'input_features': features} )
UpperCAmelCase__ = self.pad(
lowerCamelCase__ ,padding=lowerCamelCase__ ,max_length=lowerCamelCase__ ,truncation=lowerCamelCase__ ,pad_to_multiple_of=lowerCamelCase__ ,return_attention_mask=lowerCamelCase__ ,**lowerCamelCase__ ,)
# make sure list is in array format
UpperCAmelCase__ = padded_inputs.get('input_features' )
if isinstance(input_features[0] ,lowerCamelCase__ ):
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ,dtype=np.floataa ) for feature in input_features]
UpperCAmelCase__ = padded_inputs.get('attention_mask' )
if attention_mask is not None:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ,dtype=np.intaa ) for array in attention_mask]
# Utterance-level cepstral mean and variance normalization
if self.do_ceptral_normalize:
UpperCAmelCase__ = (
np.array(lowerCamelCase__ ,dtype=np.intaa )
if self._get_padding_strategies(lowerCamelCase__ ,max_length=lowerCamelCase__ ) is not PaddingStrategy.DO_NOT_PAD
else None
)
UpperCAmelCase__ = self.normalize(
padded_inputs['input_features'] ,attention_mask=lowerCamelCase__ )
if return_tensors is not None:
UpperCAmelCase__ = padded_inputs.convert_to_tensors(lowerCamelCase__ )
return padded_inputs
| 632 | """simple docstring"""
from __future__ import annotations
import collections
import pprint
from pathlib import Path
def a_ ( lowerCamelCase ):
return "".join(sorted(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
return word_by_signature[signature(lowerCamelCase )]
lowerCAmelCase__ : str = Path(__file__).parent.joinpath('words.txt').read_text(encoding='utf-8')
lowerCAmelCase__ : str = sorted({word.strip().lower() for word in data.splitlines()})
lowerCAmelCase__ : Optional[Any] = collections.defaultdict(list)
for word in word_list:
word_by_signature[signature(word)].append(word)
if __name__ == "__main__":
lowerCAmelCase__ : int = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
with open('anagrams.txt', 'w') as file:
file.write('all_anagrams = \n ')
file.write(pprint.pformat(all_anagrams))
| 632 | 1 |
"""simple docstring"""
from typing import Dict, List, Optional, Union
import numpy as np
from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
IMAGENET_STANDARD_MEAN,
IMAGENET_STANDARD_STD,
ChannelDimension,
ImageInput,
PILImageResampling,
make_list_of_images,
to_numpy_array,
valid_images,
)
from ...utils import TensorType, is_vision_available, logging
if is_vision_available():
import PIL
lowerCAmelCase__ : Union[str, Any] = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ["pixel_values"]
def __init__( self : Union[str, Any] ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : PILImageResampling = PIL.Image.BICUBIC ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : Union[int, float] = 1 / 255 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,**lowerCamelCase__ : Any ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = size if size is not None else {'height': 256, 'width': 256}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
UpperCAmelCase__ = crop_size if crop_size is not None else {'height': 224, 'width': 224}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='crop_size' )
UpperCAmelCase__ = do_resize
UpperCAmelCase__ = size
UpperCAmelCase__ = resample
UpperCAmelCase__ = do_center_crop
UpperCAmelCase__ = crop_size
UpperCAmelCase__ = do_rescale
UpperCAmelCase__ = rescale_factor
UpperCAmelCase__ = do_normalize
UpperCAmelCase__ = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
UpperCAmelCase__ = image_std if image_std is not None else IMAGENET_STANDARD_STD
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : PILImageResampling = PIL.Image.BICUBIC ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : str ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
if "height" not in size or "width" not in size:
raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}''' )
return resize(
lowerCamelCase__ ,size=(size['height'], size['width']) ,resample=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Dict ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
if "height" not in size or "width" not in size:
raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}''' )
return center_crop(lowerCamelCase__ ,size=(size['height'], size['width']) ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Union[int, float] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Tuple ,):
return rescale(lowerCamelCase__ ,scale=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Union[float, List[float]] ,lowerCamelCase__ : Union[float, List[float]] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Union[str, Any] ,):
return normalize(lowerCamelCase__ ,mean=lowerCamelCase__ ,std=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : ImageInput ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : Union[str, Any]=None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : float = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : Optional[Union[str, TensorType]] = None ,lowerCamelCase__ : ChannelDimension = ChannelDimension.FIRST ,**lowerCamelCase__ : List[Any] ,):
UpperCAmelCase__ = do_resize if do_resize is not None else self.do_resize
UpperCAmelCase__ = resample if resample is not None else self.resample
UpperCAmelCase__ = do_center_crop if do_center_crop is not None else self.do_center_crop
UpperCAmelCase__ = do_rescale if do_rescale is not None else self.do_rescale
UpperCAmelCase__ = rescale_factor if rescale_factor is not None else self.rescale_factor
UpperCAmelCase__ = do_normalize if do_normalize is not None else self.do_normalize
UpperCAmelCase__ = image_mean if image_mean is not None else self.image_mean
UpperCAmelCase__ = image_std if image_std is not None else self.image_std
UpperCAmelCase__ = size if size is not None else self.size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
UpperCAmelCase__ = crop_size if crop_size is not None else self.crop_size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='crop_size' )
UpperCAmelCase__ = make_list_of_images(lowerCamelCase__ )
if not valid_images(lowerCamelCase__ ):
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 or resample is None:
raise ValueError('Size and resample must be specified if do_resize is True.' )
if do_center_crop and crop_size is None:
raise ValueError('Crop size must be specified if do_center_crop is True.' )
if do_rescale and rescale_factor is None:
raise ValueError('Rescale factor must be specified if do_rescale is True.' )
if do_normalize and (image_mean is None or image_std is None):
raise ValueError('Image mean and std must be specified if do_normalize is True.' )
# All transformations expect numpy arrays.
UpperCAmelCase__ = [to_numpy_array(lowerCamelCase__ ) for image in images]
if do_resize:
UpperCAmelCase__ = [self.resize(image=lowerCamelCase__ ,size=lowerCamelCase__ ,resample=lowerCamelCase__ ) for image in images]
if do_center_crop:
UpperCAmelCase__ = [self.center_crop(image=lowerCamelCase__ ,size=lowerCamelCase__ ) for image in images]
if do_rescale:
UpperCAmelCase__ = [self.rescale(image=lowerCamelCase__ ,scale=lowerCamelCase__ ) for image in images]
if do_normalize:
UpperCAmelCase__ = [self.normalize(image=lowerCamelCase__ ,mean=lowerCamelCase__ ,std=lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = [to_channel_dimension_format(lowerCamelCase__ ,lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = {'pixel_values': images}
return BatchFeature(data=lowerCamelCase__ ,tensor_type=lowerCamelCase__ )
| 632 | """simple docstring"""
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class snake_case ( ctypes.Structure ):
"""simple docstring"""
snake_case__ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25l' )
sys.stdout.flush()
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25h' )
sys.stdout.flush()
@contextmanager
def a_ ( ):
try:
hide_cursor()
yield
finally:
show_cursor()
| 632 | 1 |
"""simple docstring"""
import functools
import operator
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Dict = logging.get_logger(__name__)
lowerCAmelCase__ : Any = {
'microsoft/wavlm-base': 'https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json',
# See all WavLM models at https://huggingface.co/models?filter=wavlm
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "wavlm"
def __init__( self : Optional[int] ,lowerCamelCase__ : List[str]=32 ,lowerCamelCase__ : str=768 ,lowerCamelCase__ : List[Any]=12 ,lowerCamelCase__ : int=12 ,lowerCamelCase__ : int=3_072 ,lowerCamelCase__ : List[str]="gelu" ,lowerCamelCase__ : Optional[Any]=0.1 ,lowerCamelCase__ : Tuple=0.1 ,lowerCamelCase__ : Optional[int]=0.1 ,lowerCamelCase__ : Optional[int]=0.0 ,lowerCamelCase__ : int=0.1 ,lowerCamelCase__ : str=0.1 ,lowerCamelCase__ : Optional[Any]=0.0_2 ,lowerCamelCase__ : str=1e-5 ,lowerCamelCase__ : Any="group" ,lowerCamelCase__ : List[str]="gelu" ,lowerCamelCase__ : str=(512, 512, 512, 512, 512, 512, 512) ,lowerCamelCase__ : List[Any]=(5, 2, 2, 2, 2, 2, 2) ,lowerCamelCase__ : List[str]=(10, 3, 3, 3, 3, 2, 2) ,lowerCamelCase__ : int=False ,lowerCamelCase__ : Optional[Any]=128 ,lowerCamelCase__ : Union[str, Any]=16 ,lowerCamelCase__ : str=320 ,lowerCamelCase__ : Tuple=800 ,lowerCamelCase__ : Optional[Any]=False ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : int=0.0_5 ,lowerCamelCase__ : List[str]=10 ,lowerCamelCase__ : Union[str, Any]=2 ,lowerCamelCase__ : Optional[int]=0.0 ,lowerCamelCase__ : int=10 ,lowerCamelCase__ : int=320 ,lowerCamelCase__ : Dict=2 ,lowerCamelCase__ : List[str]=0.1 ,lowerCamelCase__ : Optional[Any]=100 ,lowerCamelCase__ : Optional[Any]=256 ,lowerCamelCase__ : Tuple=256 ,lowerCamelCase__ : Optional[int]=0.1 ,lowerCamelCase__ : Tuple="mean" ,lowerCamelCase__ : Optional[int]=False ,lowerCamelCase__ : List[str]=False ,lowerCamelCase__ : Dict=256 ,lowerCamelCase__ : Optional[int]=(512, 512, 512, 512, 1_500) ,lowerCamelCase__ : Any=(5, 3, 3, 1, 1) ,lowerCamelCase__ : Union[str, Any]=(1, 2, 3, 1, 1) ,lowerCamelCase__ : Optional[int]=512 ,lowerCamelCase__ : List[str]=80 ,lowerCamelCase__ : Any=0 ,lowerCamelCase__ : Optional[Any]=1 ,lowerCamelCase__ : Tuple=2 ,lowerCamelCase__ : str=False ,lowerCamelCase__ : Any=3 ,lowerCamelCase__ : Any=2 ,lowerCamelCase__ : Union[str, Any]=3 ,lowerCamelCase__ : List[str]=None ,**lowerCamelCase__ : Optional[int] ,):
super().__init__(**lowerCamelCase__ ,pad_token_id=lowerCamelCase__ ,bos_token_id=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = feat_extract_norm
UpperCAmelCase__ = feat_extract_activation
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = conv_bias
UpperCAmelCase__ = num_buckets
UpperCAmelCase__ = max_bucket_distance
UpperCAmelCase__ = num_conv_pos_embeddings
UpperCAmelCase__ = num_conv_pos_embedding_groups
UpperCAmelCase__ = len(self.conv_dim )
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = hidden_dropout
UpperCAmelCase__ = attention_dropout
UpperCAmelCase__ = activation_dropout
UpperCAmelCase__ = feat_proj_dropout
UpperCAmelCase__ = final_dropout
UpperCAmelCase__ = layerdrop
UpperCAmelCase__ = layer_norm_eps
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = num_ctc_classes
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = do_stable_layer_norm
UpperCAmelCase__ = use_weighted_layer_sum
UpperCAmelCase__ = classifier_proj_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)`, but is `len(config.conv_dim) ='
f''' {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,'''
f''' `len(config.conv_kernel) = {len(self.conv_kernel )}`.''' )
# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
UpperCAmelCase__ = apply_spec_augment
UpperCAmelCase__ = mask_time_prob
UpperCAmelCase__ = mask_time_length
UpperCAmelCase__ = mask_time_min_masks
UpperCAmelCase__ = mask_feature_prob
UpperCAmelCase__ = mask_feature_length
# parameters for pretraining with codevector quantized representations
UpperCAmelCase__ = num_codevectors_per_group
UpperCAmelCase__ = num_codevector_groups
UpperCAmelCase__ = contrastive_logits_temperature
UpperCAmelCase__ = num_negatives
UpperCAmelCase__ = codevector_dim
UpperCAmelCase__ = proj_codevector_dim
UpperCAmelCase__ = diversity_loss_weight
# ctc loss
UpperCAmelCase__ = ctc_loss_reduction
UpperCAmelCase__ = ctc_zero_infinity
# adapter
UpperCAmelCase__ = add_adapter
UpperCAmelCase__ = adapter_kernel_size
UpperCAmelCase__ = adapter_stride
UpperCAmelCase__ = num_adapter_layers
UpperCAmelCase__ = output_hidden_size or hidden_size
# SequenceClassification-specific parameter. Feel free to ignore for other classes.
UpperCAmelCase__ = classifier_proj_size
# XVector-specific parameters. Feel free to ignore for other classes.
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = list(lowerCamelCase__ )
UpperCAmelCase__ = xvector_output_dim
@property
def __lowerCAmelCase ( self : Optional[Any] ):
return functools.reduce(operator.mul ,self.conv_stride ,1 )
| 632 | """simple docstring"""
import inspect
import tempfile
from collections import OrderedDict, UserDict
from collections.abc import MutableMapping
from contextlib import ExitStack, contextmanager
from dataclasses import fields
from enum import Enum
from typing import Any, ContextManager, List, Tuple
import numpy as np
from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy
if is_flax_available():
import jax.numpy as jnp
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __get__( self : Dict ,lowerCamelCase__ : str ,lowerCamelCase__ : str=None ):
# See docs.python.org/3/howto/descriptor.html#properties
if obj is None:
return self
if self.fget is None:
raise AttributeError('unreadable attribute' )
UpperCAmelCase__ = '__cached_' + self.fget.__name__
UpperCAmelCase__ = getattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
if cached is None:
UpperCAmelCase__ = self.fget(lowerCamelCase__ )
setattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
return cached
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = val.lower()
if val in {"y", "yes", "t", "true", "on", "1"}:
return 1
if val in {"n", "no", "f", "false", "off", "0"}:
return 0
raise ValueError(f'''invalid truth value {val!r}''' )
def a_ ( lowerCamelCase ):
if is_torch_fx_proxy(lowerCamelCase ):
return True
if is_torch_available():
import torch
if isinstance(lowerCamelCase , torch.Tensor ):
return True
if is_tf_available():
import tensorflow as tf
if isinstance(lowerCamelCase , tf.Tensor ):
return True
if is_flax_available():
import jax.numpy as jnp
from jax.core import Tracer
if isinstance(lowerCamelCase , (jnp.ndarray, Tracer) ):
return True
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return _is_numpy(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.device )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_device(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
if isinstance(lowerCamelCase , lowerCamelCase ):
if hasattr(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = getattr(lowerCamelCase , lowerCamelCase )
else:
return False
return isinstance(lowerCamelCase , torch.dtype )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_dtype(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
return isinstance(lowerCamelCase , tf.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tensorflow(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
# the `is_symbolic_tensor` predicate is only available starting with TF 2.14
if hasattr(lowerCamelCase , 'is_symbolic_tensor' ):
return tf.is_symbolic_tensor(lowerCamelCase )
return type(lowerCamelCase ) == tf.Tensor
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tf_symbolic_tensor(lowerCamelCase )
def a_ ( lowerCamelCase ):
import jax.numpy as jnp # noqa: F811
return isinstance(lowerCamelCase , jnp.ndarray )
def a_ ( lowerCamelCase ):
return False if not is_flax_available() else _is_jax(lowerCamelCase )
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_py_obj(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return [to_py_obj(lowerCamelCase ) for o in obj]
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy().tolist()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().tolist()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase ).tolist()
elif isinstance(lowerCamelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays
return obj.tolist()
else:
return obj
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_numpy(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return np.array(lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().numpy()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase )
else:
return obj
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = fields(self )
# Safety and consistency checks
if not len(lowerCamelCase__ ):
raise ValueError(f'''{self.__class__.__name__} has no fields.''' )
if not all(field.default is None for field in class_fields[1:] ):
raise ValueError(f'''{self.__class__.__name__} should not have more than one required field.''' )
UpperCAmelCase__ = getattr(self ,class_fields[0].name )
UpperCAmelCase__ = all(getattr(self ,field.name ) is None for field in class_fields[1:] )
if other_fields_are_none and not is_tensor(lowerCamelCase__ ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = first_field.items()
UpperCAmelCase__ = True
else:
try:
UpperCAmelCase__ = iter(lowerCamelCase__ )
UpperCAmelCase__ = True
except TypeError:
UpperCAmelCase__ = False
# if we provided an iterator as first field and the iterator is a (key, value) iterator
# set the associated fields
if first_field_iterator:
for idx, element in enumerate(lowerCamelCase__ ):
if (
not isinstance(lowerCamelCase__ ,(list, tuple) )
or not len(lowerCamelCase__ ) == 2
or not isinstance(element[0] ,lowerCamelCase__ )
):
if idx == 0:
# If we do not have an iterator of key/values, set it as attribute
UpperCAmelCase__ = first_field
else:
# If we have a mixed iterator, raise an error
raise ValueError(
f'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' )
break
setattr(self ,element[0] ,element[1] )
if element[1] is not None:
UpperCAmelCase__ = element[1]
elif first_field is not None:
UpperCAmelCase__ = first_field
else:
for field in class_fields:
UpperCAmelCase__ = getattr(self ,field.name )
if v is not None:
UpperCAmelCase__ = v
def __delitem__( self : List[Any] ,*lowerCamelCase__ : Any ,**lowerCamelCase__ : Dict ):
raise Exception(f'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : str ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Optional[Any] ):
raise Exception(f'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : List[Any] ,*lowerCamelCase__ : int ,**lowerCamelCase__ : List[Any] ):
raise Exception(f'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : Optional[int] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Optional[int] ):
raise Exception(f'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' )
def __getitem__( self : Tuple ,lowerCamelCase__ : List[Any] ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = dict(self.items() )
return inner_dict[k]
else:
return self.to_tuple()[k]
def __setattr__( self : int ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if name in self.keys() and value is not None:
# Don't call self.__setitem__ to avoid recursion errors
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __setitem__( self : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : Any ):
# Will raise a KeyException if needed
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
# Don't call self.__setattr__ to avoid recursion errors
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
return tuple(self[k] for k in self.keys() )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
@classmethod
def __lowerCAmelCase ( cls : str ,lowerCamelCase__ : Optional[int] ):
raise ValueError(
f'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "longest"
snake_case__ = "max_length"
snake_case__ = "do_not_pad"
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "pt"
snake_case__ = "tf"
snake_case__ = "np"
snake_case__ = "jax"
class snake_case :
"""simple docstring"""
def __init__( self : int ,lowerCamelCase__ : List[ContextManager] ):
UpperCAmelCase__ = context_managers
UpperCAmelCase__ = ExitStack()
def __enter__( self : Union[str, Any] ):
for context_manager in self.context_managers:
self.stack.enter_context(lowerCamelCase__ )
def __exit__( self : List[Any] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Dict ):
self.stack.__exit__(*lowerCamelCase__ ,**lowerCamelCase__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
for p in signature.parameters:
if p == "return_loss" and signature.parameters[p].default is True:
return True
return False
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = model_class.__name__
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
if "QuestionAnswering" in model_name:
return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")]
else:
return [p for p in signature.parameters if "label" in p]
def a_ ( lowerCamelCase , lowerCamelCase = "" , lowerCamelCase = "." ):
def _flatten_dict(lowerCamelCase , lowerCamelCase="" , lowerCamelCase="." ):
for k, v in d.items():
UpperCAmelCase__ = str(lowerCamelCase ) + delimiter + str(lowerCamelCase ) if parent_key else k
if v and isinstance(lowerCamelCase , lowerCamelCase ):
yield from flatten_dict(lowerCamelCase , lowerCamelCase , delimiter=lowerCamelCase ).items()
else:
yield key, v
return dict(_flatten_dict(lowerCamelCase , lowerCamelCase , lowerCamelCase ) )
@contextmanager
def a_ ( lowerCamelCase , lowerCamelCase = False ):
if use_temp_dir:
with tempfile.TemporaryDirectory() as tmp_dir:
yield tmp_dir
else:
yield working_dir
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.transpose(lowerCamelCase , axes=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.T if axes is None else array.permute(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.transpose(lowerCamelCase , perm=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.transpose(lowerCamelCase , axes=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for transpose: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.reshape(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.reshape(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.reshape(lowerCamelCase , lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.reshape(lowerCamelCase , lowerCamelCase )
else:
raise ValueError(f'''Type not supported for reshape: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.squeeze() if axis is None else array.squeeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.squeeze(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for squeeze: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.expand_dims(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.unsqueeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.expand_dims(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.expand_dims(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.size(lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.numel()
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.size(lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return array.size
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
for key, value in auto_map.items():
if isinstance(lowerCamelCase , (tuple, list) ):
UpperCAmelCase__ = [f'''{repo_id}--{v}''' if (v is not None and '--' not in v) else v for v in value]
elif value is not None and "--" not in value:
UpperCAmelCase__ = f'''{repo_id}--{value}'''
return auto_map
def a_ ( lowerCamelCase ):
for base_class in inspect.getmro(lowerCamelCase ):
UpperCAmelCase__ = base_class.__module__
UpperCAmelCase__ = base_class.__name__
if module.startswith('tensorflow' ) or module.startswith('keras' ) or name == "TFPreTrainedModel":
return "tf"
elif module.startswith('torch' ) or name == "PreTrainedModel":
return "pt"
elif module.startswith('flax' ) or module.startswith('jax' ) or name == "FlaxPreTrainedModel":
return "flax"
else:
raise TypeError(f'''Could not infer framework from class {model_class}.''' )
| 632 | 1 |
"""simple docstring"""
import importlib
import inspect
import json
import os
import re
import shutil
import sys
from pathlib import Path
from typing import Dict, Optional, Union
from urllib import request
from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info
from packaging import version
from .. import __version__
from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging
lowerCAmelCase__ : str = (
'https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py'
)
lowerCAmelCase__ : List[Any] = logging.get_logger(__name__) # pylint: disable=invalid-name
def a_ ( ):
UpperCAmelCase__ = 'https://pypi.org/pypi/diffusers/json'
UpperCAmelCase__ = json.loads(request.urlopen(lowerCamelCase ).read() )['releases'].keys()
return sorted(lowerCamelCase , key=lambda lowerCamelCase : version.Version(lowerCamelCase ) )
def a_ ( ):
# This function has already been executed if HF_MODULES_CACHE already is in the Python path.
if HF_MODULES_CACHE in sys.path:
return
sys.path.append(lowerCamelCase )
os.makedirs(lowerCamelCase , exist_ok=lowerCamelCase )
UpperCAmelCase__ = Path(lowerCamelCase ) / '__init__.py'
if not init_path.exists():
init_path.touch()
def a_ ( lowerCamelCase ):
init_hf_modules()
UpperCAmelCase__ = Path(lowerCamelCase ) / name
# If the parent module does not exist yet, recursively create it.
if not dynamic_module_path.parent.exists():
create_dynamic_module(dynamic_module_path.parent )
os.makedirs(lowerCamelCase , exist_ok=lowerCamelCase )
UpperCAmelCase__ = dynamic_module_path / '__init__.py'
if not init_path.exists():
init_path.touch()
def a_ ( lowerCamelCase ):
with open(lowerCamelCase , 'r' , encoding='utf-8' ) as f:
UpperCAmelCase__ = f.read()
# Imports of the form `import .xxx`
UpperCAmelCase__ = re.findall('^\s*import\s+\.(\S+)\s*$' , lowerCamelCase , flags=re.MULTILINE )
# Imports of the form `from .xxx import yyy`
relative_imports += re.findall('^\s*from\s+\.(\S+)\s+import' , lowerCamelCase , flags=re.MULTILINE )
# Unique-ify
return list(set(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = False
UpperCAmelCase__ = [module_file]
UpperCAmelCase__ = []
# Let's recurse through all relative imports
while not no_change:
UpperCAmelCase__ = []
for f in files_to_check:
new_imports.extend(get_relative_imports(lowerCamelCase ) )
UpperCAmelCase__ = Path(lowerCamelCase ).parent
UpperCAmelCase__ = [str(module_path / m ) for m in new_imports]
UpperCAmelCase__ = [f for f in new_import_files if f not in all_relative_imports]
UpperCAmelCase__ = [f'''{f}.py''' for f in new_import_files]
UpperCAmelCase__ = len(lowerCamelCase ) == 0
all_relative_imports.extend(lowerCamelCase )
return all_relative_imports
def a_ ( lowerCamelCase ):
with open(lowerCamelCase , 'r' , encoding='utf-8' ) as f:
UpperCAmelCase__ = f.read()
# Imports of the form `import xxx`
UpperCAmelCase__ = re.findall('^\s*import\s+(\S+)\s*$' , lowerCamelCase , flags=re.MULTILINE )
# Imports of the form `from xxx import yyy`
imports += re.findall('^\s*from\s+(\S+)\s+import' , lowerCamelCase , flags=re.MULTILINE )
# Only keep the top-level module
UpperCAmelCase__ = [imp.split('.' )[0] for imp in imports if not imp.startswith('.' )]
# Unique-ify and test we got them all
UpperCAmelCase__ = list(set(lowerCamelCase ) )
UpperCAmelCase__ = []
for imp in imports:
try:
importlib.import_module(lowerCamelCase )
except ImportError:
missing_packages.append(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ImportError(
'This modeling file requires the following packages that were not found in your environment: '
f'''{", ".join(lowerCamelCase )}. Run `pip install {" ".join(lowerCamelCase )}`''' )
return get_relative_imports(lowerCamelCase )
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = module_path.replace(os.path.sep , '.' )
UpperCAmelCase__ = importlib.import_module(lowerCamelCase )
if class_name is None:
return find_pipeline_class(lowerCamelCase )
return getattr(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase ):
from ..pipelines import DiffusionPipeline
UpperCAmelCase__ = dict(inspect.getmembers(lowerCamelCase , inspect.isclass ) )
UpperCAmelCase__ = None
for cls_name, cls in cls_members.items():
if (
cls_name != DiffusionPipeline.__name__
and issubclass(cls , lowerCamelCase )
and cls.__module__.split('.' )[0] != "diffusers"
):
if pipeline_class is not None:
raise ValueError(
f'''Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:'''
f''' {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in'''
f''' {loaded_module}.''' )
UpperCAmelCase__ = cls
return pipeline_class
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase = None , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = False , ):
UpperCAmelCase__ = str(lowerCamelCase )
UpperCAmelCase__ = os.path.join(lowerCamelCase , lowerCamelCase )
if os.path.isfile(lowerCamelCase ):
UpperCAmelCase__ = module_file_or_url
UpperCAmelCase__ = 'local'
elif pretrained_model_name_or_path.count('/' ) == 0:
UpperCAmelCase__ = get_diffusers_versions()
# cut ".dev0"
UpperCAmelCase__ = 'v' + '.'.join(__version__.split('.' )[:3] )
# retrieve github version that matches
if revision is None:
UpperCAmelCase__ = latest_version if latest_version[1:] in available_versions else 'main'
logger.info(f'''Defaulting to latest_version: {revision}.''' )
elif revision in available_versions:
UpperCAmelCase__ = f'''v{revision}'''
elif revision == "main":
UpperCAmelCase__ = revision
else:
raise ValueError(
f'''`custom_revision`: {revision} does not exist. Please make sure to choose one of'''
f''' {", ".join(available_versions + ["main"] )}.''' )
# community pipeline on GitHub
UpperCAmelCase__ = COMMUNITY_PIPELINES_URL.format(revision=lowerCamelCase , pipeline=lowerCamelCase )
try:
UpperCAmelCase__ = cached_download(
lowerCamelCase , cache_dir=lowerCamelCase , force_download=lowerCamelCase , proxies=lowerCamelCase , resume_download=lowerCamelCase , local_files_only=lowerCamelCase , use_auth_token=lowerCamelCase , )
UpperCAmelCase__ = 'git'
UpperCAmelCase__ = pretrained_model_name_or_path + '.py'
except EnvironmentError:
logger.error(f'''Could not locate the {module_file} inside {pretrained_model_name_or_path}.''' )
raise
else:
try:
# Load from URL or cache if already cached
UpperCAmelCase__ = hf_hub_download(
lowerCamelCase , lowerCamelCase , cache_dir=lowerCamelCase , force_download=lowerCamelCase , proxies=lowerCamelCase , resume_download=lowerCamelCase , local_files_only=lowerCamelCase , use_auth_token=lowerCamelCase , )
UpperCAmelCase__ = os.path.join('local' , '--'.join(pretrained_model_name_or_path.split('/' ) ) )
except EnvironmentError:
logger.error(f'''Could not locate the {module_file} inside {pretrained_model_name_or_path}.''' )
raise
# Check we have all the requirements in our environment
UpperCAmelCase__ = check_imports(lowerCamelCase )
# Now we move the module inside our cached dynamic modules.
UpperCAmelCase__ = DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
create_dynamic_module(lowerCamelCase )
UpperCAmelCase__ = Path(lowerCamelCase ) / full_submodule
if submodule == "local" or submodule == "git":
# We always copy local files (we could hash the file to see if there was a change, and give them the name of
# that hash, to only copy when there is a modification but it seems overkill for now).
# The only reason we do the copy is to avoid putting too many folders in sys.path.
shutil.copy(lowerCamelCase , submodule_path / module_file )
for module_needed in modules_needed:
UpperCAmelCase__ = f'''{module_needed}.py'''
shutil.copy(os.path.join(lowerCamelCase , lowerCamelCase ) , submodule_path / module_needed )
else:
# Get the commit hash
# TODO: we will get this info in the etag soon, so retrieve it from there and not here.
if isinstance(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = use_auth_token
elif use_auth_token is True:
UpperCAmelCase__ = HfFolder.get_token()
else:
UpperCAmelCase__ = None
UpperCAmelCase__ = model_info(lowerCamelCase , revision=lowerCamelCase , token=lowerCamelCase ).sha
# The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the
# benefit of versioning.
UpperCAmelCase__ = submodule_path / commit_hash
UpperCAmelCase__ = full_submodule + os.path.sep + commit_hash
create_dynamic_module(lowerCamelCase )
if not (submodule_path / module_file).exists():
shutil.copy(lowerCamelCase , submodule_path / module_file )
# Make sure we also have every file with relative
for module_needed in modules_needed:
if not (submodule_path / module_needed).exists():
get_cached_module_file(
lowerCamelCase , f'''{module_needed}.py''' , cache_dir=lowerCamelCase , force_download=lowerCamelCase , resume_download=lowerCamelCase , proxies=lowerCamelCase , use_auth_token=lowerCamelCase , revision=lowerCamelCase , local_files_only=lowerCamelCase , )
return os.path.join(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = False , lowerCamelCase = False , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = None , lowerCamelCase = False , **lowerCamelCase , ):
UpperCAmelCase__ = get_cached_module_file(
lowerCamelCase , lowerCamelCase , cache_dir=lowerCamelCase , force_download=lowerCamelCase , resume_download=lowerCamelCase , proxies=lowerCamelCase , use_auth_token=lowerCamelCase , revision=lowerCamelCase , local_files_only=lowerCamelCase , )
return get_class_in_module(lowerCamelCase , final_module.replace('.py' , '' ) )
| 632 | """simple docstring"""
import gc
import tempfile
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
lowerCAmelCase__ : Union[str, Any] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@nightly
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='numpy' ,).images
with tempfile.TemporaryDirectory() as tmpdirname:
pipe.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained(lowerCamelCase__ ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = generator.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,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 __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'cyberpunk 2077'
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.1_4_4_8, 0.1_6_1_9, 0.1_7_4_1, 0.1_0_8_6, 0.1_1_4_7, 0.1_1_2_8, 0.1_1_9_9, 0.1_1_6_5, 0.1_0_0_1] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = 'A painting of a squirrel eating a burger '
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.text_to_image(
prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_3_6_7, 0.3_1_6_9, 0.2_6_5_6, 0.3_8_7_0, 0.4_7_9_0, 0.3_7_9_6, 0.4_0_0_9, 0.4_8_7_8, 0.4_7_7_8] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = pipe.image_variation(lowerCamelCase__ ,generator=lowerCamelCase__ ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_0_7_6, 0.3_1_2_3, 0.3_2_8_4, 0.3_7_8_2, 0.3_7_7_0, 0.3_8_9_4, 0.4_2_9_7, 0.4_3_3_1, 0.4_4_5_6] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
| 632 | 1 |
"""simple docstring"""
from random import randint
from tempfile import TemporaryFile
import numpy as np
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = 0
if start < end:
UpperCAmelCase__ = randint(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = a[end]
UpperCAmelCase__ = a[pivot]
UpperCAmelCase__ = temp
UpperCAmelCase__ , UpperCAmelCase__ = _in_place_partition(lowerCamelCase , lowerCamelCase , lowerCamelCase )
count += _in_place_quick_sort(lowerCamelCase , lowerCamelCase , p - 1 )
count += _in_place_quick_sort(lowerCamelCase , p + 1 , lowerCamelCase )
return count
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = 0
UpperCAmelCase__ = randint(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = a[end]
UpperCAmelCase__ = a[pivot]
UpperCAmelCase__ = temp
UpperCAmelCase__ = start - 1
for index in range(lowerCamelCase , lowerCamelCase ):
count += 1
if a[index] < a[end]: # check if current val is less than pivot value
UpperCAmelCase__ = new_pivot_index + 1
UpperCAmelCase__ = a[new_pivot_index]
UpperCAmelCase__ = a[index]
UpperCAmelCase__ = temp
UpperCAmelCase__ = a[new_pivot_index + 1]
UpperCAmelCase__ = a[end]
UpperCAmelCase__ = temp
return new_pivot_index + 1, count
lowerCAmelCase__ : Union[str, Any] = TemporaryFile()
lowerCAmelCase__ : List[str] = 100 # 1000 elements are to be sorted
lowerCAmelCase__ , lowerCAmelCase__ : Optional[int] = 0, 1 # mean and standard deviation
lowerCAmelCase__ : int = np.random.normal(mu, sigma, p)
np.save(outfile, X)
print('The array is')
print(X)
outfile.seek(0) # using the same array
lowerCAmelCase__ : Optional[int] = np.load(outfile)
lowerCAmelCase__ : Optional[Any] = len(M) - 1
lowerCAmelCase__ : Optional[Any] = _in_place_quick_sort(M, 0, r)
print(
'No of Comparisons for 100 elements selected from a standard normal distribution'
'is :'
)
print(z)
| 632 | """simple docstring"""
from typing import Optional
import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin
from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]
@register_to_config
def __init__( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : int = 50_257 ,lowerCamelCase__ : int = 1_024 ,lowerCamelCase__ : int = 768 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "gelu_new" ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 1e-5 ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
super().__init__()
UpperCAmelCase__ = prefix_length
if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
raise ValueError(
f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
f''' `n_embd`: {n_embd} are not equal.''' )
UpperCAmelCase__ = prefix_inner_dim
UpperCAmelCase__ = prefix_hidden_dim
UpperCAmelCase__ = (
nn.Linear(self.prefix_inner_dim ,self.prefix_hidden_dim )
if self.prefix_hidden_dim is not None
else nn.Identity()
)
UpperCAmelCase__ = (
nn.Linear(self.prefix_hidden_dim ,lowerCamelCase__ ) if self.prefix_hidden_dim is not None else nn.Identity()
)
UpperCAmelCase__ = GPTaConfig(
vocab_size=lowerCamelCase__ ,n_positions=lowerCamelCase__ ,n_embd=lowerCamelCase__ ,n_layer=lowerCamelCase__ ,n_head=lowerCamelCase__ ,n_inner=lowerCamelCase__ ,activation_function=lowerCamelCase__ ,resid_pdrop=lowerCamelCase__ ,embd_pdrop=lowerCamelCase__ ,attn_pdrop=lowerCamelCase__ ,layer_norm_epsilon=lowerCamelCase__ ,initializer_range=lowerCamelCase__ ,scale_attn_weights=lowerCamelCase__ ,use_cache=lowerCamelCase__ ,scale_attn_by_inverse_layer_idx=lowerCamelCase__ ,reorder_and_upcast_attn=lowerCamelCase__ ,)
UpperCAmelCase__ = GPTaLMHeadModel(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : Optional[torch.Tensor] = None ,lowerCamelCase__ : Optional[torch.Tensor] = None ,):
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
UpperCAmelCase__ = self.encode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = self.decode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = torch.cat((prefix_embeds, embedding_text) ,dim=1 )
if labels is not None:
UpperCAmelCase__ = self.get_dummy_token(input_ids.shape[0] ,input_ids.device )
UpperCAmelCase__ = torch.cat((dummy_token, input_ids) ,dim=1 )
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ ,labels=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
if self.prefix_hidden_dim is not None:
return out, hidden
else:
return out
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : torch.device ):
return torch.zeros(lowerCamelCase__ ,self.prefix_length ,dtype=torch.intaa ,device=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[str] ):
return self.encode_prefix(lowerCamelCase__ )
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = torch.split(lowerCamelCase__ ,1 ,dim=0 )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for feature in features:
UpperCAmelCase__ = self.decode_prefix(feature.to(lowerCamelCase__ ) ) # back to the clip feature
# Only support beam search for now
UpperCAmelCase__ , UpperCAmelCase__ = self.generate_beam(
input_embeds=lowerCamelCase__ ,device=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
generated_tokens.append(output_tokens[0] )
generated_seq_lengths.append(seq_lengths[0] )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
return generated_tokens, generated_seq_lengths
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int = 5 ,lowerCamelCase__ : int = 67 ,lowerCamelCase__ : float = 1.0 ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = eos_token_id
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = torch.ones(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.int )
UpperCAmelCase__ = torch.zeros(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.bool )
if input_embeds is not None:
UpperCAmelCase__ = input_embeds
else:
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ )
UpperCAmelCase__ = outputs.logits
UpperCAmelCase__ = logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
UpperCAmelCase__ = logits.softmax(-1 ).log()
if scores is None:
UpperCAmelCase__ , UpperCAmelCase__ = logits.topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = generated.expand(lowerCamelCase__ ,*generated.shape[1:] )
UpperCAmelCase__ , UpperCAmelCase__ = next_tokens.permute(1 ,0 ), scores.squeeze(0 )
if tokens is None:
UpperCAmelCase__ = next_tokens
else:
UpperCAmelCase__ = tokens.expand(lowerCamelCase__ ,*tokens.shape[1:] )
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
else:
UpperCAmelCase__ = -float(np.inf )
UpperCAmelCase__ = 0
UpperCAmelCase__ = scores[:, None] + logits
seq_lengths[~is_stopped] += 1
UpperCAmelCase__ = scores_sum / seq_lengths[:, None]
UpperCAmelCase__ , UpperCAmelCase__ = scores_sum_average.view(-1 ).topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = next_tokens // scores_sum.shape[1]
UpperCAmelCase__ = seq_lengths[next_tokens_source]
UpperCAmelCase__ = next_tokens % scores_sum.shape[1]
UpperCAmelCase__ = next_tokens.unsqueeze(1 )
UpperCAmelCase__ = tokens[next_tokens_source]
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
UpperCAmelCase__ = generated[next_tokens_source]
UpperCAmelCase__ = scores_sum_average * seq_lengths
UpperCAmelCase__ = is_stopped[next_tokens_source]
UpperCAmelCase__ = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] ,1 ,-1 )
UpperCAmelCase__ = torch.cat((generated, next_token_embed) ,dim=1 )
UpperCAmelCase__ = is_stopped + next_tokens.eq(lowerCamelCase__ ).squeeze()
if is_stopped.all():
break
UpperCAmelCase__ = scores / seq_lengths
UpperCAmelCase__ = scores.argsort(descending=lowerCamelCase__ )
# tokens tensors are already padded to max_seq_length
UpperCAmelCase__ = [tokens[i] for i in order]
UpperCAmelCase__ = torch.stack(lowerCamelCase__ ,dim=0 )
UpperCAmelCase__ = torch.tensor([seq_lengths[i] for i in order] ,dtype=seq_lengths.dtype )
return output_texts, seq_lengths
| 632 | 1 |
"""simple docstring"""
import itertools
import math
def a_ ( lowerCamelCase ):
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(lowerCamelCase ) + 1 ) , 6 ):
if number % i == 0 or number % (i + 2) == 0:
return False
return True
def a_ ( ):
UpperCAmelCase__ = 2
while True:
if is_prime(lowerCamelCase ):
yield num
num += 1
def a_ ( lowerCamelCase = 1_0_0_0_1 ):
return next(itertools.islice(prime_generator() , nth - 1 , lowerCamelCase ) )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | """simple docstring"""
import argparse
import os
import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints
from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
lowerCAmelCase__ : str = 'base_with_context'
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['token_embedder']['embedding'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['input_proj']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['continuous_inputs_projection']['kernel'].T ) )
for lyr_num, lyr in enumerate(model.decoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_self_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_0']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['self_attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['MultiHeadDotProductAttention_0']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_cross_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_1']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['decoder_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['spec_out_dense']['kernel'].T ) )
return model
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = checkpoints.load_tax_checkpoint(args.checkpoint_path )
UpperCAmelCase__ = jnp.tree_util.tree_map(onp.array , lowerCamelCase )
UpperCAmelCase__ = [
'from __gin__ import dynamic_registration',
'from music_spectrogram_diffusion.models.diffusion import diffusion_utils',
'diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0',
'diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()',
]
UpperCAmelCase__ = os.path.join(args.checkpoint_path , '..' , 'config.gin' )
UpperCAmelCase__ = inference.parse_training_gin_file(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = inference.InferenceModel(args.checkpoint_path , lowerCamelCase )
UpperCAmelCase__ = DDPMScheduler(beta_schedule='squaredcos_cap_v2' , variance_type='fixed_large' )
UpperCAmelCase__ = SpectrogramNotesEncoder(
max_length=synth_model.sequence_length['inputs'] , vocab_size=synth_model.model.module.config.vocab_size , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = SpectrogramContEncoder(
input_dims=synth_model.audio_codec.n_dims , targets_context_length=synth_model.sequence_length['targets_context'] , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = TaFilmDecoder(
input_dims=synth_model.audio_codec.n_dims , targets_length=synth_model.sequence_length['targets_context'] , max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time , d_model=synth_model.model.module.config.emb_dim , num_layers=synth_model.model.module.config.num_decoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , dropout_rate=synth_model.model.module.config.dropout_rate , )
UpperCAmelCase__ = load_notes_encoder(ta_checkpoint['target']['token_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_continuous_encoder(ta_checkpoint['target']['continuous_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_decoder(ta_checkpoint['target']['decoder'] , lowerCamelCase )
UpperCAmelCase__ = OnnxRuntimeModel.from_pretrained('kashif/soundstream_mel_decoder' )
UpperCAmelCase__ = SpectrogramDiffusionPipeline(
notes_encoder=lowerCamelCase , continuous_encoder=lowerCamelCase , decoder=lowerCamelCase , scheduler=lowerCamelCase , melgan=lowerCamelCase , )
if args.save:
pipe.save_pretrained(args.output_path )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
parser.add_argument('--output_path', default=None, type=str, required=True, help='Path to the converted model.')
parser.add_argument(
'--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
)
parser.add_argument(
'--checkpoint_path',
default=F"""{MODEL}/checkpoint_500000""",
type=str,
required=False,
help='Path to the original jax model checkpoint.',
)
lowerCAmelCase__ : List[str] = parser.parse_args()
main(args)
| 632 | 1 |
"""simple docstring"""
import requests
from bsa import BeautifulSoup
def a_ ( lowerCamelCase = "AAPL" ):
UpperCAmelCase__ = f'''https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'''
UpperCAmelCase__ = BeautifulSoup(requests.get(lowerCamelCase ).text , 'html.parser' )
UpperCAmelCase__ = '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}""")
| 632 | """simple docstring"""
import socket
def a_ ( ):
UpperCAmelCase__ = socket.socket(socket.AF_INET , socket.SOCK_STREAM )
UpperCAmelCase__ = socket.gethostname()
UpperCAmelCase__ = 1_2_3_1_2
sock.connect((host, port) )
sock.send(b'Hello server!' )
with open('Received_file' , 'wb' ) as out_file:
print('File opened' )
print('Receiving data...' )
while True:
UpperCAmelCase__ = sock.recv(1_0_2_4 )
if not data:
break
out_file.write(lowerCamelCase )
print('Successfully received the file' )
sock.close()
print('Connection closed' )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
from __future__ import annotations
import collections
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available
from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester
if is_tf_available():
from transformers import (
TFBertModel,
TFCLIPVisionModel,
TFDeiTModel,
TFRobertaModel,
TFVisionTextDualEncoderModel,
TFViTModel,
VisionTextDualEncoderConfig,
)
if is_vision_available():
from PIL import Image
from transformers import VisionTextDualEncoderProcessor
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , collections.abc.Iterable ):
return x
return (x, x)
@require_tf
class snake_case :
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[Any] ):
pass
def __lowerCAmelCase ( self : str ):
pass
def __lowerCAmelCase ( self : List[Any] ):
pass
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : Dict ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : str ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : List[str]=None ,**lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel(lowerCamelCase__ )
UpperCAmelCase__ = model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
self.assertEqual(output['text_embeds'].shape ,(input_ids.shape[0], config.projection_dim) )
self.assertEqual(output['image_embeds'].shape ,(pixel_values.shape[0], config.projection_dim) )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Optional[int]=None ,**lowerCamelCase__ : Any ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel(vision_model=lowerCamelCase__ ,text_model=lowerCamelCase__ )
UpperCAmelCase__ = model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
self.assertEqual(output['text_embeds'].shape ,(input_ids.shape[0], model.config.projection_dim) )
self.assertEqual(output['image_embeds'].shape ,(pixel_values.shape[0], model.config.projection_dim) )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : str ,lowerCamelCase__ : List[str]=None ,**lowerCamelCase__ : Union[str, Any] ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = {'vision_model': vision_model, 'text_model': text_model}
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__ )
UpperCAmelCase__ = model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
self.assertEqual(output['text_embeds'].shape ,(input_ids.shape[0], model.config.projection_dim) )
self.assertEqual(output['image_embeds'].shape ,(pixel_values.shape[0], model.config.projection_dim) )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Dict ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int]=None ,**lowerCamelCase__ : Union[str, Any] ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel(vision_model=lowerCamelCase__ ,text_model=lowerCamelCase__ )
UpperCAmelCase__ = model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
UpperCAmelCase__ = output[0].numpy()
with tempfile.TemporaryDirectory() as tmpdirname:
model.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = model(input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
UpperCAmelCase__ = after_output[0].numpy()
UpperCAmelCase__ = np.amax(np.abs(out_a - out_a ) )
self.assertLessEqual(lowerCamelCase__ ,1e-5 )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Dict ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : List[Any]=None ,**lowerCamelCase__ : Dict ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel(vision_model=lowerCamelCase__ ,text_model=lowerCamelCase__ )
UpperCAmelCase__ = model(
input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ ,output_attentions=lowerCamelCase__ )
UpperCAmelCase__ = output.vision_model_output.attentions
self.assertEqual(len(lowerCamelCase__ ) ,vision_config.num_hidden_layers )
# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
UpperCAmelCase__ = to_atuple(vision_model.config.image_size )
UpperCAmelCase__ = to_atuple(vision_model.config.patch_size )
UpperCAmelCase__ = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
UpperCAmelCase__ = num_patches + 1
self.assertEqual(vision_attentions[0].shape[-3:] ,(vision_config.num_attention_heads, seq_len, seq_len) )
UpperCAmelCase__ = output.text_model_output.attentions
self.assertEqual(len(lowerCamelCase__ ) ,text_config.num_hidden_layers )
self.assertEqual(
text_attentions[0].shape[-3:] ,(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,)
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : float ):
UpperCAmelCase__ = np.abs((a - b) ).max()
self.assertLessEqual(lowerCamelCase__ ,lowerCamelCase__ ,f'''Difference between torch and flax is {diff} (>= {tol}).''' )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
self.check_vision_text_dual_encoder_model(**lowerCamelCase__ )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
self.check_model_from_pretrained_configs(**lowerCamelCase__ )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
self.check_save_load(**lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
self.check_vision_text_output_attention(**lowerCamelCase__ )
@slow
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_pretrained_model_and_inputs()
UpperCAmelCase__ = model_a(**lowerCamelCase__ )
UpperCAmelCase__ = outputs[0].numpy()
with tempfile.TemporaryDirectory() as tmp_dirname:
model_a.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = model_a(**lowerCamelCase__ )
UpperCAmelCase__ = after_outputs[0].numpy()
UpperCAmelCase__ = np.amax(np.abs(out_a - out_a ) )
self.assertLessEqual(lowerCamelCase__ ,1e-5 )
@require_tf
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_vision_text_pretrained(
'hf-internal-testing/tiny-random-vit' ,'hf-internal-testing/tiny-random-bert' )
UpperCAmelCase__ = 13
UpperCAmelCase__ = floats_tensor(
[
batch_size,
model.vision_model.config.num_channels,
model.vision_model.config.image_size,
model.vision_model.config.image_size,
] )
UpperCAmelCase__ = ids_tensor([batch_size, 4] ,model.text_model.config.vocab_size )
UpperCAmelCase__ = random_attention_mask([batch_size, 4] )
UpperCAmelCase__ = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}
return model, inputs
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : int ):
UpperCAmelCase__ = TFViTModel(lowerCamelCase__ ,name='vision_model' )
UpperCAmelCase__ = TFBertModel(lowerCamelCase__ ,name='text_model' )
return vision_model, text_model
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = TFViTModelTester(self )
UpperCAmelCase__ = TFBertModelTester(self )
UpperCAmelCase__ = vit_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ = bert_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = vision_config_and_inputs
(
(
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) ,
) = text_config_and_inputs
return {
"text_config": text_config,
"vision_config": vision_config,
"pixel_values": pixel_values,
"attention_mask": input_mask,
"input_ids": input_ids,
"text_token_type_ids": token_type_ids,
"text_sequence_labels": sequence_labels,
"text_token_labels": token_labels,
"text_choice_labels": choice_labels,
}
@require_tf
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : int ):
# DeiT repo doesn't have TF weights, but we don't actually use the weights at all so let's
# just reinitialize it.
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_vision_text_pretrained(
'Rocketknight1/tiny-random-deit-tf' ,'hf-internal-testing/tiny-random-roberta' )
UpperCAmelCase__ = 13
UpperCAmelCase__ = floats_tensor(
[
batch_size,
model.vision_model.config.num_channels,
model.vision_model.config.image_size,
model.vision_model.config.image_size,
] )
UpperCAmelCase__ = ids_tensor([batch_size, 4] ,model.text_model.config.vocab_size )
UpperCAmelCase__ = random_attention_mask([batch_size, 4] )
UpperCAmelCase__ = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}
return model, inputs
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Any ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Any ,lowerCamelCase__ : Dict ,lowerCamelCase__ : Tuple=None ,**lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ , UpperCAmelCase__ = self.get_vision_text_model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = TFVisionTextDualEncoderModel(vision_model=lowerCamelCase__ ,text_model=lowerCamelCase__ )
UpperCAmelCase__ = model(
input_ids=lowerCamelCase__ ,pixel_values=lowerCamelCase__ ,attention_mask=lowerCamelCase__ ,output_attentions=lowerCamelCase__ )
UpperCAmelCase__ = output.vision_model_output.attentions
self.assertEqual(len(lowerCamelCase__ ) ,vision_config.num_hidden_layers )
# in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
UpperCAmelCase__ = to_atuple(vision_model.config.image_size )
UpperCAmelCase__ = to_atuple(vision_model.config.patch_size )
UpperCAmelCase__ = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
UpperCAmelCase__ = num_patches + 2
self.assertEqual(vision_attentions[0].shape[-3:] ,(vision_config.num_attention_heads, seq_len, seq_len) )
UpperCAmelCase__ = output.text_model_output.attentions
self.assertEqual(len(lowerCamelCase__ ) ,text_config.num_hidden_layers )
self.assertEqual(
text_attentions[0].shape[-3:] ,(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,)
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Any ,lowerCamelCase__ : Dict ):
UpperCAmelCase__ = TFDeiTModel(lowerCamelCase__ ,name='vision_model' )
UpperCAmelCase__ = TFRobertaModel(lowerCamelCase__ ,name='text_model' )
return vision_model, text_model
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = TFDeiTModelTester(self )
UpperCAmelCase__ = TFRobertaModelTester(self )
UpperCAmelCase__ = vit_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ = bert_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = vision_config_and_inputs
(
(
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) ,
) = text_config_and_inputs
return {
"text_config": text_config,
"vision_config": vision_config,
"pixel_values": pixel_values,
"attention_mask": input_mask,
"input_ids": input_ids,
"text_token_type_ids": token_type_ids,
"text_sequence_labels": sequence_labels,
"text_token_labels": token_labels,
"text_choice_labels": choice_labels,
}
@require_tf
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_vision_text_pretrained(
'Rocketknight1/tiny-random-clip-tf' ,'hf-internal-testing/tiny-random-bert' )
UpperCAmelCase__ = 13
UpperCAmelCase__ = floats_tensor(
[
batch_size,
model.vision_model.config.num_channels,
model.vision_model.config.image_size,
model.vision_model.config.image_size,
] )
UpperCAmelCase__ = ids_tensor([batch_size, 4] ,model.text_model.config.vocab_size )
UpperCAmelCase__ = random_attention_mask([batch_size, 4] )
UpperCAmelCase__ = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}
return model, inputs
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : int ):
UpperCAmelCase__ = TFCLIPVisionModel(lowerCamelCase__ ,name='vision_model' )
UpperCAmelCase__ = TFBertModel(lowerCamelCase__ ,name='text_model' )
return vision_model, text_model
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = TFCLIPVisionModelTester(self )
UpperCAmelCase__ = TFBertModelTester(self )
UpperCAmelCase__ = clip_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ = bert_model_tester.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ = vision_config_and_inputs
(
(
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) ,
) = text_config_and_inputs
return {
"text_config": text_config,
"vision_config": vision_config,
"pixel_values": pixel_values,
"attention_mask": input_mask,
"input_ids": input_ids,
"text_token_type_ids": token_type_ids,
"text_sequence_labels": sequence_labels,
"text_token_labels": token_labels,
"text_choice_labels": choice_labels,
}
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@slow
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = TFVisionTextDualEncoderModel.from_pretrained(
'clip-italian/clip-italian' ,logit_scale_init_value=1.0 ,from_pt=lowerCamelCase__ )
UpperCAmelCase__ = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian' )
UpperCAmelCase__ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
UpperCAmelCase__ = processor(
text=['una foto di un gatto', 'una foto di un cane'] ,images=lowerCamelCase__ ,padding=lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = model(**lowerCamelCase__ )
# verify the logits
self.assertEqual(outputs.logits_per_image.shape ,(inputs.pixel_values.shape[0], inputs.input_ids.shape[0]) )
self.assertEqual(
outputs.logits_per_text.shape ,(inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) ,)
UpperCAmelCase__ = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]] )
self.assertTrue(np.allclose(outputs.logits_per_image.numpy() ,lowerCamelCase__ ,atol=1e-3 ) )
| 632 | """simple docstring"""
from __future__ import annotations
class snake_case :
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : list[list[int]] ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = 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
UpperCAmelCase__ = rows
else:
UpperCAmelCase__ = []
def __lowerCAmelCase ( self : Union[str, Any] ):
return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]
@property
def __lowerCAmelCase ( self : str ):
return len(self.rows )
@property
def __lowerCAmelCase ( self : List[Any] ):
return len(self.rows[0] )
@property
def __lowerCAmelCase ( self : Any ):
return (self.num_rows, self.num_columns)
@property
def __lowerCAmelCase ( self : Optional[int] ):
return self.order[0] == self.order[1]
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = [
[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 __lowerCAmelCase ( self : str ):
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 __lowerCAmelCase ( self : List[str] ):
return bool(self.determinant() )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
UpperCAmelCase__ = [
[
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 __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if (row + column) % 2 == 0:
return self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
return -1 * self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
return Matrix(
[
[self.get_minor(lowerCamelCase__ ,lowerCamelCase__ ) for column in range(self.num_columns )]
for row in range(self.num_rows )
] )
def __lowerCAmelCase ( self : int ):
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 __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = [
[self.cofactors().rows[column][row] for column in range(self.num_columns )]
for row in range(self.num_rows )
]
return Matrix(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = 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 : Optional[Any] ):
return str(self.rows )
def __str__( self : List[str] ):
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 __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = self.rows[0:position] + [row] + self.rows[position:]
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = [self.rows[i] + [column[i]] for i in range(self.num_rows )]
else:
UpperCAmelCase__ = [
self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
for i in range(self.num_rows )
]
def __eq__( self : List[Any] ,lowerCamelCase__ : object ):
if not isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
return NotImplemented
return self.rows == other.rows
def __ne__( self : Any ,lowerCamelCase__ : object ):
return not self == other
def __neg__( self : Dict ):
return self * -1
def __add__( self : str ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix | int | float ):
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 ):
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' )
UpperCAmelCase__ = self
for _ in range(other - 1 ):
result *= self
return result
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
return sum(row[i] * column[i] for i in range(len(lowerCamelCase__ ) ) )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase ):
if not isinstance(lowerCamelCase , lowerCamelCase ):
raise TypeError('only integers accepted as input' )
else:
UpperCAmelCase__ = str(abs(lowerCamelCase ) )
UpperCAmelCase__ = [list(lowerCamelCase ) for char in range(len(lowerCamelCase ) )]
for index in range(len(lowerCamelCase ) ):
num_transpositions[index].pop(lowerCamelCase )
return max(
int(''.join(list(lowerCamelCase ) ) ) for transposition in num_transpositions )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | """simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
lowerCAmelCase__ : int = {
'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
'tokenization_tapas': ['TapasTokenizer'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Union[str, Any] = [
'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TapasForMaskedLM',
'TapasForQuestionAnswering',
'TapasForSequenceClassification',
'TapasModel',
'TapasPreTrainedModel',
'load_tf_weights_in_tapas',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFTapasForMaskedLM',
'TFTapasForQuestionAnswering',
'TFTapasForSequenceClassification',
'TFTapasModel',
'TFTapasPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
from .tokenization_tapas import TapasTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tapas import (
TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
TapasPreTrainedModel,
load_tf_weights_in_tapas,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_tapas import (
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTapasForMaskedLM,
TFTapasForQuestionAnswering,
TFTapasForSequenceClassification,
TFTapasModel,
TFTapasPreTrainedModel,
)
else:
import sys
lowerCAmelCase__ : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | 1 |
"""simple docstring"""
from typing import Optional
import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin
from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]
@register_to_config
def __init__( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : int = 50_257 ,lowerCamelCase__ : int = 1_024 ,lowerCamelCase__ : int = 768 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "gelu_new" ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 1e-5 ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
super().__init__()
UpperCAmelCase__ = prefix_length
if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
raise ValueError(
f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
f''' `n_embd`: {n_embd} are not equal.''' )
UpperCAmelCase__ = prefix_inner_dim
UpperCAmelCase__ = prefix_hidden_dim
UpperCAmelCase__ = (
nn.Linear(self.prefix_inner_dim ,self.prefix_hidden_dim )
if self.prefix_hidden_dim is not None
else nn.Identity()
)
UpperCAmelCase__ = (
nn.Linear(self.prefix_hidden_dim ,lowerCamelCase__ ) if self.prefix_hidden_dim is not None else nn.Identity()
)
UpperCAmelCase__ = GPTaConfig(
vocab_size=lowerCamelCase__ ,n_positions=lowerCamelCase__ ,n_embd=lowerCamelCase__ ,n_layer=lowerCamelCase__ ,n_head=lowerCamelCase__ ,n_inner=lowerCamelCase__ ,activation_function=lowerCamelCase__ ,resid_pdrop=lowerCamelCase__ ,embd_pdrop=lowerCamelCase__ ,attn_pdrop=lowerCamelCase__ ,layer_norm_epsilon=lowerCamelCase__ ,initializer_range=lowerCamelCase__ ,scale_attn_weights=lowerCamelCase__ ,use_cache=lowerCamelCase__ ,scale_attn_by_inverse_layer_idx=lowerCamelCase__ ,reorder_and_upcast_attn=lowerCamelCase__ ,)
UpperCAmelCase__ = GPTaLMHeadModel(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : Optional[torch.Tensor] = None ,lowerCamelCase__ : Optional[torch.Tensor] = None ,):
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
UpperCAmelCase__ = self.encode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = self.decode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = torch.cat((prefix_embeds, embedding_text) ,dim=1 )
if labels is not None:
UpperCAmelCase__ = self.get_dummy_token(input_ids.shape[0] ,input_ids.device )
UpperCAmelCase__ = torch.cat((dummy_token, input_ids) ,dim=1 )
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ ,labels=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
if self.prefix_hidden_dim is not None:
return out, hidden
else:
return out
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : torch.device ):
return torch.zeros(lowerCamelCase__ ,self.prefix_length ,dtype=torch.intaa ,device=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[str] ):
return self.encode_prefix(lowerCamelCase__ )
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = torch.split(lowerCamelCase__ ,1 ,dim=0 )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for feature in features:
UpperCAmelCase__ = self.decode_prefix(feature.to(lowerCamelCase__ ) ) # back to the clip feature
# Only support beam search for now
UpperCAmelCase__ , UpperCAmelCase__ = self.generate_beam(
input_embeds=lowerCamelCase__ ,device=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
generated_tokens.append(output_tokens[0] )
generated_seq_lengths.append(seq_lengths[0] )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
return generated_tokens, generated_seq_lengths
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int = 5 ,lowerCamelCase__ : int = 67 ,lowerCamelCase__ : float = 1.0 ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = eos_token_id
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = torch.ones(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.int )
UpperCAmelCase__ = torch.zeros(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.bool )
if input_embeds is not None:
UpperCAmelCase__ = input_embeds
else:
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ )
UpperCAmelCase__ = outputs.logits
UpperCAmelCase__ = logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
UpperCAmelCase__ = logits.softmax(-1 ).log()
if scores is None:
UpperCAmelCase__ , UpperCAmelCase__ = logits.topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = generated.expand(lowerCamelCase__ ,*generated.shape[1:] )
UpperCAmelCase__ , UpperCAmelCase__ = next_tokens.permute(1 ,0 ), scores.squeeze(0 )
if tokens is None:
UpperCAmelCase__ = next_tokens
else:
UpperCAmelCase__ = tokens.expand(lowerCamelCase__ ,*tokens.shape[1:] )
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
else:
UpperCAmelCase__ = -float(np.inf )
UpperCAmelCase__ = 0
UpperCAmelCase__ = scores[:, None] + logits
seq_lengths[~is_stopped] += 1
UpperCAmelCase__ = scores_sum / seq_lengths[:, None]
UpperCAmelCase__ , UpperCAmelCase__ = scores_sum_average.view(-1 ).topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = next_tokens // scores_sum.shape[1]
UpperCAmelCase__ = seq_lengths[next_tokens_source]
UpperCAmelCase__ = next_tokens % scores_sum.shape[1]
UpperCAmelCase__ = next_tokens.unsqueeze(1 )
UpperCAmelCase__ = tokens[next_tokens_source]
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
UpperCAmelCase__ = generated[next_tokens_source]
UpperCAmelCase__ = scores_sum_average * seq_lengths
UpperCAmelCase__ = is_stopped[next_tokens_source]
UpperCAmelCase__ = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] ,1 ,-1 )
UpperCAmelCase__ = torch.cat((generated, next_token_embed) ,dim=1 )
UpperCAmelCase__ = is_stopped + next_tokens.eq(lowerCamelCase__ ).squeeze()
if is_stopped.all():
break
UpperCAmelCase__ = scores / seq_lengths
UpperCAmelCase__ = scores.argsort(descending=lowerCamelCase__ )
# tokens tensors are already padded to max_seq_length
UpperCAmelCase__ = [tokens[i] for i in order]
UpperCAmelCase__ = torch.stack(lowerCamelCase__ ,dim=0 )
UpperCAmelCase__ = torch.tensor([seq_lengths[i] for i in order] ,dtype=seq_lengths.dtype )
return output_texts, seq_lengths
| 632 | """simple docstring"""
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device
lowerCAmelCase__ : Optional[int] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@slow
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe(
image=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.0_4_4_1, 0.0_4_6_9, 0.0_5_0_7, 0.0_5_7_5, 0.0_6_3_2, 0.0_6_5_0, 0.0_8_6_5, 0.0_9_0_9, 0.0_9_4_5] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 632 | 1 |
"""simple docstring"""
from __future__ import annotations
from math import ceil, floor, sqrt
def a_ ( lowerCamelCase = 2_0_0_0_0_0_0 ):
UpperCAmelCase__ = [0]
UpperCAmelCase__ = 42
for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ):
triangle_numbers.append(triangle_numbers[-1] + idx )
# we want this to be as close as possible to target
UpperCAmelCase__ = 0
# the area corresponding to the grid that gives the product closest to target
UpperCAmelCase__ = 0
# an estimate of b, using the quadratic formula
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the triangle number corresponding to b_floor
UpperCAmelCase__ = 42
# the triangle number corresponding to b_ceil
UpperCAmelCase__ = 42
for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ):
UpperCAmelCase__ = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2
UpperCAmelCase__ = floor(lowerCamelCase )
UpperCAmelCase__ = ceil(lowerCamelCase )
UpperCAmelCase__ = triangle_numbers[b_floor]
UpperCAmelCase__ = triangle_numbers[b_ceil]
if abs(target - triangle_b_first_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_first_guess * triangle_a
UpperCAmelCase__ = idx_a * b_floor
if abs(target - triangle_b_second_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_second_guess * triangle_a
UpperCAmelCase__ = idx_a * b_ceil
return area
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | """simple docstring"""
from __future__ import annotations
from math import ceil, floor, sqrt
def a_ ( lowerCamelCase = 2_0_0_0_0_0_0 ):
UpperCAmelCase__ = [0]
UpperCAmelCase__ = 42
for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ):
triangle_numbers.append(triangle_numbers[-1] + idx )
# we want this to be as close as possible to target
UpperCAmelCase__ = 0
# the area corresponding to the grid that gives the product closest to target
UpperCAmelCase__ = 0
# an estimate of b, using the quadratic formula
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the triangle number corresponding to b_floor
UpperCAmelCase__ = 42
# the triangle number corresponding to b_ceil
UpperCAmelCase__ = 42
for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ):
UpperCAmelCase__ = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2
UpperCAmelCase__ = floor(lowerCamelCase )
UpperCAmelCase__ = ceil(lowerCamelCase )
UpperCAmelCase__ = triangle_numbers[b_floor]
UpperCAmelCase__ = triangle_numbers[b_ceil]
if abs(target - triangle_b_first_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_first_guess * triangle_a
UpperCAmelCase__ = idx_a * b_floor
if abs(target - triangle_b_second_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_second_guess * triangle_a
UpperCAmelCase__ = idx_a * b_ceil
return area
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | """simple docstring"""
import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple
import torch
from audiocraft.models import MusicGen
from transformers import (
AutoFeatureExtractor,
AutoTokenizer,
EncodecModel,
MusicgenDecoderConfig,
MusicgenForConditionalGeneration,
MusicgenProcessor,
TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging
logging.set_verbosity_info()
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[Any] = ['model.decoder.embed_positions.weights']
def a_ ( lowerCamelCase ):
if "emb" in name:
UpperCAmelCase__ = name.replace('emb' , 'model.decoder.embed_tokens' )
if "transformer" in name:
UpperCAmelCase__ = name.replace('transformer' , 'model.decoder' )
if "cross_attention" in name:
UpperCAmelCase__ = name.replace('cross_attention' , 'encoder_attn' )
if "linear1" in name:
UpperCAmelCase__ = name.replace('linear1' , 'fc1' )
if "linear2" in name:
UpperCAmelCase__ = name.replace('linear2' , 'fc2' )
if "norm1" in name:
UpperCAmelCase__ = name.replace('norm1' , 'self_attn_layer_norm' )
if "norm_cross" in name:
UpperCAmelCase__ = name.replace('norm_cross' , 'encoder_attn_layer_norm' )
if "norm2" in name:
UpperCAmelCase__ = name.replace('norm2' , 'final_layer_norm' )
if "out_norm" in name:
UpperCAmelCase__ = name.replace('out_norm' , 'model.decoder.layer_norm' )
if "linears" in name:
UpperCAmelCase__ = name.replace('linears' , 'lm_heads' )
if "condition_provider.conditioners.description.output_proj" in name:
UpperCAmelCase__ = name.replace('condition_provider.conditioners.description.output_proj' , 'enc_to_dec_proj' )
return name
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(state_dict.keys() )
UpperCAmelCase__ = {}
for key in keys:
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
UpperCAmelCase__ = rename_keys(lowerCamelCase )
if "in_proj_weight" in key:
# split fused qkv proj
UpperCAmelCase__ = val[:hidden_size, :]
UpperCAmelCase__ = val[hidden_size : 2 * hidden_size, :]
UpperCAmelCase__ = val[-hidden_size:, :]
elif "enc_to_dec_proj" in key:
UpperCAmelCase__ = val
else:
UpperCAmelCase__ = val
return state_dict, enc_dec_proj_state_dict
def a_ ( lowerCamelCase ):
if checkpoint == "small":
# default config values
UpperCAmelCase__ = 1_0_2_4
UpperCAmelCase__ = 2_4
UpperCAmelCase__ = 1_6
elif checkpoint == "medium":
UpperCAmelCase__ = 1_5_3_6
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 2_4
elif checkpoint == "large":
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 3_2
else:
raise ValueError(f'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' )
UpperCAmelCase__ = MusicgenDecoderConfig(
hidden_size=lowerCamelCase , ffn_dim=hidden_size * 4 , num_hidden_layers=lowerCamelCase , num_attention_heads=lowerCamelCase , )
return config
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase="cpu" ):
UpperCAmelCase__ = MusicGen.get_pretrained(lowerCamelCase , device=lowerCamelCase )
UpperCAmelCase__ = decoder_config_from_checkpoint(lowerCamelCase )
UpperCAmelCase__ = fairseq_model.lm.state_dict()
UpperCAmelCase__ , UpperCAmelCase__ = rename_state_dict(
lowerCamelCase , hidden_size=decoder_config.hidden_size )
UpperCAmelCase__ = TaEncoderModel.from_pretrained('t5-base' )
UpperCAmelCase__ = EncodecModel.from_pretrained('facebook/encodec_32khz' )
UpperCAmelCase__ = MusicgenForCausalLM(lowerCamelCase ).eval()
# load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
UpperCAmelCase__ , UpperCAmelCase__ = decoder.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
for key in missing_keys.copy():
if key.startswith(('text_encoder', 'audio_encoder') ) or key in EXPECTED_MISSING_KEYS:
missing_keys.remove(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Missing key(s) in state_dict: {missing_keys}''' )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Unexpected key(s) in state_dict: {unexpected_keys}''' )
# init the composite model
UpperCAmelCase__ = MusicgenForConditionalGeneration(text_encoder=lowerCamelCase , audio_encoder=lowerCamelCase , decoder=lowerCamelCase )
# load the pre-trained enc-dec projection (from the decoder state dict)
model.enc_to_dec_proj.load_state_dict(lowerCamelCase )
# check we can do a forward pass
UpperCAmelCase__ = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 )
UpperCAmelCase__ = input_ids.reshape(2 * 4 , -1 )
with torch.no_grad():
UpperCAmelCase__ = model(input_ids=lowerCamelCase , decoder_input_ids=lowerCamelCase ).logits
if logits.shape != (8, 1, 2_0_4_8):
raise ValueError('Incorrect shape for logits' )
# now construct the processor
UpperCAmelCase__ = AutoTokenizer.from_pretrained('t5-base' )
UpperCAmelCase__ = AutoFeatureExtractor.from_pretrained('facebook/encodec_32khz' , padding_side='left' )
UpperCAmelCase__ = MusicgenProcessor(feature_extractor=lowerCamelCase , tokenizer=lowerCamelCase )
# set the appropriate bos/pad token ids
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 2_0_4_8
# set other default generation config params
UpperCAmelCase__ = int(3_0 * audio_encoder.config.frame_rate )
UpperCAmelCase__ = True
UpperCAmelCase__ = 3.0
if pytorch_dump_folder is not None:
Path(lowerCamelCase ).mkdir(exist_ok=lowerCamelCase )
logger.info(f'''Saving model {checkpoint} to {pytorch_dump_folder}''' )
model.save_pretrained(lowerCamelCase )
processor.save_pretrained(lowerCamelCase )
if repo_id:
logger.info(f'''Pushing model {checkpoint} to {repo_id}''' )
model.push_to_hub(lowerCamelCase )
processor.push_to_hub(lowerCamelCase )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--checkpoint',
default='small',
type=str,
help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
)
parser.add_argument(
'--pytorch_dump_folder',
required=True,
default=None,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
)
parser.add_argument(
'--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
)
lowerCAmelCase__ : List[str] = parser.parse_args()
convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
| 632 | 1 |
"""simple docstring"""
import json
import os
import unittest
from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow
from ...test_tokenization_common import TokenizerTesterMixin
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = DebertaTokenizer
snake_case__ = True
snake_case__ = DebertaTokenizerFast
def __lowerCAmelCase ( self : Union[str, Any] ):
super().setUp()
# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
UpperCAmelCase__ = [
'l',
'o',
'w',
'e',
'r',
's',
't',
'i',
'd',
'n',
'\u0120',
'\u0120l',
'\u0120n',
'\u0120lo',
'\u0120low',
'er',
'\u0120lowest',
'\u0120newer',
'\u0120wider',
'[UNK]',
]
UpperCAmelCase__ = dict(zip(lowerCamelCase__ ,range(len(lowerCamelCase__ ) ) ) )
UpperCAmelCase__ = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
UpperCAmelCase__ = {'unk_token': '[UNK]'}
UpperCAmelCase__ = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES['vocab_file'] )
UpperCAmelCase__ = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES['merges_file'] )
with open(self.vocab_file ,'w' ,encoding='utf-8' ) as fp:
fp.write(json.dumps(lowerCamelCase__ ) + '\n' )
with open(self.merges_file ,'w' ,encoding='utf-8' ) as fp:
fp.write('\n'.join(lowerCamelCase__ ) )
def __lowerCAmelCase ( self : Tuple ,**lowerCamelCase__ : Optional[int] ):
kwargs.update(self.special_tokens_map )
return self.tokenizer_class.from_pretrained(self.tmpdirname ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : Any ):
UpperCAmelCase__ = 'lower newer'
UpperCAmelCase__ = 'lower newer'
return input_text, output_text
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_tokenizer()
UpperCAmelCase__ = 'lower newer'
UpperCAmelCase__ = ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
UpperCAmelCase__ = tokenizer.tokenize(lowerCamelCase__ )
self.assertListEqual(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = tokens + [tokenizer.unk_token]
UpperCAmelCase__ = [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_tokenizer()
UpperCAmelCase__ = tokenizer('Hello' ,'World' )
UpperCAmelCase__ = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
self.assertListEqual(tokd['token_type_ids'] ,lowerCamelCase__ )
@slow
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.tokenizer_class.from_pretrained('microsoft/deberta-base' )
UpperCAmelCase__ = tokenizer.encode('sequence builders' ,add_special_tokens=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode('multi-sequence build' ,add_special_tokens=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode(
'sequence builders' ,add_special_tokens=lowerCamelCase__ ,add_prefix_space=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.encode(
'sequence builders' ,'multi-sequence build' ,add_special_tokens=lowerCamelCase__ ,add_prefix_space=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ,lowerCamelCase__ )
assert encoded_sentence == encoded_text_from_decode
assert encoded_pair == encoded_pair_from_decode
@slow
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = [self.tokenizer_class]
if self.test_rust_tokenizer:
tokenizer_classes.append(self.rust_tokenizer_class )
for tokenizer_class in tokenizer_classes:
UpperCAmelCase__ = tokenizer_class.from_pretrained('microsoft/deberta-base' )
UpperCAmelCase__ = [
'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
'ALBERT incorporates two parameter reduction techniques',
'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
' vocabulary embedding.',
]
UpperCAmelCase__ = tokenizer(lowerCamelCase__ ,padding=lowerCamelCase__ )
UpperCAmelCase__ = [tokenizer.decode(lowerCamelCase__ ,skip_special_tokens=lowerCamelCase__ ) for seq in encoding['input_ids']]
# fmt: off
UpperCAmelCase__ = {
'input_ids': [
[1, 2_118, 11_126, 565, 35, 83, 25_191, 163, 18_854, 13, 12_156, 12, 16_101, 25_376, 13_807, 9, 22_205, 27_893, 1_635, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 2_118, 11_126, 565, 24_536, 80, 43_797, 4_878, 7_373, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 133, 78, 65, 16, 10, 3_724, 1_538, 33_183, 11_303, 43_797, 1_938, 4, 870, 24_165, 29_105, 5, 739, 32_644, 33_183, 11_303, 36_173, 88, 80, 650, 7_821, 45_940, 6, 52, 2_559, 5, 1_836, 9, 5, 7_397, 13_171, 31, 5, 1_836, 9, 32_644, 33_183, 11_303, 4, 2]
],
'token_type_ids': [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
],
'attention_mask': [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
}
# fmt: on
UpperCAmelCase__ = [
'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
'ALBERT incorporates two parameter reduction techniques',
'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
' vocabulary embedding.',
]
self.assertDictEqual(encoding.data ,lowerCamelCase__ )
for expected, decoded in zip(lowerCamelCase__ ,lowerCamelCase__ ):
self.assertEqual(lowerCamelCase__ ,lowerCamelCase__ )
| 632 | """simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import logging
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional, Union
from .generation.configuration_utils import GenerationConfig
from .training_args import TrainingArguments
from .utils import add_start_docstrings
lowerCAmelCase__ : List[str] = logging.getLogger(__name__)
@dataclass
@add_start_docstrings(TrainingArguments.__doc__ )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = field(default=__UpperCAmelCase , metadata={"help": "Whether to use SortishSampler or not."} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={"help": "Whether to use generate to calculate generative metrics (ROUGE, BLEU)."} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={
"help": (
"The `max_length` to use on each evaluation loop when `predict_with_generate=True`. Will default "
"to the `max_length` value of the model configuration."
)
} , )
snake_case__ = field(
default=__UpperCAmelCase , metadata={
"help": (
"The `num_beams` to use on each evaluation loop when `predict_with_generate=True`. Will default "
"to the `num_beams` value of the model configuration."
)
} , )
snake_case__ = field(
default=__UpperCAmelCase , metadata={
"help": "Model id, file path or url pointing to a GenerationConfig json file, to use during prediction."
} , )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = super().to_dict()
for k, v in d.items():
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = v.to_dict()
return d
| 632 | """simple docstring"""
import random
class snake_case :
"""simple docstring"""
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : str ):
UpperCAmelCase__ = [ord(lowerCamelCase__ ) for i in text]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i in plain:
UpperCAmelCase__ = random.randint(1 ,300 )
UpperCAmelCase__ = (i + k) * k
cipher.append(lowerCamelCase__ )
key.append(lowerCamelCase__ )
return cipher, key
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = int((cipher[i] - (key[i]) ** 2) / key[i] )
plain.append(chr(lowerCamelCase__ ) )
return "".join(lowerCamelCase__ )
if __name__ == "__main__":
lowerCAmelCase__ , lowerCAmelCase__ : Dict = Onepad().encrypt('Hello')
print(c, k)
print(Onepad().decrypt(c, k))
| 632 | 1 |
"""simple docstring"""
import unittest
import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
from diffusers import (
AutoencoderKL,
DDIMScheduler,
DPMSolverMultistepScheduler,
TextToVideoSDPipeline,
UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism
from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
enable_full_determinism()
@skip_mps
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = TextToVideoSDPipeline
snake_case__ = TEXT_TO_IMAGE_PARAMS
snake_case__ = TEXT_TO_IMAGE_BATCH_PARAMS
# No `output_type`.
snake_case__ = frozenset(
[
"num_inference_steps",
"generator",
"latents",
"return_dict",
"callback",
"callback_steps",
] )
def __lowerCAmelCase ( self : Tuple ):
torch.manual_seed(0 )
UpperCAmelCase__ = UNetaDConditionModel(
block_out_channels=(32, 64, 64, 64) ,layers_per_block=2 ,sample_size=32 ,in_channels=4 ,out_channels=4 ,down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D') ,up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D') ,cross_attention_dim=32 ,attention_head_dim=4 ,)
UpperCAmelCase__ = DDIMScheduler(
beta_start=0.0_0_0_8_5 ,beta_end=0.0_1_2 ,beta_schedule='scaled_linear' ,clip_sample=lowerCamelCase__ ,set_alpha_to_one=lowerCamelCase__ ,)
torch.manual_seed(0 )
UpperCAmelCase__ = 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 )
UpperCAmelCase__ = 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=1_000 ,hidden_act='gelu' ,projection_dim=512 ,)
UpperCAmelCase__ = CLIPTextModel(lowerCamelCase__ )
UpperCAmelCase__ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )
UpperCAmelCase__ = {
'unet': unet,
'scheduler': scheduler,
'vae': vae,
'text_encoder': text_encoder,
'tokenizer': tokenizer,
}
return components
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Any ,lowerCamelCase__ : Optional[int]=0 ):
if str(lowerCamelCase__ ).startswith('mps' ):
UpperCAmelCase__ = torch.manual_seed(lowerCamelCase__ )
else:
UpperCAmelCase__ = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
UpperCAmelCase__ = {
'prompt': 'A painting of a squirrel eating a burger',
'generator': generator,
'num_inference_steps': 2,
'guidance_scale': 6.0,
'output_type': 'pt',
}
return inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'cpu' # ensure determinism for the device-dependent torch.Generator
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = TextToVideoSDPipeline(**lowerCamelCase__ )
UpperCAmelCase__ = sd_pipe.to(lowerCamelCase__ )
sd_pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_inputs(lowerCamelCase__ )
UpperCAmelCase__ = 'np'
UpperCAmelCase__ = sd_pipe(**lowerCamelCase__ ).frames
UpperCAmelCase__ = frames[0][-3:, -3:, -1]
assert frames[0].shape == (64, 64, 3)
UpperCAmelCase__ = np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
def __lowerCAmelCase ( self : Union[str, Any] ):
self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase__ ,expected_max_diff=3e-3 )
@unittest.skipIf(
torch_device != 'cuda' or not is_xformers_available() ,reason='XFormers attention is only available with CUDA and `xformers` installed' ,)
def __lowerCAmelCase ( self : Dict ):
self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase__ ,expected_max_diff=1e-2 )
@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.' )
def __lowerCAmelCase ( self : Optional[Any] ):
pass
@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.' )
def __lowerCAmelCase ( self : List[str] ):
pass
@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.' )
def __lowerCAmelCase ( self : Optional[Any] ):
pass
def __lowerCAmelCase ( self : Tuple ):
return super().test_progress_bar()
@slow
@skip_mps
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = load_numpy(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy' )
UpperCAmelCase__ = TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b' )
UpperCAmelCase__ = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
UpperCAmelCase__ = pipe.to('cuda' )
UpperCAmelCase__ = 'Spiderman is surfing'
UpperCAmelCase__ = torch.Generator(device='cpu' ).manual_seed(0 )
UpperCAmelCase__ = pipe(lowerCamelCase__ ,generator=lowerCamelCase__ ,num_inference_steps=25 ,output_type='pt' ).frames
UpperCAmelCase__ = video_frames.cpu().numpy()
assert np.abs(expected_video - video ).mean() < 5e-2
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = load_numpy(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy' )
UpperCAmelCase__ = TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b' )
UpperCAmelCase__ = pipe.to('cuda' )
UpperCAmelCase__ = 'Spiderman is surfing'
UpperCAmelCase__ = torch.Generator(device='cpu' ).manual_seed(0 )
UpperCAmelCase__ = pipe(lowerCamelCase__ ,generator=lowerCamelCase__ ,num_inference_steps=2 ,output_type='pt' ).frames
UpperCAmelCase__ = video_frames.cpu().numpy()
assert np.abs(expected_video - video ).mean() < 5e-2
| 632 | """simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | 1 |
"""simple docstring"""
from dataclasses import dataclass
from typing import List, Optional, Union
import numpy as np
import PIL
import torch
from transformers import CLIPImageProcessor, CLIPVisionModel
from ...models import PriorTransformer
from ...pipelines import DiffusionPipeline
from ...schedulers import HeunDiscreteScheduler
from ...utils import (
BaseOutput,
is_accelerate_available,
logging,
randn_tensor,
replace_example_docstring,
)
from .renderer import ShapERenderer
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__) # pylint: disable=invalid-name
lowerCAmelCase__ : Optional[int] = '\n Examples:\n ```py\n >>> from PIL import Image\n >>> import torch\n >>> from diffusers import DiffusionPipeline\n >>> from diffusers.utils import export_to_gif, load_image\n\n >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")\n\n >>> repo = "openai/shap-e-img2img"\n >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n >>> pipe = pipe.to(device)\n\n >>> guidance_scale = 3.0\n >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"\n >>> image = load_image(image_url).convert("RGB")\n\n >>> images = pipe(\n ... image,\n ... guidance_scale=guidance_scale,\n ... num_inference_steps=64,\n ... frame_size=256,\n ... ).images\n\n >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")\n ```\n'
@dataclass
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = 42
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : PriorTransformer ,lowerCamelCase__ : CLIPVisionModel ,lowerCamelCase__ : CLIPImageProcessor ,lowerCamelCase__ : HeunDiscreteScheduler ,lowerCamelCase__ : ShapERenderer ,):
super().__init__()
self.register_modules(
prior=lowerCamelCase__ ,image_encoder=lowerCamelCase__ ,image_processor=lowerCamelCase__ ,scheduler=lowerCamelCase__ ,renderer=lowerCamelCase__ ,)
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Optional[int] ):
if latents is None:
UpperCAmelCase__ = randn_tensor(lowerCamelCase__ ,generator=lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=lowerCamelCase__ )
else:
if latents.shape != shape:
raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {shape}''' )
UpperCAmelCase__ = latents.to(lowerCamelCase__ )
UpperCAmelCase__ = latents * scheduler.init_noise_sigma
return latents
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=0 ):
if is_accelerate_available():
from accelerate import cpu_offload
else:
raise ImportError('Please install accelerate via `pip install accelerate`' )
UpperCAmelCase__ = torch.device(f'''cuda:{gpu_id}''' )
UpperCAmelCase__ = [self.image_encoder, self.prior]
for cpu_offloaded_model in models:
if cpu_offloaded_model is not None:
cpu_offload(lowerCamelCase__ ,lowerCamelCase__ )
@property
def __lowerCAmelCase ( self : str ):
if self.device != torch.device('meta' ) or not hasattr(self.image_encoder ,'_hf_hook' ):
return self.device
for module in self.image_encoder.modules():
if (
hasattr(lowerCamelCase__ ,'_hf_hook' )
and hasattr(module._hf_hook ,'execution_device' )
and module._hf_hook.execution_device is not None
):
return torch.device(module._hf_hook.execution_device )
return self.device
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : int ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : List[Any] ,):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ) and isinstance(image[0] ,torch.Tensor ):
UpperCAmelCase__ = torch.cat(lowerCamelCase__ ,axis=0 ) if image[0].ndim == 4 else torch.stack(lowerCamelCase__ ,axis=0 )
if not isinstance(lowerCamelCase__ ,torch.Tensor ):
UpperCAmelCase__ = self.image_processor(lowerCamelCase__ ,return_tensors='pt' ).pixel_values[0].unsqueeze(0 )
UpperCAmelCase__ = image.to(dtype=self.image_encoder.dtype ,device=lowerCamelCase__ )
UpperCAmelCase__ = self.image_encoder(lowerCamelCase__ )['last_hidden_state']
UpperCAmelCase__ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256
UpperCAmelCase__ = image_embeds.repeat_interleave(lowerCamelCase__ ,dim=0 )
if do_classifier_free_guidance:
UpperCAmelCase__ = torch.zeros_like(lowerCamelCase__ )
# For classifier free guidance, we need to do two forward passes.
# Here we concatenate the unconditional and text embeddings into a single batch
# to avoid doing two forward passes
UpperCAmelCase__ = torch.cat([negative_image_embeds, image_embeds] )
return image_embeds
@torch.no_grad()
@replace_example_docstring(lowerCamelCase__ )
def __call__( self : str ,lowerCamelCase__ : Union[PIL.Image.Image, List[PIL.Image.Image]] ,lowerCamelCase__ : int = 1 ,lowerCamelCase__ : int = 25 ,lowerCamelCase__ : Optional[Union[torch.Generator, List[torch.Generator]]] = None ,lowerCamelCase__ : Optional[torch.FloatTensor] = None ,lowerCamelCase__ : float = 4.0 ,lowerCamelCase__ : int = 64 ,lowerCamelCase__ : Optional[str] = "pil" ,lowerCamelCase__ : bool = True ,):
if isinstance(lowerCamelCase__ ,PIL.Image.Image ):
UpperCAmelCase__ = 1
elif isinstance(lowerCamelCase__ ,torch.Tensor ):
UpperCAmelCase__ = image.shape[0]
elif isinstance(lowerCamelCase__ ,lowerCamelCase__ ) and isinstance(image[0] ,(torch.Tensor, PIL.Image.Image) ):
UpperCAmelCase__ = len(lowerCamelCase__ )
else:
raise ValueError(
f'''`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowerCamelCase__ )}''' )
UpperCAmelCase__ = self._execution_device
UpperCAmelCase__ = batch_size * num_images_per_prompt
UpperCAmelCase__ = guidance_scale > 1.0
UpperCAmelCase__ = self._encode_image(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
# prior
self.scheduler.set_timesteps(lowerCamelCase__ ,device=lowerCamelCase__ )
UpperCAmelCase__ = self.scheduler.timesteps
UpperCAmelCase__ = self.prior.config.num_embeddings
UpperCAmelCase__ = self.prior.config.embedding_dim
UpperCAmelCase__ = self.prepare_latents(
(batch_size, num_embeddings * embedding_dim) ,image_embeds.dtype ,lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,self.scheduler ,)
# YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim
UpperCAmelCase__ = latents.reshape(latents.shape[0] ,lowerCamelCase__ ,lowerCamelCase__ )
for i, t in enumerate(self.progress_bar(lowerCamelCase__ ) ):
# expand the latents if we are doing classifier free guidance
UpperCAmelCase__ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents
UpperCAmelCase__ = self.scheduler.scale_model_input(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = self.prior(
lowerCamelCase__ ,timestep=lowerCamelCase__ ,proj_embedding=lowerCamelCase__ ,).predicted_image_embedding
# remove the variance
UpperCAmelCase__ , UpperCAmelCase__ = noise_pred.split(
scaled_model_input.shape[2] ,dim=2 ) # batch_size, num_embeddings, embedding_dim
if do_classifier_free_guidance is not None:
UpperCAmelCase__ , UpperCAmelCase__ = noise_pred.chunk(2 )
UpperCAmelCase__ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)
UpperCAmelCase__ = self.scheduler.step(
lowerCamelCase__ ,timestep=lowerCamelCase__ ,sample=lowerCamelCase__ ,).prev_sample
if output_type == "latent":
return ShapEPipelineOutput(images=lowerCamelCase__ )
UpperCAmelCase__ = []
for i, latent in enumerate(lowerCamelCase__ ):
print()
UpperCAmelCase__ = self.renderer.decode(
latent[None, :] ,lowerCamelCase__ ,size=lowerCamelCase__ ,ray_batch_size=4_096 ,n_coarse_samples=64 ,n_fine_samples=128 ,)
images.append(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
if output_type not in ["np", "pil"]:
raise ValueError(f'''Only the output types `pil` and `np` are supported not output_type={output_type}''' )
UpperCAmelCase__ = images.cpu().numpy()
if output_type == "pil":
UpperCAmelCase__ = [self.numpy_to_pil(lowerCamelCase__ ) for image in images]
# Offload last model to CPU
if hasattr(self ,'final_offload_hook' ) and self.final_offload_hook is not None:
self.final_offload_hook.offload()
if not return_dict:
return (images,)
return ShapEPipelineOutput(images=lowerCamelCase__ )
| 632 | """simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | """simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | 1 |
"""simple docstring"""
import unittest
import numpy as np
from transformers import RobertaPreLayerNormConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
if is_flax_available():
import jax.numpy as jnp
from transformers.models.roberta_prelayernorm.modeling_flax_roberta_prelayernorm import (
FlaxRobertaPreLayerNormForCausalLM,
FlaxRobertaPreLayerNormForMaskedLM,
FlaxRobertaPreLayerNormForMultipleChoice,
FlaxRobertaPreLayerNormForQuestionAnswering,
FlaxRobertaPreLayerNormForSequenceClassification,
FlaxRobertaPreLayerNormForTokenClassification,
FlaxRobertaPreLayerNormModel,
)
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : List[Any]=13 ,lowerCamelCase__ : Optional[Any]=7 ,lowerCamelCase__ : str=True ,lowerCamelCase__ : str=True ,lowerCamelCase__ : List[str]=True ,lowerCamelCase__ : Any=True ,lowerCamelCase__ : Union[str, Any]=99 ,lowerCamelCase__ : Dict=32 ,lowerCamelCase__ : List[Any]=5 ,lowerCamelCase__ : Tuple=4 ,lowerCamelCase__ : Any=37 ,lowerCamelCase__ : List[str]="gelu" ,lowerCamelCase__ : List[Any]=0.1 ,lowerCamelCase__ : int=0.1 ,lowerCamelCase__ : str=512 ,lowerCamelCase__ : Optional[int]=16 ,lowerCamelCase__ : Optional[Any]=2 ,lowerCamelCase__ : Dict=0.0_2 ,lowerCamelCase__ : List[str]=4 ,):
UpperCAmelCase__ = parent
UpperCAmelCase__ = batch_size
UpperCAmelCase__ = seq_length
UpperCAmelCase__ = is_training
UpperCAmelCase__ = use_attention_mask
UpperCAmelCase__ = use_token_type_ids
UpperCAmelCase__ = use_labels
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = hidden_dropout_prob
UpperCAmelCase__ = attention_probs_dropout_prob
UpperCAmelCase__ = max_position_embeddings
UpperCAmelCase__ = type_vocab_size
UpperCAmelCase__ = type_sequence_label_size
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = num_choices
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size )
UpperCAmelCase__ = None
if self.use_attention_mask:
UpperCAmelCase__ = random_attention_mask([self.batch_size, self.seq_length] )
UpperCAmelCase__ = None
if self.use_token_type_ids:
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,self.type_vocab_size )
UpperCAmelCase__ = RobertaPreLayerNormConfig(
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 ,)
return config, input_ids, token_type_ids, attention_mask
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = config_and_inputs
UpperCAmelCase__ = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
return config, inputs_dict
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = config_and_inputs
UpperCAmelCase__ = True
UpperCAmelCase__ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,vocab_size=2 )
return (
config,
input_ids,
token_type_ids,
encoder_hidden_states,
encoder_attention_mask,
)
@require_flax
# Copied from tests.models.roberta.test_modelling_flax_roberta.FlaxRobertaPreLayerNormModelTest with ROBERTA->ROBERTA_PRELAYERNORM,Roberta->RobertaPreLayerNorm,roberta-base->andreasmadsen/efficient_mlm_m0.40
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = True
snake_case__ = (
(
FlaxRobertaPreLayerNormModel,
FlaxRobertaPreLayerNormForCausalLM,
FlaxRobertaPreLayerNormForMaskedLM,
FlaxRobertaPreLayerNormForSequenceClassification,
FlaxRobertaPreLayerNormForTokenClassification,
FlaxRobertaPreLayerNormForMultipleChoice,
FlaxRobertaPreLayerNormForQuestionAnswering,
)
if is_flax_available()
else ()
)
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = FlaxRobertaPreLayerNormModelTester(self )
@slow
def __lowerCAmelCase ( self : Union[str, Any] ):
for model_class_name in self.all_model_classes:
UpperCAmelCase__ = model_class_name.from_pretrained('andreasmadsen/efficient_mlm_m0.40' ,from_pt=lowerCamelCase__ )
UpperCAmelCase__ = model(np.ones((1, 1) ) )
self.assertIsNotNone(lowerCamelCase__ )
@require_flax
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@slow
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = FlaxRobertaPreLayerNormForMaskedLM.from_pretrained('andreasmadsen/efficient_mlm_m0.40' ,from_pt=lowerCamelCase__ )
UpperCAmelCase__ = np.array([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]] ,dtype=jnp.intaa )
UpperCAmelCase__ = model(lowerCamelCase__ )[0]
UpperCAmelCase__ = [1, 11, 50_265]
self.assertEqual(list(output.shape ) ,lowerCamelCase__ )
# compare the actual values for a slice.
UpperCAmelCase__ = np.array(
[[[4_0.4_8_8_0, 1_8.0_1_9_9, -5.2_3_6_7], [-1.8_8_7_7, -4.0_8_8_5, 1_0.7_0_8_5], [-2.2_6_1_3, -5.6_1_1_0, 7.2_6_6_5]]] ,dtype=np.floataa )
self.assertTrue(np.allclose(output[:, :3, :3] ,lowerCamelCase__ ,atol=1e-4 ) )
@slow
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = FlaxRobertaPreLayerNormModel.from_pretrained('andreasmadsen/efficient_mlm_m0.40' ,from_pt=lowerCamelCase__ )
UpperCAmelCase__ = np.array([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]] ,dtype=jnp.intaa )
UpperCAmelCase__ = model(lowerCamelCase__ )[0]
# compare the actual values for a slice.
UpperCAmelCase__ = np.array(
[[[0.0_2_0_8, -0.0_3_5_6, 0.0_2_3_7], [-0.1_5_6_9, -0.0_4_1_1, -0.2_6_2_6], [0.1_8_7_9, 0.0_1_2_5, -0.0_0_8_9]]] ,dtype=np.floataa )
self.assertTrue(np.allclose(output[:, :3, :3] ,lowerCamelCase__ ,atol=1e-4 ) )
| 632 | """simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import os
from accelerate.utils import ComputeEnvironment
from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401
from .sagemaker import get_sagemaker_input
lowerCAmelCase__ : Dict = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'
def a_ ( ):
UpperCAmelCase__ = _ask_options(
'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , )
if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
UpperCAmelCase__ = get_sagemaker_input()
else:
UpperCAmelCase__ = get_cluster_input()
return config
def a_ ( lowerCamelCase=None ):
if subparsers is not None:
UpperCAmelCase__ = subparsers.add_parser('config' , description=lowerCamelCase )
else:
UpperCAmelCase__ = argparse.ArgumentParser('Accelerate config command' , description=lowerCamelCase )
parser.add_argument(
'--config_file' , default=lowerCamelCase , help=(
'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
'with \'huggingface\'.'
) , )
if subparsers is not None:
parser.set_defaults(func=lowerCamelCase )
return parser
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_user_input()
if args.config_file is not None:
UpperCAmelCase__ = args.config_file
else:
if not os.path.isdir(lowerCamelCase ):
os.makedirs(lowerCamelCase )
UpperCAmelCase__ = default_yaml_config_file
if config_file.endswith('.json' ):
config.to_json_file(lowerCamelCase )
else:
config.to_yaml_file(lowerCamelCase )
print(f'''accelerate configuration saved at {config_file}''' )
def a_ ( ):
UpperCAmelCase__ = config_command_parser()
UpperCAmelCase__ = parser.parse_args()
config_command(lowerCamelCase )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
import json
import os
import subprocess
import unittest
from ast import literal_eval
import pytest
from parameterized import parameterized, parameterized_class
from . import is_sagemaker_available
if is_sagemaker_available():
from sagemaker import Session, TrainingJobAnalytics
from sagemaker.huggingface import HuggingFace
@pytest.mark.skipif(
literal_eval(os.getenv("TEST_SAGEMAKER" , "False" ) ) is not True , reason="Skipping test because should only be run when releasing minor transformers version" , )
@pytest.mark.usefixtures("sm_env" )
@parameterized_class(
[
{
"framework": "pytorch",
"script": "run_glue.py",
"model_name_or_path": "distilbert-base-cased",
"instance_type": "ml.p3.16xlarge",
"results": {"train_runtime": 6_50, "eval_accuracy": 0.7, "eval_loss": 0.6},
},
{
"framework": "pytorch",
"script": "run_ddp.py",
"model_name_or_path": "distilbert-base-cased",
"instance_type": "ml.p3.16xlarge",
"results": {"train_runtime": 6_00, "eval_accuracy": 0.7, "eval_loss": 0.6},
},
{
"framework": "tensorflow",
"script": "run_tf_dist.py",
"model_name_or_path": "distilbert-base-cased",
"instance_type": "ml.p3.16xlarge",
"results": {"train_runtime": 6_00, "eval_accuracy": 0.6, "eval_loss": 0.7},
},
] )
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Tuple ):
if self.framework == "pytorch":
subprocess.run(
f'''cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py'''.split() ,encoding='utf-8' ,check=lowerCamelCase__ ,)
assert hasattr(self ,'env' )
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Dict ):
UpperCAmelCase__ = f'''{self.env.base_job_name}-{instance_count}-{"ddp" if "ddp" in self.script else "smd"}'''
# distributed data settings
UpperCAmelCase__ = {'smdistributed': {'dataparallel': {'enabled': True}}} if self.script != 'run_ddp.py' else None
# creates estimator
return HuggingFace(
entry_point=self.script ,source_dir=self.env.test_path ,role=self.env.role ,image_uri=self.env.image_uri ,base_job_name=lowerCamelCase__ ,instance_count=lowerCamelCase__ ,instance_type=self.instance_type ,debugger_hook_config=lowerCamelCase__ ,hyperparameters={**self.env.distributed_hyperparameters, 'model_name_or_path': self.model_name_or_path} ,metric_definitions=self.env.metric_definitions ,distribution=lowerCamelCase__ ,py_version='py36' ,)
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Dict ):
TrainingJobAnalytics(lowerCamelCase__ ).export_csv(f'''{self.env.test_path}/{job_name}_metrics.csv''' )
@parameterized.expand([(2,)] )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Optional[int] ):
# create estimator
UpperCAmelCase__ = self.create_estimator(lowerCamelCase__ )
# run training
estimator.fit()
# result dataframe
UpperCAmelCase__ = TrainingJobAnalytics(estimator.latest_training_job.name ).dataframe()
# extract kpis
UpperCAmelCase__ = list(result_metrics_df[result_metrics_df.metric_name == 'eval_accuracy']['value'] )
UpperCAmelCase__ = list(result_metrics_df[result_metrics_df.metric_name == 'eval_loss']['value'] )
# get train time from SageMaker job, this includes starting, preprocessing, stopping
UpperCAmelCase__ = (
Session().describe_training_job(estimator.latest_training_job.name ).get('TrainingTimeInSeconds' ,999_999 )
)
# assert kpis
assert train_runtime <= self.results["train_runtime"]
assert all(t >= self.results['eval_accuracy'] for t in eval_accuracy )
assert all(t <= self.results['eval_loss'] for t in eval_loss )
# dump tests result into json file to share in PR
with open(f'''{estimator.latest_training_job.name}.json''' ,'w' ) as outfile:
json.dump({'train_time': train_runtime, 'eval_accuracy': eval_accuracy, 'eval_loss': eval_loss} ,lowerCamelCase__ )
| 632 | """simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import socket
def a_ ( ):
UpperCAmelCase__ = socket.socket(socket.AF_INET , socket.SOCK_STREAM )
UpperCAmelCase__ = socket.gethostname()
UpperCAmelCase__ = 1_2_3_1_2
sock.connect((host, port) )
sock.send(b'Hello server!' )
with open('Received_file' , 'wb' ) as out_file:
print('File opened' )
print('Receiving data...' )
while True:
UpperCAmelCase__ = sock.recv(1_0_2_4 )
if not data:
break
out_file.write(lowerCamelCase )
print('Successfully received the file' )
sock.close()
print('Connection closed' )
if __name__ == "__main__":
main()
| 632 | """simple docstring"""
import warnings
from functools import wraps
from typing import Callable
def a_ ( lowerCamelCase ):
@wraps(lowerCamelCase )
def _inner_fn(*lowerCamelCase , **lowerCamelCase ):
warnings.warn(
(f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''') , lowerCamelCase , )
return fn(*lowerCamelCase , **lowerCamelCase )
return _inner_fn
| 632 | 1 |
"""simple docstring"""
from typing import Dict, List, Optional, Tuple, Union
import numpy as np
from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
center_crop,
flip_channel_order,
get_resize_output_image_size,
rescale,
resize,
to_channel_dimension_format,
)
from ...image_utils import (
ChannelDimension,
ImageInput,
PILImageResampling,
make_list_of_images,
to_numpy_array,
valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging
if is_vision_available():
import PIL
if is_torch_available():
import torch
lowerCAmelCase__ : Any = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ["pixel_values"]
def __init__( self : Optional[Any] ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : PILImageResampling = PILImageResampling.BILINEAR ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Union[int, float] = 1 / 255 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : bool = True ,**lowerCamelCase__ : str ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = size if size is not None else {'shortest_edge': 224}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ )
UpperCAmelCase__ = crop_size if crop_size is not None else {'height': 256, 'width': 256}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='crop_size' )
UpperCAmelCase__ = do_resize
UpperCAmelCase__ = size
UpperCAmelCase__ = resample
UpperCAmelCase__ = do_rescale
UpperCAmelCase__ = rescale_factor
UpperCAmelCase__ = do_center_crop
UpperCAmelCase__ = crop_size
UpperCAmelCase__ = do_flip_channel_order
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : PILImageResampling = PIL.Image.BILINEAR ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ )
if "shortest_edge" not in size:
raise ValueError(f'''The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}''' )
UpperCAmelCase__ = get_resize_output_image_size(lowerCamelCase__ ,size=size['shortest_edge'] ,default_to_square=lowerCamelCase__ )
return resize(lowerCamelCase__ ,size=lowerCamelCase__ ,resample=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : List[Any] ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
if "height" not in size or "width" not in size:
raise ValueError(f'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}''' )
return center_crop(lowerCamelCase__ ,size=(size['height'], size['width']) ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Union[int, float] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : List[Any] ,):
return rescale(lowerCamelCase__ ,scale=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ):
return flip_channel_order(lowerCamelCase__ ,data_format=lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : ImageInput ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : PILImageResampling = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : float = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Optional[Union[str, TensorType]] = None ,lowerCamelCase__ : ChannelDimension = ChannelDimension.FIRST ,**lowerCamelCase__ : str ,):
UpperCAmelCase__ = do_resize if do_resize is not None else self.do_resize
UpperCAmelCase__ = resample if resample is not None else self.resample
UpperCAmelCase__ = do_rescale if do_rescale is not None else self.do_rescale
UpperCAmelCase__ = rescale_factor if rescale_factor is not None else self.rescale_factor
UpperCAmelCase__ = do_center_crop if do_center_crop is not None else self.do_center_crop
UpperCAmelCase__ = (
do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
)
UpperCAmelCase__ = size if size is not None else self.size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ )
UpperCAmelCase__ = crop_size if crop_size is not None else self.crop_size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='crop_size' )
UpperCAmelCase__ = make_list_of_images(lowerCamelCase__ )
if not valid_images(lowerCamelCase__ ):
raise ValueError(
'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
'torch.Tensor, tf.Tensor or jax.ndarray.' )
if do_resize and size is None:
raise ValueError('Size must be specified if do_resize is True.' )
if do_rescale and rescale_factor is None:
raise ValueError('Rescale factor must be specified if do_rescale is True.' )
if do_center_crop and crop_size is None:
raise ValueError('Crop size must be specified if do_center_crop is True.' )
# All transformations expect numpy arrays.
UpperCAmelCase__ = [to_numpy_array(lowerCamelCase__ ) for image in images]
if do_resize:
UpperCAmelCase__ = [self.resize(image=lowerCamelCase__ ,size=lowerCamelCase__ ,resample=lowerCamelCase__ ) for image in images]
if do_center_crop:
UpperCAmelCase__ = [self.center_crop(image=lowerCamelCase__ ,size=lowerCamelCase__ ) for image in images]
if do_rescale:
UpperCAmelCase__ = [self.rescale(image=lowerCamelCase__ ,scale=lowerCamelCase__ ) for image in images]
# the pretrained checkpoints assume images are BGR, not RGB
if do_flip_channel_order:
UpperCAmelCase__ = [self.flip_channel_order(image=lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = [to_channel_dimension_format(lowerCamelCase__ ,lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = {'pixel_values': images}
return BatchFeature(data=lowerCamelCase__ ,tensor_type=lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : List[Tuple] = None ):
UpperCAmelCase__ = outputs.logits
# Resize logits and compute semantic segmentation maps
if target_sizes is not None:
if len(lowerCamelCase__ ) != len(lowerCamelCase__ ):
raise ValueError(
'Make sure that you pass in as many target sizes as the batch dimension of the logits' )
if is_torch_tensor(lowerCamelCase__ ):
UpperCAmelCase__ = target_sizes.numpy()
UpperCAmelCase__ = []
for idx in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = torch.nn.functional.interpolate(
logits[idx].unsqueeze(dim=0 ) ,size=target_sizes[idx] ,mode='bilinear' ,align_corners=lowerCamelCase__ )
UpperCAmelCase__ = resized_logits[0].argmax(dim=0 )
semantic_segmentation.append(lowerCamelCase__ )
else:
UpperCAmelCase__ = logits.argmax(dim=1 )
UpperCAmelCase__ = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )]
return semantic_segmentation
| 632 | """simple docstring"""
from __future__ import annotations
import string
from itertools import cycle, product
from pathlib import Path
lowerCAmelCase__ : str = (
string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__ : list[int] = [ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__ : set[int] = {ord(char) for char in VALID_CHARS}
lowerCAmelCase__ : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"]
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = ""
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
for keychar, cipherchar in zip(cycle(lowerCamelCase ) , lowerCamelCase ):
UpperCAmelCase__ = cipherchar ^ keychar
if decodedchar not in VALID_INTS:
return None
decoded += chr(lowerCamelCase )
return decoded
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
for key in product(lowerCamelCase , repeat=3 ):
UpperCAmelCase__ = try_key(lowerCamelCase , lowerCamelCase )
if encoded is not None:
possibles.append(lowerCamelCase )
return possibles
def a_ ( lowerCamelCase , lowerCamelCase ):
return [possible for possible in possibles if common_word in possible.lower()]
def a_ ( lowerCamelCase = "p059_cipher.txt" ):
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )
UpperCAmelCase__ = [int(lowerCamelCase ) for number in data.strip().split(',' )]
UpperCAmelCase__ = filter_valid_chars(lowerCamelCase )
for common_word in COMMON_WORDS:
UpperCAmelCase__ = filter_common_word(lowerCamelCase , lowerCamelCase )
if len(lowerCamelCase ) == 1:
break
UpperCAmelCase__ = possibles[0]
return sum(ord(lowerCamelCase ) for char in decoded_text )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position
lowerCAmelCase__ : Any = '2.13.1'
import platform
import pyarrow
from packaging import version
if version.parse(platform.python_version()) < version.parse('3.7'):
raise ImportWarning(
'To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'
)
if version.parse(pyarrow.__version__).major < 8:
raise ImportWarning(
'To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'
'If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'
)
del platform
del pyarrow
del version
from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
get_dataset_config_info,
get_dataset_config_names,
get_dataset_infos,
get_dataset_split_names,
inspect_dataset,
inspect_metric,
list_datasets,
list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
NamedSplit,
NamedSplitAll,
Split,
SplitBase,
SplitDict,
SplitGenerator,
SplitInfo,
SubSplitInfo,
percent,
)
from .tasks import *
from .utils import *
from .utils import logging
# deprecated modules
from datasets import arrow_dataset as _arrow_dataset # isort:skip
from datasets import utils as _utils # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager # isort:skip
lowerCAmelCase__ : Optional[Any] = concatenate_datasets
lowerCAmelCase__ : List[Any] = DownloadConfig
lowerCAmelCase__ : Tuple = DownloadManager
lowerCAmelCase__ : str = DownloadMode
lowerCAmelCase__ : Union[str, Any] = DownloadConfig
lowerCAmelCase__ : List[str] = DownloadMode
lowerCAmelCase__ : Optional[Any] = DownloadManager
del _arrow_dataset, _utils, _deprecated_download_manager
| 632 | """simple docstring"""
import unittest
from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : Any = get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = XLMProphetNetTokenizer
snake_case__ = False
snake_case__ = True
def __lowerCAmelCase ( self : Any ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = '[PAD]'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'[PAD]' )
self.assertEqual(vocab_keys[1] ,'[CLS]' )
self.assertEqual(vocab_keys[-1] ,'j' )
self.assertEqual(len(lowerCamelCase__ ) ,1_012 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,1_012 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowerCamelCase__ ,['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,)
UpperCAmelCase__ = 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',
'é',
'.',
] ,)
UpperCAmelCase__ = tokenizer.convert_tokens_to_ids(lowerCamelCase__ )
self.assertListEqual(
lowerCamelCase__ ,[
value + tokenizer.fairseq_offset
for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
] ,)
UpperCAmelCase__ = 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 __lowerCAmelCase ( self : Dict ):
return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )
@slow
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello World!'
UpperCAmelCase__ = [35_389, 6_672, 49, 2]
self.assertListEqual(lowerCamelCase__ ,self.big_tokenizer.encode(lowerCamelCase__ ) )
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/xprophetnet-large-wiki100-cased' ,revision='1acad1643ddd54a44df6a1b797ada8373685d90e' ,)
| 632 | 1 |
"""simple docstring"""
from .testing import (
are_the_same_tensors,
execute_subprocess_async,
require_bnb,
require_cpu,
require_cuda,
require_huggingface_suite,
require_mps,
require_multi_gpu,
require_multi_xpu,
require_safetensors,
require_single_gpu,
require_single_xpu,
require_torch_min_version,
require_tpu,
require_xpu,
skip,
slow,
)
from .training import RegressionDataset, RegressionModel, RegressionModelaXPU
from .scripts import test_script, test_sync, test_ops # isort: skip
| 632 | """simple docstring"""
from __future__ import annotations
import collections
import pprint
from pathlib import Path
def a_ ( lowerCamelCase ):
return "".join(sorted(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
return word_by_signature[signature(lowerCamelCase )]
lowerCAmelCase__ : str = Path(__file__).parent.joinpath('words.txt').read_text(encoding='utf-8')
lowerCAmelCase__ : str = sorted({word.strip().lower() for word in data.splitlines()})
lowerCAmelCase__ : Optional[Any] = collections.defaultdict(list)
for word in word_list:
word_by_signature[signature(word)].append(word)
if __name__ == "__main__":
lowerCAmelCase__ : int = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
with open('anagrams.txt', 'w') as file:
file.write('all_anagrams = \n ')
file.write(pprint.pformat(all_anagrams))
| 632 | 1 |
"""simple docstring"""
from typing import List, Optional, Union
import numpy as np
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging
lowerCAmelCase__ : int = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ["input_values", "padding_mask"]
def __init__( self : str ,lowerCamelCase__ : int = 1 ,lowerCamelCase__ : int = 24_000 ,lowerCamelCase__ : float = 0.0 ,lowerCamelCase__ : float = None ,lowerCamelCase__ : float = None ,**lowerCamelCase__ : Any ,):
super().__init__(feature_size=lowerCamelCase__ ,sampling_rate=lowerCamelCase__ ,padding_value=lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = chunk_length_s
UpperCAmelCase__ = overlap
@property
def __lowerCAmelCase ( self : Optional[Any] ):
if self.chunk_length_s is None:
return None
else:
return int(self.chunk_length_s * self.sampling_rate )
@property
def __lowerCAmelCase ( self : List[str] ):
if self.chunk_length_s is None or self.overlap is None:
return None
else:
return max(1 ,int((1.0 - self.overlap) * self.chunk_length ) )
def __call__( self : Union[str, Any] ,lowerCamelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCamelCase__ : Optional[Union[bool, str, PaddingStrategy]] = None ,lowerCamelCase__ : Optional[bool] = False ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : Optional[Union[str, TensorType]] = None ,lowerCamelCase__ : Optional[int] = None ,):
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
f''' {self.sampling_rate}. Please make sure that the provided audio input was sampled with'''
f''' {self.sampling_rate} and not {sampling_rate}.''' )
else:
logger.warning(
'It is strongly recommended to pass the `sampling_rate` argument to this function. '
'Failing to do so can result in silent errors that might be hard to debug.' )
if padding and truncation:
raise ValueError('Both padding and truncation were set. Make sure you only set one.' )
elif padding is None:
# by default let's pad the inputs
UpperCAmelCase__ = True
UpperCAmelCase__ = bool(
isinstance(lowerCamelCase__ ,(list, tuple) ) and (isinstance(raw_audio[0] ,(np.ndarray, tuple, list) )) )
if is_batched:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ,dtype=np.floataa ).T for audio in raw_audio]
elif not is_batched and not isinstance(lowerCamelCase__ ,np.ndarray ):
UpperCAmelCase__ = np.asarray(lowerCamelCase__ ,dtype=np.floataa )
elif isinstance(lowerCamelCase__ ,np.ndarray ) and raw_audio.dtype is np.dtype(np.floataa ):
UpperCAmelCase__ = raw_audio.astype(np.floataa )
# always return batch
if not is_batched:
UpperCAmelCase__ = [np.asarray(lowerCamelCase__ ).T]
# verify inputs are valid
for idx, example in enumerate(lowerCamelCase__ ):
if example.ndim > 2:
raise ValueError(f'''Expected input shape (channels, length) but got shape {example.shape}''' )
if self.feature_size == 1 and example.ndim != 1:
raise ValueError(f'''Expected mono audio but example has {example.shape[-1]} channels''' )
if self.feature_size == 2 and example.shape[-1] != 2:
raise ValueError(f'''Expected stereo audio but example has {example.shape[-1]} channels''' )
UpperCAmelCase__ = None
UpperCAmelCase__ = BatchFeature({'input_values': raw_audio} )
if self.chunk_stride is not None and self.chunk_length is not None and max_length is None:
if truncation:
UpperCAmelCase__ = min(array.shape[0] for array in raw_audio )
UpperCAmelCase__ = int(np.floor(max_length / self.chunk_stride ) )
UpperCAmelCase__ = (nb_step - 1) * self.chunk_stride + self.chunk_length
elif padding:
UpperCAmelCase__ = max(array.shape[0] for array in raw_audio )
UpperCAmelCase__ = int(np.ceil(max_length / self.chunk_stride ) )
UpperCAmelCase__ = (nb_step - 1) * self.chunk_stride + self.chunk_length
UpperCAmelCase__ = 'max_length'
else:
UpperCAmelCase__ = input_values
# normal padding on batch
if padded_inputs is None:
UpperCAmelCase__ = self.pad(
lowerCamelCase__ ,max_length=lowerCamelCase__ ,truncation=lowerCamelCase__ ,padding=lowerCamelCase__ ,return_attention_mask=lowerCamelCase__ ,)
if padding:
UpperCAmelCase__ = padded_inputs.pop('attention_mask' )
UpperCAmelCase__ = []
for example in padded_inputs.pop('input_values' ):
if self.feature_size == 1:
UpperCAmelCase__ = example[..., None]
input_values.append(example.T )
UpperCAmelCase__ = input_values
if return_tensors is not None:
UpperCAmelCase__ = padded_inputs.convert_to_tensors(lowerCamelCase__ )
return padded_inputs
| 632 | """simple docstring"""
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class snake_case ( ctypes.Structure ):
"""simple docstring"""
snake_case__ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25l' )
sys.stdout.flush()
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25h' )
sys.stdout.flush()
@contextmanager
def a_ ( ):
try:
hide_cursor()
yield
finally:
show_cursor()
| 632 | 1 |
"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | """simple docstring"""
import inspect
import tempfile
from collections import OrderedDict, UserDict
from collections.abc import MutableMapping
from contextlib import ExitStack, contextmanager
from dataclasses import fields
from enum import Enum
from typing import Any, ContextManager, List, Tuple
import numpy as np
from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy
if is_flax_available():
import jax.numpy as jnp
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __get__( self : Dict ,lowerCamelCase__ : str ,lowerCamelCase__ : str=None ):
# See docs.python.org/3/howto/descriptor.html#properties
if obj is None:
return self
if self.fget is None:
raise AttributeError('unreadable attribute' )
UpperCAmelCase__ = '__cached_' + self.fget.__name__
UpperCAmelCase__ = getattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
if cached is None:
UpperCAmelCase__ = self.fget(lowerCamelCase__ )
setattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
return cached
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = val.lower()
if val in {"y", "yes", "t", "true", "on", "1"}:
return 1
if val in {"n", "no", "f", "false", "off", "0"}:
return 0
raise ValueError(f'''invalid truth value {val!r}''' )
def a_ ( lowerCamelCase ):
if is_torch_fx_proxy(lowerCamelCase ):
return True
if is_torch_available():
import torch
if isinstance(lowerCamelCase , torch.Tensor ):
return True
if is_tf_available():
import tensorflow as tf
if isinstance(lowerCamelCase , tf.Tensor ):
return True
if is_flax_available():
import jax.numpy as jnp
from jax.core import Tracer
if isinstance(lowerCamelCase , (jnp.ndarray, Tracer) ):
return True
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return _is_numpy(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.device )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_device(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
if isinstance(lowerCamelCase , lowerCamelCase ):
if hasattr(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = getattr(lowerCamelCase , lowerCamelCase )
else:
return False
return isinstance(lowerCamelCase , torch.dtype )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_dtype(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
return isinstance(lowerCamelCase , tf.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tensorflow(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
# the `is_symbolic_tensor` predicate is only available starting with TF 2.14
if hasattr(lowerCamelCase , 'is_symbolic_tensor' ):
return tf.is_symbolic_tensor(lowerCamelCase )
return type(lowerCamelCase ) == tf.Tensor
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tf_symbolic_tensor(lowerCamelCase )
def a_ ( lowerCamelCase ):
import jax.numpy as jnp # noqa: F811
return isinstance(lowerCamelCase , jnp.ndarray )
def a_ ( lowerCamelCase ):
return False if not is_flax_available() else _is_jax(lowerCamelCase )
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_py_obj(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return [to_py_obj(lowerCamelCase ) for o in obj]
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy().tolist()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().tolist()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase ).tolist()
elif isinstance(lowerCamelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays
return obj.tolist()
else:
return obj
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_numpy(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return np.array(lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().numpy()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase )
else:
return obj
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = fields(self )
# Safety and consistency checks
if not len(lowerCamelCase__ ):
raise ValueError(f'''{self.__class__.__name__} has no fields.''' )
if not all(field.default is None for field in class_fields[1:] ):
raise ValueError(f'''{self.__class__.__name__} should not have more than one required field.''' )
UpperCAmelCase__ = getattr(self ,class_fields[0].name )
UpperCAmelCase__ = all(getattr(self ,field.name ) is None for field in class_fields[1:] )
if other_fields_are_none and not is_tensor(lowerCamelCase__ ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = first_field.items()
UpperCAmelCase__ = True
else:
try:
UpperCAmelCase__ = iter(lowerCamelCase__ )
UpperCAmelCase__ = True
except TypeError:
UpperCAmelCase__ = False
# if we provided an iterator as first field and the iterator is a (key, value) iterator
# set the associated fields
if first_field_iterator:
for idx, element in enumerate(lowerCamelCase__ ):
if (
not isinstance(lowerCamelCase__ ,(list, tuple) )
or not len(lowerCamelCase__ ) == 2
or not isinstance(element[0] ,lowerCamelCase__ )
):
if idx == 0:
# If we do not have an iterator of key/values, set it as attribute
UpperCAmelCase__ = first_field
else:
# If we have a mixed iterator, raise an error
raise ValueError(
f'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' )
break
setattr(self ,element[0] ,element[1] )
if element[1] is not None:
UpperCAmelCase__ = element[1]
elif first_field is not None:
UpperCAmelCase__ = first_field
else:
for field in class_fields:
UpperCAmelCase__ = getattr(self ,field.name )
if v is not None:
UpperCAmelCase__ = v
def __delitem__( self : List[Any] ,*lowerCamelCase__ : Any ,**lowerCamelCase__ : Dict ):
raise Exception(f'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : str ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Optional[Any] ):
raise Exception(f'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : List[Any] ,*lowerCamelCase__ : int ,**lowerCamelCase__ : List[Any] ):
raise Exception(f'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : Optional[int] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Optional[int] ):
raise Exception(f'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' )
def __getitem__( self : Tuple ,lowerCamelCase__ : List[Any] ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = dict(self.items() )
return inner_dict[k]
else:
return self.to_tuple()[k]
def __setattr__( self : int ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if name in self.keys() and value is not None:
# Don't call self.__setitem__ to avoid recursion errors
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __setitem__( self : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : Any ):
# Will raise a KeyException if needed
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
# Don't call self.__setattr__ to avoid recursion errors
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
return tuple(self[k] for k in self.keys() )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
@classmethod
def __lowerCAmelCase ( cls : str ,lowerCamelCase__ : Optional[int] ):
raise ValueError(
f'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "longest"
snake_case__ = "max_length"
snake_case__ = "do_not_pad"
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "pt"
snake_case__ = "tf"
snake_case__ = "np"
snake_case__ = "jax"
class snake_case :
"""simple docstring"""
def __init__( self : int ,lowerCamelCase__ : List[ContextManager] ):
UpperCAmelCase__ = context_managers
UpperCAmelCase__ = ExitStack()
def __enter__( self : Union[str, Any] ):
for context_manager in self.context_managers:
self.stack.enter_context(lowerCamelCase__ )
def __exit__( self : List[Any] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Dict ):
self.stack.__exit__(*lowerCamelCase__ ,**lowerCamelCase__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
for p in signature.parameters:
if p == "return_loss" and signature.parameters[p].default is True:
return True
return False
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = model_class.__name__
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
if "QuestionAnswering" in model_name:
return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")]
else:
return [p for p in signature.parameters if "label" in p]
def a_ ( lowerCamelCase , lowerCamelCase = "" , lowerCamelCase = "." ):
def _flatten_dict(lowerCamelCase , lowerCamelCase="" , lowerCamelCase="." ):
for k, v in d.items():
UpperCAmelCase__ = str(lowerCamelCase ) + delimiter + str(lowerCamelCase ) if parent_key else k
if v and isinstance(lowerCamelCase , lowerCamelCase ):
yield from flatten_dict(lowerCamelCase , lowerCamelCase , delimiter=lowerCamelCase ).items()
else:
yield key, v
return dict(_flatten_dict(lowerCamelCase , lowerCamelCase , lowerCamelCase ) )
@contextmanager
def a_ ( lowerCamelCase , lowerCamelCase = False ):
if use_temp_dir:
with tempfile.TemporaryDirectory() as tmp_dir:
yield tmp_dir
else:
yield working_dir
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.transpose(lowerCamelCase , axes=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.T if axes is None else array.permute(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.transpose(lowerCamelCase , perm=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.transpose(lowerCamelCase , axes=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for transpose: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.reshape(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.reshape(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.reshape(lowerCamelCase , lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.reshape(lowerCamelCase , lowerCamelCase )
else:
raise ValueError(f'''Type not supported for reshape: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.squeeze() if axis is None else array.squeeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.squeeze(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for squeeze: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.expand_dims(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.unsqueeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.expand_dims(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.expand_dims(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.size(lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.numel()
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.size(lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return array.size
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
for key, value in auto_map.items():
if isinstance(lowerCamelCase , (tuple, list) ):
UpperCAmelCase__ = [f'''{repo_id}--{v}''' if (v is not None and '--' not in v) else v for v in value]
elif value is not None and "--" not in value:
UpperCAmelCase__ = f'''{repo_id}--{value}'''
return auto_map
def a_ ( lowerCamelCase ):
for base_class in inspect.getmro(lowerCamelCase ):
UpperCAmelCase__ = base_class.__module__
UpperCAmelCase__ = base_class.__name__
if module.startswith('tensorflow' ) or module.startswith('keras' ) or name == "TFPreTrainedModel":
return "tf"
elif module.startswith('torch' ) or name == "PreTrainedModel":
return "pt"
elif module.startswith('flax' ) or module.startswith('jax' ) or name == "FlaxPreTrainedModel":
return "flax"
else:
raise TypeError(f'''Could not infer framework from class {model_class}.''' )
| 632 | 1 |
"""simple docstring"""
from typing import List, Optional, Tuple
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_herbert import HerbertTokenizer
lowerCAmelCase__ : int = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[int] = {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}
lowerCAmelCase__ : List[Any] = {
'vocab_file': {
'allegro/herbert-base-cased': 'https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json'
},
'merges_file': {
'allegro/herbert-base-cased': 'https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt'
},
}
lowerCAmelCase__ : Optional[Any] = {'allegro/herbert-base-cased': 514}
lowerCAmelCase__ : int = {}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = VOCAB_FILES_NAMES
snake_case__ = PRETRAINED_VOCAB_FILES_MAP
snake_case__ = PRETRAINED_INIT_CONFIGURATION
snake_case__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
snake_case__ = HerbertTokenizer
def __init__( self : Union[str, Any] ,lowerCamelCase__ : List[str]=None ,lowerCamelCase__ : Optional[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : Optional[int]="<s>" ,lowerCamelCase__ : Dict="<unk>" ,lowerCamelCase__ : Optional[Any]="<pad>" ,lowerCamelCase__ : List[Any]="<mask>" ,lowerCamelCase__ : List[str]="</s>" ,**lowerCamelCase__ : Tuple ,):
super().__init__(
lowerCamelCase__ ,lowerCamelCase__ ,tokenizer_file=lowerCamelCase__ ,cls_token=lowerCamelCase__ ,unk_token=lowerCamelCase__ ,pad_token=lowerCamelCase__ ,mask_token=lowerCamelCase__ ,sep_token=lowerCamelCase__ ,**lowerCamelCase__ ,)
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
UpperCAmelCase__ = [self.cls_token_id]
UpperCAmelCase__ = [self.sep_token_id]
if token_ids_a is None:
return cls + token_ids_a + sep
return cls + token_ids_a + sep + token_ids_a + sep
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ,lowerCamelCase__ : bool = False ):
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=lowerCamelCase__ ,token_ids_a=lowerCamelCase__ ,already_has_special_tokens=lowerCamelCase__ )
if token_ids_a is None:
return [1] + ([0] * len(lowerCamelCase__ )) + [1]
return [1] + ([0] * len(lowerCamelCase__ )) + [1] + ([0] * len(lowerCamelCase__ )) + [1]
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : List[int] ,lowerCamelCase__ : Optional[List[int]] = None ):
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 ) * [0] + len(token_ids_a + sep ) * [1]
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : str ,lowerCamelCase__ : Optional[str] = None ):
UpperCAmelCase__ = self._tokenizer.model.save(lowerCamelCase__ ,name=lowerCamelCase__ )
return tuple(lowerCamelCase__ )
| 632 | """simple docstring"""
import gc
import tempfile
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
lowerCAmelCase__ : Union[str, Any] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@nightly
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='numpy' ,).images
with tempfile.TemporaryDirectory() as tmpdirname:
pipe.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained(lowerCamelCase__ ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = generator.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,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 __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'cyberpunk 2077'
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.1_4_4_8, 0.1_6_1_9, 0.1_7_4_1, 0.1_0_8_6, 0.1_1_4_7, 0.1_1_2_8, 0.1_1_9_9, 0.1_1_6_5, 0.1_0_0_1] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = 'A painting of a squirrel eating a burger '
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.text_to_image(
prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_3_6_7, 0.3_1_6_9, 0.2_6_5_6, 0.3_8_7_0, 0.4_7_9_0, 0.3_7_9_6, 0.4_0_0_9, 0.4_8_7_8, 0.4_7_7_8] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = pipe.image_variation(lowerCamelCase__ ,generator=lowerCamelCase__ ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_0_7_6, 0.3_1_2_3, 0.3_2_8_4, 0.3_7_8_2, 0.3_7_7_0, 0.3_8_9_4, 0.4_2_9_7, 0.4_3_3_1, 0.4_4_5_6] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase = 1_0 ):
if not isinstance(lowerCamelCase , lowerCamelCase ) or n < 0:
raise ValueError('Invalid input' )
UpperCAmelCase__ = 1_0**n
UpperCAmelCase__ = 2_8_4_3_3 * (pow(2 , 7_8_3_0_4_5_7 , lowerCamelCase )) + 1
return str(number % modulus )
if __name__ == "__main__":
from doctest import testmod
testmod()
print(F"""{solution(10) = }""")
| 632 | """simple docstring"""
from typing import Optional
import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin
from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]
@register_to_config
def __init__( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : int = 50_257 ,lowerCamelCase__ : int = 1_024 ,lowerCamelCase__ : int = 768 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "gelu_new" ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 1e-5 ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
super().__init__()
UpperCAmelCase__ = prefix_length
if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
raise ValueError(
f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
f''' `n_embd`: {n_embd} are not equal.''' )
UpperCAmelCase__ = prefix_inner_dim
UpperCAmelCase__ = prefix_hidden_dim
UpperCAmelCase__ = (
nn.Linear(self.prefix_inner_dim ,self.prefix_hidden_dim )
if self.prefix_hidden_dim is not None
else nn.Identity()
)
UpperCAmelCase__ = (
nn.Linear(self.prefix_hidden_dim ,lowerCamelCase__ ) if self.prefix_hidden_dim is not None else nn.Identity()
)
UpperCAmelCase__ = GPTaConfig(
vocab_size=lowerCamelCase__ ,n_positions=lowerCamelCase__ ,n_embd=lowerCamelCase__ ,n_layer=lowerCamelCase__ ,n_head=lowerCamelCase__ ,n_inner=lowerCamelCase__ ,activation_function=lowerCamelCase__ ,resid_pdrop=lowerCamelCase__ ,embd_pdrop=lowerCamelCase__ ,attn_pdrop=lowerCamelCase__ ,layer_norm_epsilon=lowerCamelCase__ ,initializer_range=lowerCamelCase__ ,scale_attn_weights=lowerCamelCase__ ,use_cache=lowerCamelCase__ ,scale_attn_by_inverse_layer_idx=lowerCamelCase__ ,reorder_and_upcast_attn=lowerCamelCase__ ,)
UpperCAmelCase__ = GPTaLMHeadModel(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : Optional[torch.Tensor] = None ,lowerCamelCase__ : Optional[torch.Tensor] = None ,):
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
UpperCAmelCase__ = self.encode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = self.decode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = torch.cat((prefix_embeds, embedding_text) ,dim=1 )
if labels is not None:
UpperCAmelCase__ = self.get_dummy_token(input_ids.shape[0] ,input_ids.device )
UpperCAmelCase__ = torch.cat((dummy_token, input_ids) ,dim=1 )
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ ,labels=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
if self.prefix_hidden_dim is not None:
return out, hidden
else:
return out
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : torch.device ):
return torch.zeros(lowerCamelCase__ ,self.prefix_length ,dtype=torch.intaa ,device=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[str] ):
return self.encode_prefix(lowerCamelCase__ )
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = torch.split(lowerCamelCase__ ,1 ,dim=0 )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for feature in features:
UpperCAmelCase__ = self.decode_prefix(feature.to(lowerCamelCase__ ) ) # back to the clip feature
# Only support beam search for now
UpperCAmelCase__ , UpperCAmelCase__ = self.generate_beam(
input_embeds=lowerCamelCase__ ,device=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
generated_tokens.append(output_tokens[0] )
generated_seq_lengths.append(seq_lengths[0] )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
return generated_tokens, generated_seq_lengths
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int = 5 ,lowerCamelCase__ : int = 67 ,lowerCamelCase__ : float = 1.0 ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = eos_token_id
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = torch.ones(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.int )
UpperCAmelCase__ = torch.zeros(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.bool )
if input_embeds is not None:
UpperCAmelCase__ = input_embeds
else:
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ )
UpperCAmelCase__ = outputs.logits
UpperCAmelCase__ = logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
UpperCAmelCase__ = logits.softmax(-1 ).log()
if scores is None:
UpperCAmelCase__ , UpperCAmelCase__ = logits.topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = generated.expand(lowerCamelCase__ ,*generated.shape[1:] )
UpperCAmelCase__ , UpperCAmelCase__ = next_tokens.permute(1 ,0 ), scores.squeeze(0 )
if tokens is None:
UpperCAmelCase__ = next_tokens
else:
UpperCAmelCase__ = tokens.expand(lowerCamelCase__ ,*tokens.shape[1:] )
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
else:
UpperCAmelCase__ = -float(np.inf )
UpperCAmelCase__ = 0
UpperCAmelCase__ = scores[:, None] + logits
seq_lengths[~is_stopped] += 1
UpperCAmelCase__ = scores_sum / seq_lengths[:, None]
UpperCAmelCase__ , UpperCAmelCase__ = scores_sum_average.view(-1 ).topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = next_tokens // scores_sum.shape[1]
UpperCAmelCase__ = seq_lengths[next_tokens_source]
UpperCAmelCase__ = next_tokens % scores_sum.shape[1]
UpperCAmelCase__ = next_tokens.unsqueeze(1 )
UpperCAmelCase__ = tokens[next_tokens_source]
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
UpperCAmelCase__ = generated[next_tokens_source]
UpperCAmelCase__ = scores_sum_average * seq_lengths
UpperCAmelCase__ = is_stopped[next_tokens_source]
UpperCAmelCase__ = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] ,1 ,-1 )
UpperCAmelCase__ = torch.cat((generated, next_token_embed) ,dim=1 )
UpperCAmelCase__ = is_stopped + next_tokens.eq(lowerCamelCase__ ).squeeze()
if is_stopped.all():
break
UpperCAmelCase__ = scores / seq_lengths
UpperCAmelCase__ = scores.argsort(descending=lowerCamelCase__ )
# tokens tensors are already padded to max_seq_length
UpperCAmelCase__ = [tokens[i] for i in order]
UpperCAmelCase__ = torch.stack(lowerCamelCase__ ,dim=0 )
UpperCAmelCase__ = torch.tensor([seq_lengths[i] for i in order] ,dtype=seq_lengths.dtype )
return output_texts, seq_lengths
| 632 | 1 |
"""simple docstring"""
import math
from collections import defaultdict
from typing import List, Optional, Tuple, Union
import numpy as np
import torch
from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
def a_ ( lowerCamelCase , lowerCamelCase=0.999 , lowerCamelCase="cosine" , ):
if alpha_transform_type == "cosine":
def alpha_bar_fn(lowerCamelCase ):
return math.cos((t + 0.008) / 1.008 * math.pi / 2 ) ** 2
elif alpha_transform_type == "exp":
def alpha_bar_fn(lowerCamelCase ):
return math.exp(t * -12.0 )
else:
raise ValueError(f'''Unsupported alpha_tranform_type: {alpha_transform_type}''' )
UpperCAmelCase__ = []
for i in range(lowerCamelCase ):
UpperCAmelCase__ = i / num_diffusion_timesteps
UpperCAmelCase__ = (i + 1) / num_diffusion_timesteps
betas.append(min(1 - alpha_bar_fn(lowerCamelCase ) / alpha_bar_fn(lowerCamelCase ) , lowerCamelCase ) )
return torch.tensor(lowerCamelCase , dtype=torch.floataa )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [e.name for e in KarrasDiffusionSchedulers]
snake_case__ = 2
@register_to_config
def __init__( self : Optional[Any] ,lowerCamelCase__ : int = 1_000 ,lowerCamelCase__ : float = 0.0_0_0_8_5 ,lowerCamelCase__ : float = 0.0_1_2 ,lowerCamelCase__ : str = "linear" ,lowerCamelCase__ : Optional[Union[np.ndarray, List[float]]] = None ,lowerCamelCase__ : str = "epsilon" ,lowerCamelCase__ : str = "linspace" ,lowerCamelCase__ : int = 0 ,):
if trained_betas is not None:
UpperCAmelCase__ = torch.tensor(lowerCamelCase__ ,dtype=torch.floataa )
elif beta_schedule == "linear":
UpperCAmelCase__ = torch.linspace(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,dtype=torch.floataa )
elif beta_schedule == "scaled_linear":
# this schedule is very specific to the latent diffusion model.
UpperCAmelCase__ = (
torch.linspace(beta_start**0.5 ,beta_end**0.5 ,lowerCamelCase__ ,dtype=torch.floataa ) ** 2
)
elif beta_schedule == "squaredcos_cap_v2":
# Glide cosine schedule
UpperCAmelCase__ = betas_for_alpha_bar(lowerCamelCase__ )
else:
raise NotImplementedError(f'''{beta_schedule} does is not implemented for {self.__class__}''' )
UpperCAmelCase__ = 1.0 - self.betas
UpperCAmelCase__ = torch.cumprod(self.alphas ,dim=0 )
# set all values
self.set_timesteps(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[Any]=None ):
if schedule_timesteps is None:
UpperCAmelCase__ = self.timesteps
UpperCAmelCase__ = (schedule_timesteps == timestep).nonzero()
# The sigma index that is taken for the **very** first `step`
# is always the second index (or the last index if there is only 1)
# This way we can ensure we don't accidentally skip a sigma in
# case we start in the middle of the denoising schedule (e.g. for image-to-image)
if len(self._index_counter ) == 0:
UpperCAmelCase__ = 1 if len(lowerCamelCase__ ) > 1 else 0
else:
UpperCAmelCase__ = timestep.cpu().item() if torch.is_tensor(lowerCamelCase__ ) else timestep
UpperCAmelCase__ = self._index_counter[timestep_int]
return indices[pos].item()
@property
def __lowerCAmelCase ( self : Union[str, Any] ):
# standard deviation of the initial noise distribution
if self.config.timestep_spacing in ["linspace", "trailing"]:
return self.sigmas.max()
return (self.sigmas.max() ** 2 + 1) ** 0.5
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : torch.FloatTensor ,lowerCamelCase__ : Union[float, torch.FloatTensor] ,):
UpperCAmelCase__ = self.index_for_timestep(lowerCamelCase__ )
if self.state_in_first_order:
UpperCAmelCase__ = self.sigmas[step_index]
else:
UpperCAmelCase__ = self.sigmas_interpol[step_index]
UpperCAmelCase__ = sample / ((sigma**2 + 1) ** 0.5)
return sample
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : int ,lowerCamelCase__ : Union[str, torch.device] = None ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = num_inference_steps
UpperCAmelCase__ = num_train_timesteps or self.config.num_train_timesteps
# "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
if self.config.timestep_spacing == "linspace":
UpperCAmelCase__ = np.linspace(0 ,num_train_timesteps - 1 ,lowerCamelCase__ ,dtype=lowerCamelCase__ )[::-1].copy()
elif self.config.timestep_spacing == "leading":
UpperCAmelCase__ = num_train_timesteps // self.num_inference_steps
# creates integer timesteps by multiplying by ratio
# casting to int to avoid issues when num_inference_step is power of 3
UpperCAmelCase__ = (np.arange(0 ,lowerCamelCase__ ) * step_ratio).round()[::-1].copy().astype(lowerCamelCase__ )
timesteps += self.config.steps_offset
elif self.config.timestep_spacing == "trailing":
UpperCAmelCase__ = num_train_timesteps / self.num_inference_steps
# creates integer timesteps by multiplying by ratio
# casting to int to avoid issues when num_inference_step is power of 3
UpperCAmelCase__ = (np.arange(lowerCamelCase__ ,0 ,-step_ratio )).round().copy().astype(lowerCamelCase__ )
timesteps -= 1
else:
raise ValueError(
f'''{self.config.timestep_spacing} is not supported. Please make sure to choose one of \'linspace\', \'leading\' or \'trailing\'.''' )
UpperCAmelCase__ = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5 )
UpperCAmelCase__ = torch.from_numpy(np.log(lowerCamelCase__ ) ).to(lowerCamelCase__ )
UpperCAmelCase__ = np.interp(lowerCamelCase__ ,np.arange(0 ,len(lowerCamelCase__ ) ) ,lowerCamelCase__ )
UpperCAmelCase__ = np.concatenate([sigmas, [0.0]] ).astype(np.floataa )
UpperCAmelCase__ = torch.from_numpy(lowerCamelCase__ ).to(device=lowerCamelCase__ )
# interpolate sigmas
UpperCAmelCase__ = sigmas.log().lerp(sigmas.roll(1 ).log() ,0.5 ).exp()
UpperCAmelCase__ = torch.cat([sigmas[:1], sigmas[1:].repeat_interleave(2 ), sigmas[-1:]] )
UpperCAmelCase__ = torch.cat(
[sigmas_interpol[:1], sigmas_interpol[1:].repeat_interleave(2 ), sigmas_interpol[-1:]] )
if str(lowerCamelCase__ ).startswith('mps' ):
# mps does not support float64
UpperCAmelCase__ = torch.from_numpy(lowerCamelCase__ ).to(lowerCamelCase__ ,dtype=torch.floataa )
else:
UpperCAmelCase__ = torch.from_numpy(lowerCamelCase__ ).to(lowerCamelCase__ )
# interpolate timesteps
UpperCAmelCase__ = self.sigma_to_t(lowerCamelCase__ ).to(lowerCamelCase__ ,dtype=timesteps.dtype )
UpperCAmelCase__ = torch.stack((timesteps_interpol[1:-1, None], timesteps[1:, None]) ,dim=-1 ).flatten()
UpperCAmelCase__ = torch.cat([timesteps[:1], interleaved_timesteps] )
UpperCAmelCase__ = None
# for exp beta schedules, such as the one for `pipeline_shap_e.py`
# we need an index counter
UpperCAmelCase__ = defaultdict(lowerCamelCase__ )
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : Optional[Any] ):
# get log sigma
UpperCAmelCase__ = sigma.log()
# get distribution
UpperCAmelCase__ = log_sigma - self.log_sigmas[:, None]
# get sigmas range
UpperCAmelCase__ = dists.ge(0 ).cumsum(dim=0 ).argmax(dim=0 ).clamp(max=self.log_sigmas.shape[0] - 2 )
UpperCAmelCase__ = low_idx + 1
UpperCAmelCase__ = self.log_sigmas[low_idx]
UpperCAmelCase__ = self.log_sigmas[high_idx]
# interpolate sigmas
UpperCAmelCase__ = (low - log_sigma) / (low - high)
UpperCAmelCase__ = w.clamp(0 ,1 )
# transform interpolation to time range
UpperCAmelCase__ = (1 - w) * low_idx + w * high_idx
UpperCAmelCase__ = t.view(sigma.shape )
return t
@property
def __lowerCAmelCase ( self : Optional[Any] ):
return self.sample is None
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[torch.FloatTensor, np.ndarray] ,lowerCamelCase__ : Union[float, torch.FloatTensor] ,lowerCamelCase__ : Union[torch.FloatTensor, np.ndarray] ,lowerCamelCase__ : bool = True ,):
UpperCAmelCase__ = self.index_for_timestep(lowerCamelCase__ )
# advance index counter by 1
UpperCAmelCase__ = timestep.cpu().item() if torch.is_tensor(lowerCamelCase__ ) else timestep
self._index_counter[timestep_int] += 1
if self.state_in_first_order:
UpperCAmelCase__ = self.sigmas[step_index]
UpperCAmelCase__ = self.sigmas_interpol[step_index + 1]
UpperCAmelCase__ = self.sigmas[step_index + 1]
else:
# 2nd order / KDPM2's method
UpperCAmelCase__ = self.sigmas[step_index - 1]
UpperCAmelCase__ = self.sigmas_interpol[step_index]
UpperCAmelCase__ = self.sigmas[step_index]
# currently only gamma=0 is supported. This usually works best anyways.
# We can support gamma in the future but then need to scale the timestep before
# passing it to the model which requires a change in API
UpperCAmelCase__ = 0
UpperCAmelCase__ = sigma * (gamma + 1) # Note: sigma_hat == sigma for now
# 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
if self.config.prediction_type == "epsilon":
UpperCAmelCase__ = sigma_hat if self.state_in_first_order else sigma_interpol
UpperCAmelCase__ = sample - sigma_input * model_output
elif self.config.prediction_type == "v_prediction":
UpperCAmelCase__ = sigma_hat if self.state_in_first_order else sigma_interpol
UpperCAmelCase__ = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + (
sample / (sigma_input**2 + 1)
)
elif self.config.prediction_type == "sample":
raise NotImplementedError('prediction_type not implemented yet: sample' )
else:
raise ValueError(
f'''prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`''' )
if self.state_in_first_order:
# 2. Convert to an ODE derivative for 1st order
UpperCAmelCase__ = (sample - pred_original_sample) / sigma_hat
# 3. delta timestep
UpperCAmelCase__ = sigma_interpol - sigma_hat
# store for 2nd order step
UpperCAmelCase__ = sample
else:
# DPM-Solver-2
# 2. Convert to an ODE derivative for 2nd order
UpperCAmelCase__ = (sample - pred_original_sample) / sigma_interpol
# 3. delta timestep
UpperCAmelCase__ = sigma_next - sigma_hat
UpperCAmelCase__ = self.sample
UpperCAmelCase__ = None
UpperCAmelCase__ = sample + derivative * dt
if not return_dict:
return (prev_sample,)
return SchedulerOutput(prev_sample=lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : torch.FloatTensor ,lowerCamelCase__ : torch.FloatTensor ,lowerCamelCase__ : torch.FloatTensor ,):
# Make sure sigmas and timesteps have the same device and dtype as original_samples
UpperCAmelCase__ = self.sigmas.to(device=original_samples.device ,dtype=original_samples.dtype )
if original_samples.device.type == "mps" and torch.is_floating_point(lowerCamelCase__ ):
# mps does not support float64
UpperCAmelCase__ = self.timesteps.to(original_samples.device ,dtype=torch.floataa )
UpperCAmelCase__ = timesteps.to(original_samples.device ,dtype=torch.floataa )
else:
UpperCAmelCase__ = self.timesteps.to(original_samples.device )
UpperCAmelCase__ = timesteps.to(original_samples.device )
UpperCAmelCase__ = [self.index_for_timestep(lowerCamelCase__ ,lowerCamelCase__ ) for t in timesteps]
UpperCAmelCase__ = sigmas[step_indices].flatten()
while len(sigma.shape ) < len(original_samples.shape ):
UpperCAmelCase__ = sigma.unsqueeze(-1 )
UpperCAmelCase__ = original_samples + noise * sigma
return noisy_samples
def __len__( self : List[str] ):
return self.config.num_train_timesteps
| 632 | """simple docstring"""
import argparse
import os
import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints
from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
lowerCAmelCase__ : str = 'base_with_context'
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['token_embedder']['embedding'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['input_proj']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['continuous_inputs_projection']['kernel'].T ) )
for lyr_num, lyr in enumerate(model.decoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_self_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_0']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['self_attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['MultiHeadDotProductAttention_0']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_cross_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_1']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['decoder_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['spec_out_dense']['kernel'].T ) )
return model
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = checkpoints.load_tax_checkpoint(args.checkpoint_path )
UpperCAmelCase__ = jnp.tree_util.tree_map(onp.array , lowerCamelCase )
UpperCAmelCase__ = [
'from __gin__ import dynamic_registration',
'from music_spectrogram_diffusion.models.diffusion import diffusion_utils',
'diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0',
'diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()',
]
UpperCAmelCase__ = os.path.join(args.checkpoint_path , '..' , 'config.gin' )
UpperCAmelCase__ = inference.parse_training_gin_file(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = inference.InferenceModel(args.checkpoint_path , lowerCamelCase )
UpperCAmelCase__ = DDPMScheduler(beta_schedule='squaredcos_cap_v2' , variance_type='fixed_large' )
UpperCAmelCase__ = SpectrogramNotesEncoder(
max_length=synth_model.sequence_length['inputs'] , vocab_size=synth_model.model.module.config.vocab_size , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = SpectrogramContEncoder(
input_dims=synth_model.audio_codec.n_dims , targets_context_length=synth_model.sequence_length['targets_context'] , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = TaFilmDecoder(
input_dims=synth_model.audio_codec.n_dims , targets_length=synth_model.sequence_length['targets_context'] , max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time , d_model=synth_model.model.module.config.emb_dim , num_layers=synth_model.model.module.config.num_decoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , dropout_rate=synth_model.model.module.config.dropout_rate , )
UpperCAmelCase__ = load_notes_encoder(ta_checkpoint['target']['token_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_continuous_encoder(ta_checkpoint['target']['continuous_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_decoder(ta_checkpoint['target']['decoder'] , lowerCamelCase )
UpperCAmelCase__ = OnnxRuntimeModel.from_pretrained('kashif/soundstream_mel_decoder' )
UpperCAmelCase__ = SpectrogramDiffusionPipeline(
notes_encoder=lowerCamelCase , continuous_encoder=lowerCamelCase , decoder=lowerCamelCase , scheduler=lowerCamelCase , melgan=lowerCamelCase , )
if args.save:
pipe.save_pretrained(args.output_path )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
parser.add_argument('--output_path', default=None, type=str, required=True, help='Path to the converted model.')
parser.add_argument(
'--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
)
parser.add_argument(
'--checkpoint_path',
default=F"""{MODEL}/checkpoint_500000""",
type=str,
required=False,
help='Path to the original jax model checkpoint.',
)
lowerCAmelCase__ : List[str] = parser.parse_args()
main(args)
| 632 | 1 |
"""simple docstring"""
import argparse
import math
import os
import torch
from neural_compressor.utils.pytorch import load
from PIL import Image
from transformers import CLIPTextModel, CLIPTokenizer
from diffusers import AutoencoderKL, StableDiffusionPipeline, UNetaDConditionModel
def a_ ( ):
UpperCAmelCase__ = argparse.ArgumentParser()
parser.add_argument(
'-m' , '--pretrained_model_name_or_path' , type=lowerCamelCase , default=lowerCamelCase , required=lowerCamelCase , help='Path to pretrained model or model identifier from huggingface.co/models.' , )
parser.add_argument(
'-c' , '--caption' , type=lowerCamelCase , default='robotic cat with wings' , help='Text used to generate images.' , )
parser.add_argument(
'-n' , '--images_num' , type=lowerCamelCase , default=4 , help='How much images to generate.' , )
parser.add_argument(
'-s' , '--seed' , type=lowerCamelCase , default=4_2 , help='Seed for random process.' , )
parser.add_argument(
'-ci' , '--cuda_id' , type=lowerCamelCase , default=0 , help='cuda_id.' , )
UpperCAmelCase__ = parser.parse_args()
return args
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if not len(lowerCamelCase ) == rows * cols:
raise ValueError('The specified number of rows and columns are not correct.' )
UpperCAmelCase__ , UpperCAmelCase__ = imgs[0].size
UpperCAmelCase__ = Image.new('RGB' , size=(cols * w, rows * h) )
UpperCAmelCase__ , UpperCAmelCase__ = grid.size
for i, img in enumerate(lowerCamelCase ):
grid.paste(lowerCamelCase , box=(i % cols * w, i // cols * h) )
return grid
def a_ ( lowerCamelCase , lowerCamelCase="robotic cat with wings" , lowerCamelCase=7.5 , lowerCamelCase=5_0 , lowerCamelCase=1 , lowerCamelCase=4_2 , ):
UpperCAmelCase__ = torch.Generator(pipeline.device ).manual_seed(lowerCamelCase )
UpperCAmelCase__ = pipeline(
lowerCamelCase , guidance_scale=lowerCamelCase , num_inference_steps=lowerCamelCase , generator=lowerCamelCase , num_images_per_prompt=lowerCamelCase , ).images
UpperCAmelCase__ = int(math.sqrt(lowerCamelCase ) )
UpperCAmelCase__ = image_grid(lowerCamelCase , rows=_rows , cols=num_images_per_prompt // _rows )
return grid, images
lowerCAmelCase__ : List[str] = parse_args()
# Load models and create wrapper for stable diffusion
lowerCAmelCase__ : List[str] = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer')
lowerCAmelCase__ : Tuple = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder')
lowerCAmelCase__ : int = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder='vae')
lowerCAmelCase__ : Tuple = UNetaDConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='unet')
lowerCAmelCase__ : Optional[Any] = StableDiffusionPipeline.from_pretrained(
args.pretrained_model_name_or_path, text_encoder=text_encoder, vae=vae, unet=unet, tokenizer=tokenizer
)
lowerCAmelCase__ : int = lambda images, clip_input: (images, False)
if os.path.exists(os.path.join(args.pretrained_model_name_or_path, 'best_model.pt')):
lowerCAmelCase__ : int = load(args.pretrained_model_name_or_path, model=unet)
unet.eval()
setattr(pipeline, 'unet', unet)
else:
lowerCAmelCase__ : List[Any] = unet.to(torch.device('cuda', args.cuda_id))
lowerCAmelCase__ : List[Any] = pipeline.to(unet.device)
lowerCAmelCase__ , lowerCAmelCase__ : Optional[Any] = generate_images(pipeline, prompt=args.caption, num_images_per_prompt=args.images_num, seed=args.seed)
grid.save(os.path.join(args.pretrained_model_name_or_path, '{}.png'.format('_'.join(args.caption.split()))))
lowerCAmelCase__ : Union[str, Any] = os.path.join(args.pretrained_model_name_or_path, '_'.join(args.caption.split()))
os.makedirs(dirname, exist_ok=True)
for idx, image in enumerate(images):
image.save(os.path.join(dirname, '{}.png'.format(idx + 1)))
| 632 | """simple docstring"""
import socket
def a_ ( ):
UpperCAmelCase__ = socket.socket(socket.AF_INET , socket.SOCK_STREAM )
UpperCAmelCase__ = socket.gethostname()
UpperCAmelCase__ = 1_2_3_1_2
sock.connect((host, port) )
sock.send(b'Hello server!' )
with open('Received_file' , 'wb' ) as out_file:
print('File opened' )
print('Receiving data...' )
while True:
UpperCAmelCase__ = sock.recv(1_0_2_4 )
if not data:
break
out_file.write(lowerCamelCase )
print('Successfully received the file' )
sock.close()
print('Connection closed' )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
from math import pi
def a_ ( lowerCamelCase , lowerCamelCase ):
return 2 * pi * radius * (angle / 3_6_0)
if __name__ == "__main__":
print(arc_length(90, 10))
| 632 | """simple docstring"""
from __future__ import annotations
class snake_case :
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : list[list[int]] ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = 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
UpperCAmelCase__ = rows
else:
UpperCAmelCase__ = []
def __lowerCAmelCase ( self : Union[str, Any] ):
return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]
@property
def __lowerCAmelCase ( self : str ):
return len(self.rows )
@property
def __lowerCAmelCase ( self : List[Any] ):
return len(self.rows[0] )
@property
def __lowerCAmelCase ( self : Any ):
return (self.num_rows, self.num_columns)
@property
def __lowerCAmelCase ( self : Optional[int] ):
return self.order[0] == self.order[1]
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = [
[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 __lowerCAmelCase ( self : str ):
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 __lowerCAmelCase ( self : List[str] ):
return bool(self.determinant() )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
UpperCAmelCase__ = [
[
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 __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if (row + column) % 2 == 0:
return self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
return -1 * self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
return Matrix(
[
[self.get_minor(lowerCamelCase__ ,lowerCamelCase__ ) for column in range(self.num_columns )]
for row in range(self.num_rows )
] )
def __lowerCAmelCase ( self : int ):
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 __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = [
[self.cofactors().rows[column][row] for column in range(self.num_columns )]
for row in range(self.num_rows )
]
return Matrix(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = 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 : Optional[Any] ):
return str(self.rows )
def __str__( self : List[str] ):
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 __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = self.rows[0:position] + [row] + self.rows[position:]
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = [self.rows[i] + [column[i]] for i in range(self.num_rows )]
else:
UpperCAmelCase__ = [
self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
for i in range(self.num_rows )
]
def __eq__( self : List[Any] ,lowerCamelCase__ : object ):
if not isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
return NotImplemented
return self.rows == other.rows
def __ne__( self : Any ,lowerCamelCase__ : object ):
return not self == other
def __neg__( self : Dict ):
return self * -1
def __add__( self : str ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix | int | float ):
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 ):
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' )
UpperCAmelCase__ = self
for _ in range(other - 1 ):
result *= self
return result
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
return sum(row[i] * column[i] for i in range(len(lowerCamelCase__ ) ) )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return int((input_a, input_a).count(0 ) != 0 )
def a_ ( ):
assert nand_gate(0 , 0 ) == 1
assert nand_gate(0 , 1 ) == 1
assert nand_gate(1 , 0 ) == 1
assert nand_gate(1 , 1 ) == 0
if __name__ == "__main__":
print(nand_gate(0, 0))
print(nand_gate(0, 1))
print(nand_gate(1, 0))
print(nand_gate(1, 1))
| 632 | """simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
lowerCAmelCase__ : int = {
'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
'tokenization_tapas': ['TapasTokenizer'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Union[str, Any] = [
'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TapasForMaskedLM',
'TapasForQuestionAnswering',
'TapasForSequenceClassification',
'TapasModel',
'TapasPreTrainedModel',
'load_tf_weights_in_tapas',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFTapasForMaskedLM',
'TFTapasForQuestionAnswering',
'TFTapasForSequenceClassification',
'TFTapasModel',
'TFTapasPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
from .tokenization_tapas import TapasTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tapas import (
TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
TapasPreTrainedModel,
load_tf_weights_in_tapas,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_tapas import (
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTapasForMaskedLM,
TFTapasForQuestionAnswering,
TFTapasForSequenceClassification,
TFTapasModel,
TFTapasPreTrainedModel,
)
else:
import sys
lowerCAmelCase__ : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | 1 |
"""simple docstring"""
import math
def a_ ( lowerCamelCase ):
if not isinstance(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = f'''Input value of [number={number}] must be an integer'''
raise TypeError(lowerCamelCase )
if number < 1:
UpperCAmelCase__ = f'''Input value of [number={number}] must be > 0'''
raise ValueError(lowerCamelCase )
elif number == 1:
return 3
elif number == 2:
return 5
else:
UpperCAmelCase__ = int(math.log(number // 3 , 2 ) ) + 2
UpperCAmelCase__ = [3, 5]
UpperCAmelCase__ = 2
UpperCAmelCase__ = 3
for block in range(1 , lowerCamelCase ):
for _ in range(lowerCamelCase ):
proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1] )
proth_index += 1
increment *= 2
return proth_list[number - 1]
if __name__ == "__main__":
import doctest
doctest.testmod()
for number in range(11):
lowerCAmelCase__ : Tuple = 0
try:
lowerCAmelCase__ : Any = proth(number)
except ValueError:
print(F"""ValueError: there is no {number}th Proth number""")
continue
print(F"""The {number}th Proth number: {value}""")
| 632 | """simple docstring"""
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device
lowerCAmelCase__ : Optional[int] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@slow
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe(
image=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.0_4_4_1, 0.0_4_6_9, 0.0_5_0_7, 0.0_5_7_5, 0.0_6_3_2, 0.0_6_5_0, 0.0_8_6_5, 0.0_9_0_9, 0.0_9_4_5] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 632 | 1 |
"""simple docstring"""
import gc
import random
import unittest
import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
import diffusers
from diffusers import (
AutoencoderKL,
EulerDiscreteScheduler,
StableDiffusionLatentUpscalePipeline,
StableDiffusionPipeline,
UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin
enable_full_determinism()
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = [tensor.shape for tensor in tensor_list]
return all(shape == shapes[0] for shape in shapes[1:] )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = StableDiffusionLatentUpscalePipeline
snake_case__ = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
"height",
"width",
"cross_attention_kwargs",
"negative_prompt_embeds",
"prompt_embeds",
}
snake_case__ = PipelineTesterMixin.required_optional_params - {"num_images_per_prompt"}
snake_case__ = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
snake_case__ = frozenset(
[] ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
snake_case__ = frozenset([] )
snake_case__ = True
@property
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = 1
UpperCAmelCase__ = 4
UpperCAmelCase__ = (16, 16)
UpperCAmelCase__ = floats_tensor((batch_size, num_channels) + sizes ,rng=random.Random(0 ) ).to(lowerCamelCase__ )
return image
def __lowerCAmelCase ( self : str ):
torch.manual_seed(0 )
UpperCAmelCase__ = UNetaDConditionModel(
act_fn='gelu' ,attention_head_dim=8 ,norm_num_groups=lowerCamelCase__ ,block_out_channels=[32, 32, 64, 64] ,time_cond_proj_dim=160 ,conv_in_kernel=1 ,conv_out_kernel=1 ,cross_attention_dim=32 ,down_block_types=(
'KDownBlock2D',
'KCrossAttnDownBlock2D',
'KCrossAttnDownBlock2D',
'KCrossAttnDownBlock2D',
) ,in_channels=8 ,mid_block_type=lowerCamelCase__ ,only_cross_attention=lowerCamelCase__ ,out_channels=5 ,resnet_time_scale_shift='scale_shift' ,time_embedding_type='fourier' ,timestep_post_act='gelu' ,up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D') ,)
UpperCAmelCase__ = AutoencoderKL(
block_out_channels=[32, 32, 64, 64] ,in_channels=3 ,out_channels=3 ,down_block_types=[
'DownEncoderBlock2D',
'DownEncoderBlock2D',
'DownEncoderBlock2D',
'DownEncoderBlock2D',
] ,up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D'] ,latent_channels=4 ,)
UpperCAmelCase__ = EulerDiscreteScheduler(prediction_type='sample' )
UpperCAmelCase__ = 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=1_000 ,hidden_act='quick_gelu' ,projection_dim=512 ,)
UpperCAmelCase__ = CLIPTextModel(lowerCamelCase__ )
UpperCAmelCase__ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )
UpperCAmelCase__ = {
'unet': model.eval(),
'vae': vae.eval(),
'scheduler': scheduler,
'text_encoder': text_encoder,
'tokenizer': tokenizer,
}
return components
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Dict=0 ):
if str(lowerCamelCase__ ).startswith('mps' ):
UpperCAmelCase__ = torch.manual_seed(lowerCamelCase__ )
else:
UpperCAmelCase__ = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
UpperCAmelCase__ = {
'prompt': 'A painting of a squirrel eating a burger',
'image': self.dummy_image.cpu(),
'generator': generator,
'num_inference_steps': 2,
'output_type': 'numpy',
}
return inputs
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = 'cpu'
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe(**lowerCamelCase__ ).images
UpperCAmelCase__ = image[0, -3:, -3:, -1]
self.assertEqual(image.shape ,(1, 256, 256, 3) )
UpperCAmelCase__ = np.array(
[0.4_7_2_2_2_4_1_2, 0.4_1_9_2_1_6_3_3, 0.4_4_7_1_7_4_3_4, 0.4_6_8_7_4_1_9_2, 0.4_2_5_8_8_2_5_8, 0.4_6_1_5_0_7_2_6, 0.4_6_7_7_5_3_4, 0.4_5_5_8_3_8_3_2, 0.4_8_5_7_9_0_5_5] )
UpperCAmelCase__ = np.abs(image_slice.flatten() - expected_slice ).max()
self.assertLessEqual(lowerCamelCase__ ,1e-3 )
def __lowerCAmelCase ( self : Dict ):
super().test_attention_slicing_forward_pass(expected_max_diff=7e-3 )
def __lowerCAmelCase ( self : str ):
super().test_cpu_offload_forward_pass(expected_max_diff=3e-3 )
def __lowerCAmelCase ( self : List[Any] ):
super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )
def __lowerCAmelCase ( self : Union[str, Any] ):
super().test_inference_batch_single_identical(expected_max_diff=7e-3 )
def __lowerCAmelCase ( self : Any ):
super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3 )
def __lowerCAmelCase ( self : Dict ):
super().test_save_load_local(expected_max_difference=3e-3 )
def __lowerCAmelCase ( self : Optional[Any] ):
super().test_save_load_optional_components(expected_max_difference=3e-3 )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [
'DDIMScheduler',
'DDPMScheduler',
'PNDMScheduler',
'HeunDiscreteScheduler',
'EulerAncestralDiscreteScheduler',
'KDPM2DiscreteScheduler',
'KDPM2AncestralDiscreteScheduler',
'DPMSolverSDEScheduler',
]
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
# make sure that PNDM does not need warm-up
pipe.scheduler.register_to_config(skip_prk_steps=lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_inputs(lowerCamelCase__ )
UpperCAmelCase__ = 2
UpperCAmelCase__ = []
for scheduler_enum in KarrasDiffusionSchedulers:
if scheduler_enum.name in skip_schedulers:
# no sigma schedulers are not supported
# no schedulers
continue
UpperCAmelCase__ = getattr(lowerCamelCase__ ,scheduler_enum.name )
UpperCAmelCase__ = scheduler_cls.from_config(pipe.scheduler.config )
UpperCAmelCase__ = pipe(**lowerCamelCase__ )[0]
outputs.append(lowerCamelCase__ )
assert check_same_shape(lowerCamelCase__ )
@require_torch_gpu
@slow
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Dict ):
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = torch.manual_seed(33 )
UpperCAmelCase__ = StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ,torch_dtype=torch.floataa )
pipe.to('cuda' )
UpperCAmelCase__ = StableDiffusionLatentUpscalePipeline.from_pretrained(
'stabilityai/sd-x2-latent-upscaler' ,torch_dtype=torch.floataa )
upscaler.to('cuda' )
UpperCAmelCase__ = 'a photo of an astronaut high resolution, unreal engine, ultra realistic'
UpperCAmelCase__ = pipe(lowerCamelCase__ ,generator=lowerCamelCase__ ,output_type='latent' ).images
UpperCAmelCase__ = upscaler(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,num_inference_steps=20 ,guidance_scale=0 ,generator=lowerCamelCase__ ,output_type='np' ,).images[0]
UpperCAmelCase__ = load_numpy(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy' )
assert np.abs((expected_image - image).mean() ) < 5e-2
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = torch.manual_seed(33 )
UpperCAmelCase__ = StableDiffusionLatentUpscalePipeline.from_pretrained(
'stabilityai/sd-x2-latent-upscaler' ,torch_dtype=torch.floataa )
upscaler.to('cuda' )
UpperCAmelCase__ = 'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png' )
UpperCAmelCase__ = upscaler(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,num_inference_steps=20 ,guidance_scale=0 ,generator=lowerCamelCase__ ,output_type='np' ,).images[0]
UpperCAmelCase__ = load_numpy(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy' )
assert np.abs((expected_image - image).max() ) < 5e-2
| 632 | """simple docstring"""
from __future__ import annotations
from math import ceil, floor, sqrt
def a_ ( lowerCamelCase = 2_0_0_0_0_0_0 ):
UpperCAmelCase__ = [0]
UpperCAmelCase__ = 42
for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ):
triangle_numbers.append(triangle_numbers[-1] + idx )
# we want this to be as close as possible to target
UpperCAmelCase__ = 0
# the area corresponding to the grid that gives the product closest to target
UpperCAmelCase__ = 0
# an estimate of b, using the quadratic formula
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the triangle number corresponding to b_floor
UpperCAmelCase__ = 42
# the triangle number corresponding to b_ceil
UpperCAmelCase__ = 42
for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ):
UpperCAmelCase__ = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2
UpperCAmelCase__ = floor(lowerCamelCase )
UpperCAmelCase__ = ceil(lowerCamelCase )
UpperCAmelCase__ = triangle_numbers[b_floor]
UpperCAmelCase__ = triangle_numbers[b_ceil]
if abs(target - triangle_b_first_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_first_guess * triangle_a
UpperCAmelCase__ = idx_a * b_floor
if abs(target - triangle_b_second_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_second_guess * triangle_a
UpperCAmelCase__ = idx_a * b_ceil
return area
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import sacrebleu as scb
from packaging import version
from sacrebleu import TER
import datasets
lowerCAmelCase__ : str = '\\n@inproceedings{snover-etal-2006-study,\n title = "A Study of Translation Edit Rate with Targeted Human Annotation",\n author = "Snover, Matthew and\n Dorr, Bonnie and\n Schwartz, Rich and\n Micciulla, Linnea and\n Makhoul, John",\n booktitle = "Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers",\n month = aug # " 8-12",\n year = "2006",\n address = "Cambridge, Massachusetts, USA",\n publisher = "Association for Machine Translation in the Americas",\n url = "https://aclanthology.org/2006.amta-papers.25",\n pages = "223--231",\n}\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n'
lowerCAmelCase__ : Union[str, Any] = '\\nTER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a\nhypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu\n(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found\nhere: https://github.com/jhclark/tercom.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu\'s required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.\n'
lowerCAmelCase__ : Optional[Any] = '\nProduces TER scores alongside the number of edits and reference length.\n\nArgs:\n predictions (list of str): The system stream (a sequence of segments).\n references (list of list of str): A list of one or more reference streams (each a sequence of segments).\n normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.\n support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,\n as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.\n Only applies if `normalized = True`. Defaults to `False`.\n case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.\n\nReturns:\n \'score\' (float): TER score (num_edits / sum_ref_lengths * 100)\n \'num_edits\' (int): The cumulative number of edits\n \'ref_length\' (float): The cumulative average reference length\n\nExamples:\n Example 1:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?",\n ... "What did the TER metric user say to the developer?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],\n ... ["Your jokes are...", "...TERrible"]]\n >>> ter = datasets.load_metric("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 150.0, \'num_edits\': 15, \'ref_length\': 10.0}\n\n Example 2:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = datasets.load_metric("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 62.5, \'num_edits\': 5, \'ref_length\': 8.0}\n\n Example 3:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = datasets.load_metric("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... normalized=True,\n ... case_sensitive=True)\n >>> print(results)\n {\'score\': 57.14285714285714, \'num_edits\': 6, \'ref_length\': 10.5}\n\n Example 4:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]\n >>> ter = datasets.load_metric("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... ignore_punct=True,\n ... case_sensitive=False)\n >>> print(results)\n {\'score\': 0.0, \'num_edits\': 0, \'ref_length\': 8.0}\n\n Example 5:\n >>> predictions = ["does this sentence match??",\n ... "what about this sentence?",\n ... "What did the TER metric user say to the developer?"]\n >>> references = [["does this sentence match", "does this sentence match!?!"],\n ... ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],\n ... ["Your jokes are...", "...TERrible"]]\n >>> ter = datasets.load_metric("ter")\n >>> results = ter.compute(predictions=predictions,\n ... references=references,\n ... ignore_punct=True,\n ... case_sensitive=False)\n >>> print(results)\n {\'score\': 100.0, \'num_edits\': 10, \'ref_length\': 10.0}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class snake_case ( datasets.Metric ):
"""simple docstring"""
def __lowerCAmelCase ( self : Union[str, Any] ):
if version.parse(scb.__version__ ) < version.parse('1.4.12' ):
raise ImportWarning(
'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
'You can install it with `pip install "sacrebleu>=1.4.12"`.' )
return datasets.MetricInfo(
description=_DESCRIPTION ,citation=_CITATION ,homepage='http://www.cs.umd.edu/~snover/tercom/' ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features(
{
'predictions': datasets.Value('string' ,id='sequence' ),
'references': datasets.Sequence(datasets.Value('string' ,id='sequence' ) ,id='references' ),
} ) ,codebase_urls=['https://github.com/mjpost/sacreBLEU#ter'] ,reference_urls=[
'https://github.com/jhclark/tercom',
] ,)
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
UpperCAmelCase__ = len(references[0] )
if any(len(lowerCamelCase__ ) != references_per_prediction for refs in references ):
raise ValueError('Sacrebleu requires the same number of references for each prediction' )
UpperCAmelCase__ = [[refs[i] for refs in references] for i in range(lowerCamelCase__ )]
UpperCAmelCase__ = TER(
normalized=lowerCamelCase__ ,no_punct=lowerCamelCase__ ,asian_support=lowerCamelCase__ ,case_sensitive=lowerCamelCase__ ,)
UpperCAmelCase__ = sb_ter.corpus_score(lowerCamelCase__ ,lowerCamelCase__ )
return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}
| 632 | """simple docstring"""
import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple
import torch
from audiocraft.models import MusicGen
from transformers import (
AutoFeatureExtractor,
AutoTokenizer,
EncodecModel,
MusicgenDecoderConfig,
MusicgenForConditionalGeneration,
MusicgenProcessor,
TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging
logging.set_verbosity_info()
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[Any] = ['model.decoder.embed_positions.weights']
def a_ ( lowerCamelCase ):
if "emb" in name:
UpperCAmelCase__ = name.replace('emb' , 'model.decoder.embed_tokens' )
if "transformer" in name:
UpperCAmelCase__ = name.replace('transformer' , 'model.decoder' )
if "cross_attention" in name:
UpperCAmelCase__ = name.replace('cross_attention' , 'encoder_attn' )
if "linear1" in name:
UpperCAmelCase__ = name.replace('linear1' , 'fc1' )
if "linear2" in name:
UpperCAmelCase__ = name.replace('linear2' , 'fc2' )
if "norm1" in name:
UpperCAmelCase__ = name.replace('norm1' , 'self_attn_layer_norm' )
if "norm_cross" in name:
UpperCAmelCase__ = name.replace('norm_cross' , 'encoder_attn_layer_norm' )
if "norm2" in name:
UpperCAmelCase__ = name.replace('norm2' , 'final_layer_norm' )
if "out_norm" in name:
UpperCAmelCase__ = name.replace('out_norm' , 'model.decoder.layer_norm' )
if "linears" in name:
UpperCAmelCase__ = name.replace('linears' , 'lm_heads' )
if "condition_provider.conditioners.description.output_proj" in name:
UpperCAmelCase__ = name.replace('condition_provider.conditioners.description.output_proj' , 'enc_to_dec_proj' )
return name
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(state_dict.keys() )
UpperCAmelCase__ = {}
for key in keys:
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
UpperCAmelCase__ = rename_keys(lowerCamelCase )
if "in_proj_weight" in key:
# split fused qkv proj
UpperCAmelCase__ = val[:hidden_size, :]
UpperCAmelCase__ = val[hidden_size : 2 * hidden_size, :]
UpperCAmelCase__ = val[-hidden_size:, :]
elif "enc_to_dec_proj" in key:
UpperCAmelCase__ = val
else:
UpperCAmelCase__ = val
return state_dict, enc_dec_proj_state_dict
def a_ ( lowerCamelCase ):
if checkpoint == "small":
# default config values
UpperCAmelCase__ = 1_0_2_4
UpperCAmelCase__ = 2_4
UpperCAmelCase__ = 1_6
elif checkpoint == "medium":
UpperCAmelCase__ = 1_5_3_6
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 2_4
elif checkpoint == "large":
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 3_2
else:
raise ValueError(f'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' )
UpperCAmelCase__ = MusicgenDecoderConfig(
hidden_size=lowerCamelCase , ffn_dim=hidden_size * 4 , num_hidden_layers=lowerCamelCase , num_attention_heads=lowerCamelCase , )
return config
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase="cpu" ):
UpperCAmelCase__ = MusicGen.get_pretrained(lowerCamelCase , device=lowerCamelCase )
UpperCAmelCase__ = decoder_config_from_checkpoint(lowerCamelCase )
UpperCAmelCase__ = fairseq_model.lm.state_dict()
UpperCAmelCase__ , UpperCAmelCase__ = rename_state_dict(
lowerCamelCase , hidden_size=decoder_config.hidden_size )
UpperCAmelCase__ = TaEncoderModel.from_pretrained('t5-base' )
UpperCAmelCase__ = EncodecModel.from_pretrained('facebook/encodec_32khz' )
UpperCAmelCase__ = MusicgenForCausalLM(lowerCamelCase ).eval()
# load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
UpperCAmelCase__ , UpperCAmelCase__ = decoder.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
for key in missing_keys.copy():
if key.startswith(('text_encoder', 'audio_encoder') ) or key in EXPECTED_MISSING_KEYS:
missing_keys.remove(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Missing key(s) in state_dict: {missing_keys}''' )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Unexpected key(s) in state_dict: {unexpected_keys}''' )
# init the composite model
UpperCAmelCase__ = MusicgenForConditionalGeneration(text_encoder=lowerCamelCase , audio_encoder=lowerCamelCase , decoder=lowerCamelCase )
# load the pre-trained enc-dec projection (from the decoder state dict)
model.enc_to_dec_proj.load_state_dict(lowerCamelCase )
# check we can do a forward pass
UpperCAmelCase__ = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 )
UpperCAmelCase__ = input_ids.reshape(2 * 4 , -1 )
with torch.no_grad():
UpperCAmelCase__ = model(input_ids=lowerCamelCase , decoder_input_ids=lowerCamelCase ).logits
if logits.shape != (8, 1, 2_0_4_8):
raise ValueError('Incorrect shape for logits' )
# now construct the processor
UpperCAmelCase__ = AutoTokenizer.from_pretrained('t5-base' )
UpperCAmelCase__ = AutoFeatureExtractor.from_pretrained('facebook/encodec_32khz' , padding_side='left' )
UpperCAmelCase__ = MusicgenProcessor(feature_extractor=lowerCamelCase , tokenizer=lowerCamelCase )
# set the appropriate bos/pad token ids
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 2_0_4_8
# set other default generation config params
UpperCAmelCase__ = int(3_0 * audio_encoder.config.frame_rate )
UpperCAmelCase__ = True
UpperCAmelCase__ = 3.0
if pytorch_dump_folder is not None:
Path(lowerCamelCase ).mkdir(exist_ok=lowerCamelCase )
logger.info(f'''Saving model {checkpoint} to {pytorch_dump_folder}''' )
model.save_pretrained(lowerCamelCase )
processor.save_pretrained(lowerCamelCase )
if repo_id:
logger.info(f'''Pushing model {checkpoint} to {repo_id}''' )
model.push_to_hub(lowerCamelCase )
processor.push_to_hub(lowerCamelCase )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--checkpoint',
default='small',
type=str,
help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
)
parser.add_argument(
'--pytorch_dump_folder',
required=True,
default=None,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
)
parser.add_argument(
'--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
)
lowerCAmelCase__ : List[str] = parser.parse_args()
convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
| 632 | 1 |
"""simple docstring"""
# Function to print upper half of diamond (pyramid)
def a_ ( lowerCamelCase ):
for i in range(0 , lowerCamelCase ):
for _ in range(0 , n - i - 1 ): # printing spaces
print(' ' , end='' )
for _ in range(0 , i + 1 ): # printing stars
print('* ' , end='' )
print()
def a_ ( lowerCamelCase ):
for i in range(lowerCamelCase , 0 , -1 ):
for _ in range(lowerCamelCase , 0 , -1 ): # printing stars
print('* ' , end='' )
print()
for _ in range(n - i + 1 , 0 , -1 ): # printing spaces
print(' ' , end='' )
def a_ ( lowerCamelCase ):
if n <= 0:
print(' ... .... nothing printing :(' )
return
floyd(lowerCamelCase ) # upper half
reverse_floyd(lowerCamelCase ) # lower half
if __name__ == "__main__":
print(r'| /\ | |- | |- |--| |\ /| |-')
print(r'|/ \| |- |_ |_ |__| | \/ | |_')
lowerCAmelCase__ : Optional[int] = 1
while K:
lowerCAmelCase__ : Optional[Any] = int(input('enter the number and , and see the magic : '))
print()
pretty_print(user_number)
lowerCAmelCase__ : Optional[int] = int(input('press 0 to exit... and 1 to continue...'))
print('Good Bye...')
| 632 | """simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
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__ : Any = pytest.mark.integration
@pytest.mark.parametrize('path' , ['paws', 'csv'] )
def a_ ( lowerCamelCase , lowerCamelCase ):
inspect_dataset(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = path + '.py'
assert script_name in os.listdir(lowerCamelCase )
assert "__pycache__" not in os.listdir(lowerCamelCase )
@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 a_ ( lowerCamelCase , lowerCamelCase ):
inspect_metric(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = path + '.py'
assert script_name in os.listdir(lowerCamelCase )
assert "__pycache__" not in os.listdir(lowerCamelCase )
@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 a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_dataset_config_info(lowerCamelCase , config_name=lowerCamelCase )
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 a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
with pytest.raises(lowerCamelCase ):
get_dataset_config_info(lowerCamelCase , config_name=lowerCamelCase )
@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 a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_dataset_config_names(lowerCamelCase )
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 a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_dataset_infos(lowerCamelCase )
assert list(infos.keys() ) == expected_configs
UpperCAmelCase__ = expected_configs[0]
assert expected_config in infos
UpperCAmelCase__ = 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 a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = get_dataset_infos(lowerCamelCase )
assert expected_config in infos
UpperCAmelCase__ = 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 a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
with pytest.raises(lowerCamelCase ):
get_dataset_split_names(lowerCamelCase , config_name=lowerCamelCase )
| 632 | """simple docstring"""
import random
class snake_case :
"""simple docstring"""
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : str ):
UpperCAmelCase__ = [ord(lowerCamelCase__ ) for i in text]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i in plain:
UpperCAmelCase__ = random.randint(1 ,300 )
UpperCAmelCase__ = (i + k) * k
cipher.append(lowerCamelCase__ )
key.append(lowerCamelCase__ )
return cipher, key
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = int((cipher[i] - (key[i]) ** 2) / key[i] )
plain.append(chr(lowerCamelCase__ ) )
return "".join(lowerCamelCase__ )
if __name__ == "__main__":
lowerCAmelCase__ , lowerCAmelCase__ : Dict = Onepad().encrypt('Hello')
print(c, k)
print(Onepad().decrypt(c, k))
| 632 | 1 |
"""simple docstring"""
import gc
import random
import tempfile
import unittest
import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
from diffusers import (
AutoencoderKL,
DDIMInverseScheduler,
DDIMScheduler,
DPMSolverMultistepInverseScheduler,
DPMSolverMultistepScheduler,
StableDiffusionDiffEditPipeline,
UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device
from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin
enable_full_determinism()
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = StableDiffusionDiffEditPipeline
snake_case__ = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
snake_case__ = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
snake_case__ = frozenset(
[] ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
snake_case__ = frozenset([] )
def __lowerCAmelCase ( self : Optional[int] ):
torch.manual_seed(0 )
UpperCAmelCase__ = UNetaDConditionModel(
block_out_channels=(32, 64) ,layers_per_block=2 ,sample_size=32 ,in_channels=4 ,out_channels=4 ,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') ,up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') ,cross_attention_dim=32 ,attention_head_dim=(2, 4) ,use_linear_projection=lowerCamelCase__ ,)
UpperCAmelCase__ = DDIMScheduler(
beta_start=0.0_0_0_8_5 ,beta_end=0.0_1_2 ,beta_schedule='scaled_linear' ,clip_sample=lowerCamelCase__ ,set_alpha_to_one=lowerCamelCase__ ,)
UpperCAmelCase__ = DDIMInverseScheduler(
beta_start=0.0_0_0_8_5 ,beta_end=0.0_1_2 ,beta_schedule='scaled_linear' ,clip_sample=lowerCamelCase__ ,set_alpha_to_zero=lowerCamelCase__ ,)
torch.manual_seed(0 )
UpperCAmelCase__ = 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 )
UpperCAmelCase__ = 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=1_000 ,hidden_act='gelu' ,projection_dim=512 ,)
UpperCAmelCase__ = CLIPTextModel(lowerCamelCase__ )
UpperCAmelCase__ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )
UpperCAmelCase__ = {
'unet': unet,
'scheduler': scheduler,
'inverse_scheduler': inverse_scheduler,
'vae': vae,
'text_encoder': text_encoder,
'tokenizer': tokenizer,
'safety_checker': None,
'feature_extractor': None,
}
return components
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : int=0 ):
UpperCAmelCase__ = floats_tensor((1, 16, 16) ,rng=random.Random(lowerCamelCase__ ) ).to(lowerCamelCase__ )
UpperCAmelCase__ = floats_tensor((1, 2, 4, 16, 16) ,rng=random.Random(lowerCamelCase__ ) ).to(lowerCamelCase__ )
if str(lowerCamelCase__ ).startswith('mps' ):
UpperCAmelCase__ = torch.manual_seed(lowerCamelCase__ )
else:
UpperCAmelCase__ = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
UpperCAmelCase__ = {
'prompt': 'a dog and a newt',
'mask_image': mask,
'image_latents': latents,
'generator': generator,
'num_inference_steps': 2,
'inpaint_strength': 1.0,
'guidance_scale': 6.0,
'output_type': 'numpy',
}
return inputs
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Dict ,lowerCamelCase__ : int=0 ):
UpperCAmelCase__ = floats_tensor((1, 3, 32, 32) ,rng=random.Random(lowerCamelCase__ ) ).to(lowerCamelCase__ )
UpperCAmelCase__ = image.cpu().permute(0 ,2 ,3 ,1 )[0]
UpperCAmelCase__ = Image.fromarray(np.uinta(lowerCamelCase__ ) ).convert('RGB' )
if str(lowerCamelCase__ ).startswith('mps' ):
UpperCAmelCase__ = torch.manual_seed(lowerCamelCase__ )
else:
UpperCAmelCase__ = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
UpperCAmelCase__ = {
'image': image,
'source_prompt': 'a cat and a frog',
'target_prompt': 'a dog and a newt',
'generator': generator,
'num_inference_steps': 2,
'num_maps_per_mask': 2,
'mask_encode_strength': 1.0,
'guidance_scale': 6.0,
'output_type': 'numpy',
}
return inputs
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : str=0 ):
UpperCAmelCase__ = floats_tensor((1, 3, 32, 32) ,rng=random.Random(lowerCamelCase__ ) ).to(lowerCamelCase__ )
UpperCAmelCase__ = image.cpu().permute(0 ,2 ,3 ,1 )[0]
UpperCAmelCase__ = Image.fromarray(np.uinta(lowerCamelCase__ ) ).convert('RGB' )
if str(lowerCamelCase__ ).startswith('mps' ):
UpperCAmelCase__ = torch.manual_seed(lowerCamelCase__ )
else:
UpperCAmelCase__ = torch.Generator(device=lowerCamelCase__ ).manual_seed(lowerCamelCase__ )
UpperCAmelCase__ = {
'image': image,
'prompt': 'a cat and a frog',
'generator': generator,
'num_inference_steps': 2,
'inpaint_strength': 1.0,
'guidance_scale': 6.0,
'decode_latents': True,
'output_type': 'numpy',
}
return inputs
def __lowerCAmelCase ( self : Any ):
if not hasattr(self.pipeline_class ,'_optional_components' ):
return
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
# set all optional components to None and update pipeline config accordingly
for optional_component in pipe._optional_components:
setattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components} )
UpperCAmelCase__ = self.get_dummy_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe(**lowerCamelCase__ )[0]
with tempfile.TemporaryDirectory() as tmpdir:
pipe.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = self.pipeline_class.from_pretrained(lowerCamelCase__ )
pipe_loaded.to(lowerCamelCase__ )
pipe_loaded.set_progress_bar_config(disable=lowerCamelCase__ )
for optional_component in pipe._optional_components:
self.assertTrue(
getattr(lowerCamelCase__ ,lowerCamelCase__ ) is None ,f'''`{optional_component}` did not stay set to None after loading.''' ,)
UpperCAmelCase__ = self.get_dummy_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe_loaded(**lowerCamelCase__ )[0]
UpperCAmelCase__ = np.abs(output - output_loaded ).max()
self.assertLess(lowerCamelCase__ ,1e-4 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = 'cpu'
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_mask_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe.generate_mask(**lowerCamelCase__ )
UpperCAmelCase__ = mask[0, -3:, -3:]
self.assertEqual(mask.shape ,(1, 16, 16) )
UpperCAmelCase__ = np.array([0] * 9 )
UpperCAmelCase__ = np.abs(mask_slice.flatten() - expected_slice ).max()
self.assertLessEqual(lowerCamelCase__ ,1e-3 )
self.assertEqual(mask[0, -3, -4] ,0 )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = 'cpu'
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_inversion_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe.invert(**lowerCamelCase__ ).images
UpperCAmelCase__ = image[0, -1, -3:, -3:]
self.assertEqual(image.shape ,(2, 32, 32, 3) )
UpperCAmelCase__ = np.array(
[0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9] ,)
UpperCAmelCase__ = np.abs(image_slice.flatten() - expected_slice ).max()
self.assertLessEqual(lowerCamelCase__ ,1e-3 )
def __lowerCAmelCase ( self : Optional[int] ):
super().test_inference_batch_single_identical(expected_max_diff=5e-3 )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = 'cpu'
UpperCAmelCase__ = self.get_dummy_components()
UpperCAmelCase__ = {'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'beta_schedule': 'scaled_linear'}
UpperCAmelCase__ = DPMSolverMultistepScheduler(**lowerCamelCase__ )
UpperCAmelCase__ = DPMSolverMultistepInverseScheduler(**lowerCamelCase__ )
UpperCAmelCase__ = self.pipeline_class(**lowerCamelCase__ )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = self.get_dummy_inversion_inputs(lowerCamelCase__ )
UpperCAmelCase__ = pipe.invert(**lowerCamelCase__ ).images
UpperCAmelCase__ = image[0, -1, -3:, -3:]
self.assertEqual(image.shape ,(2, 32, 32, 3) )
UpperCAmelCase__ = np.array(
[0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9] ,)
UpperCAmelCase__ = np.abs(image_slice.flatten() - expected_slice ).max()
self.assertLessEqual(lowerCamelCase__ ,1e-3 )
@require_torch_gpu
@slow
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[Any] ):
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
@classmethod
def __lowerCAmelCase ( cls : Dict ):
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png' )
UpperCAmelCase__ = raw_image.convert('RGB' ).resize((768, 768) )
UpperCAmelCase__ = raw_image
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = StableDiffusionDiffEditPipeline.from_pretrained(
'stabilityai/stable-diffusion-2-1' ,safety_checker=lowerCamelCase__ ,torch_dtype=torch.floataa )
UpperCAmelCase__ = DDIMScheduler.from_config(pipe.scheduler.config )
UpperCAmelCase__ = DDIMInverseScheduler.from_config(pipe.scheduler.config )
pipe.enable_model_cpu_offload()
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'a bowl of fruit'
UpperCAmelCase__ = 'a bowl of pears'
UpperCAmelCase__ = pipe.generate_mask(
image=self.raw_image ,source_prompt=lowerCamelCase__ ,target_prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,)
UpperCAmelCase__ = pipe.invert(
prompt=lowerCamelCase__ ,image=self.raw_image ,inpaint_strength=0.7 ,generator=lowerCamelCase__ ).latents
UpperCAmelCase__ = pipe(
prompt=lowerCamelCase__ ,mask_image=lowerCamelCase__ ,image_latents=lowerCamelCase__ ,generator=lowerCamelCase__ ,negative_prompt=lowerCamelCase__ ,inpaint_strength=0.7 ,output_type='numpy' ,).images[0]
UpperCAmelCase__ = (
np.array(
load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
'/diffedit/pears.png' ).resize((768, 768) ) )
/ 255
)
assert np.abs((expected_image - image).max() ) < 5e-1
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = StableDiffusionDiffEditPipeline.from_pretrained(
'stabilityai/stable-diffusion-2-1' ,safety_checker=lowerCamelCase__ ,torch_dtype=torch.floataa )
UpperCAmelCase__ = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
UpperCAmelCase__ = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config )
pipe.enable_model_cpu_offload()
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'a bowl of fruit'
UpperCAmelCase__ = 'a bowl of pears'
UpperCAmelCase__ = pipe.generate_mask(
image=self.raw_image ,source_prompt=lowerCamelCase__ ,target_prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,)
UpperCAmelCase__ = pipe.invert(
prompt=lowerCamelCase__ ,image=self.raw_image ,inpaint_strength=0.7 ,generator=lowerCamelCase__ ,num_inference_steps=25 ,).latents
UpperCAmelCase__ = pipe(
prompt=lowerCamelCase__ ,mask_image=lowerCamelCase__ ,image_latents=lowerCamelCase__ ,generator=lowerCamelCase__ ,negative_prompt=lowerCamelCase__ ,inpaint_strength=0.7 ,num_inference_steps=25 ,output_type='numpy' ,).images[0]
UpperCAmelCase__ = (
np.array(
load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
'/diffedit/pears.png' ).resize((768, 768) ) )
/ 255
)
assert np.abs((expected_image - image).max() ) < 5e-1
| 632 | """simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | 1 |
"""simple docstring"""
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__":
lowerCAmelCase__ : Tuple = '%20'.join(argv[1:]) if len(argv) > 1 else quote(str(input('Search: ')))
print('Googling.....')
lowerCAmelCase__ : Tuple = F"""https://www.google.com/search?q={query}&num=100"""
lowerCAmelCase__ : Union[str, Any] = requests.get(
url,
headers={'User-Agent': str(UserAgent().random)},
)
try:
lowerCAmelCase__ : Dict = (
BeautifulSoup(res.text, 'html.parser')
.find('div', attrs={'class': 'yuRUbf'})
.find('a')
.get('href')
)
except AttributeError:
lowerCAmelCase__ : List[Any] = parse_qs(
BeautifulSoup(res.text, 'html.parser')
.find('div', attrs={'class': 'kCrYT'})
.find('a')
.get('href')
)['url'][0]
webbrowser.open(link)
| 632 | """simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | 1 |
"""simple docstring"""
# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run
import sys
import warnings
from os.path import abspath, dirname, join
# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
lowerCAmelCase__ : List[str] = abspath(join(dirname(dirname(dirname(__file__))), 'src'))
sys.path.insert(1, git_repo_path)
# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)
def a_ ( lowerCamelCase ):
from transformers.testing_utils import pytest_addoption_shared
pytest_addoption_shared(lowerCamelCase )
def a_ ( lowerCamelCase ):
from transformers.testing_utils import pytest_terminal_summary_main
UpperCAmelCase__ = terminalreporter.config.getoption('--make-reports' )
if make_reports:
pytest_terminal_summary_main(lowerCamelCase , id=lowerCamelCase )
| 632 | """simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
if not (isinstance(lowerCamelCase , lowerCamelCase ) and isinstance(lowerCamelCase , lowerCamelCase )):
raise ValueError('longest_common_substring() takes two strings for inputs' )
UpperCAmelCase__ = len(lowerCamelCase )
UpperCAmelCase__ = len(lowerCamelCase )
UpperCAmelCase__ = [[0] * (texta_length + 1) for _ in range(texta_length + 1 )]
UpperCAmelCase__ = 0
UpperCAmelCase__ = 0
for i in range(1 , texta_length + 1 ):
for j in range(1 , texta_length + 1 ):
if texta[i - 1] == texta[j - 1]:
UpperCAmelCase__ = 1 + dp[i - 1][j - 1]
if dp[i][j] > ans_length:
UpperCAmelCase__ = i
UpperCAmelCase__ = dp[i][j]
return texta[ans_index - ans_length : ans_index]
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | """simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import os
from accelerate.utils import ComputeEnvironment
from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401
from .sagemaker import get_sagemaker_input
lowerCAmelCase__ : Dict = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'
def a_ ( ):
UpperCAmelCase__ = _ask_options(
'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , )
if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
UpperCAmelCase__ = get_sagemaker_input()
else:
UpperCAmelCase__ = get_cluster_input()
return config
def a_ ( lowerCamelCase=None ):
if subparsers is not None:
UpperCAmelCase__ = subparsers.add_parser('config' , description=lowerCamelCase )
else:
UpperCAmelCase__ = argparse.ArgumentParser('Accelerate config command' , description=lowerCamelCase )
parser.add_argument(
'--config_file' , default=lowerCamelCase , help=(
'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
'with \'huggingface\'.'
) , )
if subparsers is not None:
parser.set_defaults(func=lowerCamelCase )
return parser
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_user_input()
if args.config_file is not None:
UpperCAmelCase__ = args.config_file
else:
if not os.path.isdir(lowerCamelCase ):
os.makedirs(lowerCamelCase )
UpperCAmelCase__ = default_yaml_config_file
if config_file.endswith('.json' ):
config.to_json_file(lowerCamelCase )
else:
config.to_yaml_file(lowerCamelCase )
print(f'''accelerate configuration saved at {config_file}''' )
def a_ ( ):
UpperCAmelCase__ = config_command_parser()
UpperCAmelCase__ = parser.parse_args()
config_command(lowerCamelCase )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
import logging
from dataclasses import dataclass, field
from typing import Optional
from seqaseq_trainer import arg_to_scheduler
from transformers import TrainingArguments
lowerCAmelCase__ : Dict = logging.getLogger(__name__)
@dataclass
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = field(
default=0.0 , metadata={"help": "The label smoothing epsilon to apply (if not zero)."} )
snake_case__ = field(default=__UpperCAmelCase , metadata={"help": "Whether to SortishSamler or not."} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={"help": "Whether to use generate to calculate generative metrics (ROUGE, BLEU)."} )
snake_case__ = field(default=__UpperCAmelCase , metadata={"help": "whether to use adafactor"} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={"help": "Encoder layer dropout probability. Goes into model.config."} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={"help": "Decoder layer dropout probability. Goes into model.config."} )
snake_case__ = field(default=__UpperCAmelCase , metadata={"help": "Dropout probability. Goes into model.config."} )
snake_case__ = field(
default=__UpperCAmelCase , metadata={"help": "Attention dropout probability. Goes into model.config."} )
snake_case__ = field(
default="linear" , metadata={"help": F'Which lr scheduler to use. Selected in {sorted(arg_to_scheduler.keys() )}'} , )
| 632 | """simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import copy
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "encoder-decoder"
snake_case__ = True
def __init__( self : str ,**lowerCamelCase__ : Any ):
super().__init__(**lowerCamelCase__ )
assert (
"encoder" in kwargs and "decoder" in kwargs
), "Config has to be initialized with encoder and decoder config"
UpperCAmelCase__ = kwargs.pop('encoder' )
UpperCAmelCase__ = encoder_config.pop('model_type' )
UpperCAmelCase__ = kwargs.pop('decoder' )
UpperCAmelCase__ = decoder_config.pop('model_type' )
from ..auto.configuration_auto import AutoConfig
UpperCAmelCase__ = AutoConfig.for_model(lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = AutoConfig.for_model(lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = True
@classmethod
def __lowerCAmelCase ( cls : List[str] ,lowerCamelCase__ : PretrainedConfig ,lowerCamelCase__ : PretrainedConfig ,**lowerCamelCase__ : Dict ):
logger.info('Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' )
UpperCAmelCase__ = True
UpperCAmelCase__ = True
return cls(encoder=encoder_config.to_dict() ,decoder=decoder_config.to_dict() ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = copy.deepcopy(self.__dict__ )
UpperCAmelCase__ = self.encoder.to_dict()
UpperCAmelCase__ = self.decoder.to_dict()
UpperCAmelCase__ = self.__class__.model_type
return output
| 632 | """simple docstring"""
import warnings
from functools import wraps
from typing import Callable
def a_ ( lowerCamelCase ):
@wraps(lowerCamelCase )
def _inner_fn(*lowerCamelCase , **lowerCamelCase ):
warnings.warn(
(f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''') , lowerCamelCase , )
return fn(*lowerCamelCase , **lowerCamelCase )
return _inner_fn
| 632 | 1 |
"""simple docstring"""
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 snake_case :
"""simple docstring"""
def __init__( self : str ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Union[str, Any]=13 ,lowerCamelCase__ : Union[str, Any]=7 ,lowerCamelCase__ : Optional[Any]=True ,lowerCamelCase__ : List[Any]=True ,lowerCamelCase__ : str=True ,lowerCamelCase__ : Optional[int]=True ,lowerCamelCase__ : List[str]=99 ,lowerCamelCase__ : Optional[int]=32 ,lowerCamelCase__ : Dict=2 ,lowerCamelCase__ : Optional[Any]=4 ,lowerCamelCase__ : Optional[Any]=37 ,lowerCamelCase__ : Optional[Any]="gelu" ,lowerCamelCase__ : Optional[int]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : Dict=512 ,lowerCamelCase__ : Optional[int]=16 ,lowerCamelCase__ : Optional[Any]=2 ,lowerCamelCase__ : Optional[int]=0.0_2 ,lowerCamelCase__ : str=False ,lowerCamelCase__ : Any=True ,lowerCamelCase__ : int="None" ,lowerCamelCase__ : Dict=3 ,lowerCamelCase__ : List[Any]=4 ,lowerCamelCase__ : List[str]=None ,):
UpperCAmelCase__ = parent
UpperCAmelCase__ = batch_size
UpperCAmelCase__ = seq_length
UpperCAmelCase__ = is_training
UpperCAmelCase__ = use_input_mask
UpperCAmelCase__ = use_token_type_ids
UpperCAmelCase__ = use_labels
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = hidden_dropout_prob
UpperCAmelCase__ = attention_probs_dropout_prob
UpperCAmelCase__ = max_position_embeddings
UpperCAmelCase__ = type_vocab_size
UpperCAmelCase__ = type_sequence_label_size
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = num_labels
UpperCAmelCase__ = num_choices
UpperCAmelCase__ = relative_attention
UpperCAmelCase__ = position_biased_input
UpperCAmelCase__ = pos_att_type
UpperCAmelCase__ = scope
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size )
UpperCAmelCase__ = None
if self.use_input_mask:
UpperCAmelCase__ = random_attention_mask([self.batch_size, self.seq_length] )
UpperCAmelCase__ = None
if self.use_token_type_ids:
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,self.type_vocab_size )
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
if self.use_labels:
UpperCAmelCase__ = ids_tensor([self.batch_size] ,self.type_sequence_label_size )
UpperCAmelCase__ = ids_tensor([self.batch_size, self.seq_length] ,self.num_labels )
UpperCAmelCase__ = 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=lowerCamelCase__ ,)
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : str ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = TFDebertaVaModel(config=lowerCamelCase__ )
UpperCAmelCase__ = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
UpperCAmelCase__ = [input_ids, input_mask]
UpperCAmelCase__ = model(lowerCamelCase__ )
UpperCAmelCase__ = model(lowerCamelCase__ )
self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) )
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Dict ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = TFDebertaVaForMaskedLM(config=lowerCamelCase__ )
UpperCAmelCase__ = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
UpperCAmelCase__ = model(lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.vocab_size) )
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Union[str, Any] ):
UpperCAmelCase__ = self.num_labels
UpperCAmelCase__ = TFDebertaVaForSequenceClassification(config=lowerCamelCase__ )
UpperCAmelCase__ = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
UpperCAmelCase__ = model(lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels) )
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : str ):
UpperCAmelCase__ = self.num_labels
UpperCAmelCase__ = TFDebertaVaForTokenClassification(config=lowerCamelCase__ )
UpperCAmelCase__ = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
UpperCAmelCase__ = model(lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.seq_length, self.num_labels) )
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : Dict ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Any ,lowerCamelCase__ : Any ):
UpperCAmelCase__ = TFDebertaVaForQuestionAnswering(config=lowerCamelCase__ )
UpperCAmelCase__ = {
'input_ids': input_ids,
'attention_mask': input_mask,
'token_type_ids': token_type_ids,
}
UpperCAmelCase__ = model(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 __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
(
(
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) , (
UpperCAmelCase__
) ,
) = config_and_inputs
UpperCAmelCase__ = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
return config, inputs_dict
@require_tf
class snake_case ( __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 : Dict ):
UpperCAmelCase__ = TFDebertaVaModelTester(self )
UpperCAmelCase__ = ConfigTester(self ,config_class=lowerCamelCase__ ,hidden_size=37 )
def __lowerCAmelCase ( self : Dict ):
self.config_tester.run_common_tests()
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowerCamelCase__ )
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__ )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__ )
@slow
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge' )
self.assertIsNotNone(lowerCamelCase__ )
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@unittest.skip(reason='Model not available yet' )
def __lowerCAmelCase ( self : Any ):
pass
@slow
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge' )
UpperCAmelCase__ = tf.constant([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]] )
UpperCAmelCase__ = tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
UpperCAmelCase__ = model(lowerCamelCase__ ,attention_mask=lowerCamelCase__ )[0]
UpperCAmelCase__ = tf.constant(
[[[0.2_3_5_6, 0.1_9_4_8, 0.0_3_6_9], [-0.1_0_6_3, 0.3_5_8_6, -0.5_1_5_2], [-0.6_3_9_9, -0.0_2_5_9, -0.2_5_2_5]]] )
tf.debugging.assert_near(output[:, 1:4, 1:4] ,lowerCamelCase__ ,atol=1e-4 )
| 632 | """simple docstring"""
from __future__ import annotations
import string
from itertools import cycle, product
from pathlib import Path
lowerCAmelCase__ : str = (
string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__ : list[int] = [ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__ : set[int] = {ord(char) for char in VALID_CHARS}
lowerCAmelCase__ : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"]
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = ""
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
for keychar, cipherchar in zip(cycle(lowerCamelCase ) , lowerCamelCase ):
UpperCAmelCase__ = cipherchar ^ keychar
if decodedchar not in VALID_INTS:
return None
decoded += chr(lowerCamelCase )
return decoded
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
for key in product(lowerCamelCase , repeat=3 ):
UpperCAmelCase__ = try_key(lowerCamelCase , lowerCamelCase )
if encoded is not None:
possibles.append(lowerCamelCase )
return possibles
def a_ ( lowerCamelCase , lowerCamelCase ):
return [possible for possible in possibles if common_word in possible.lower()]
def a_ ( lowerCamelCase = "p059_cipher.txt" ):
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )
UpperCAmelCase__ = [int(lowerCamelCase ) for number in data.strip().split(',' )]
UpperCAmelCase__ = filter_valid_chars(lowerCamelCase )
for common_word in COMMON_WORDS:
UpperCAmelCase__ = filter_common_word(lowerCamelCase , lowerCamelCase )
if len(lowerCamelCase ) == 1:
break
UpperCAmelCase__ = possibles[0]
return sum(ord(lowerCamelCase ) for char in decoded_text )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
from __future__ import absolute_import, division, print_function, unicode_literals
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss
from transformers import RobertaConfig
from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
from transformers.models.roberta.modeling_roberta import (
ROBERTA_INPUTS_DOCSTRING,
ROBERTA_START_DOCSTRING,
RobertaEmbeddings,
)
from .modeling_highway_bert import BertPreTrainedModel, DeeBertModel, HighwayException, entropy
@add_start_docstrings(
"The RoBERTa Model transformer with early exiting (DeeRoBERTa). " , __UpperCAmelCase , )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = RobertaConfig
snake_case__ = "roberta"
def __init__( self : List[str] ,lowerCamelCase__ : Dict ):
super().__init__(lowerCamelCase__ )
UpperCAmelCase__ = RobertaEmbeddings(lowerCamelCase__ )
self.init_weights()
@add_start_docstrings(
"RoBERTa Model (with early exiting - DeeRoBERTa) with a classifier on top,\n also takes care of multi-layer training. " , __UpperCAmelCase , )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = RobertaConfig
snake_case__ = "roberta"
def __init__( self : Union[str, Any] ,lowerCamelCase__ : Optional[int] ):
super().__init__(lowerCamelCase__ )
UpperCAmelCase__ = config.num_labels
UpperCAmelCase__ = config.num_hidden_layers
UpperCAmelCase__ = DeeRobertaModel(lowerCamelCase__ )
UpperCAmelCase__ = nn.Dropout(config.hidden_dropout_prob )
UpperCAmelCase__ = nn.Linear(config.hidden_size ,self.config.num_labels )
@add_start_docstrings_to_model_forward(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : Union[str, Any]=None ,lowerCamelCase__ : List[str]=None ,lowerCamelCase__ : str=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Optional[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int=-1 ,lowerCamelCase__ : Any=False ,):
UpperCAmelCase__ = self.num_layers
try:
UpperCAmelCase__ = self.roberta(
lowerCamelCase__ ,attention_mask=lowerCamelCase__ ,token_type_ids=lowerCamelCase__ ,position_ids=lowerCamelCase__ ,head_mask=lowerCamelCase__ ,inputs_embeds=lowerCamelCase__ ,)
UpperCAmelCase__ = outputs[1]
UpperCAmelCase__ = self.dropout(lowerCamelCase__ )
UpperCAmelCase__ = self.classifier(lowerCamelCase__ )
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(lowerCamelCase__ )
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(lowerCamelCase__ )
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(lowerCamelCase__ )
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), entropy
| 632 | """simple docstring"""
import unittest
from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : Any = get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = XLMProphetNetTokenizer
snake_case__ = False
snake_case__ = True
def __lowerCAmelCase ( self : Any ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = '[PAD]'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'[PAD]' )
self.assertEqual(vocab_keys[1] ,'[CLS]' )
self.assertEqual(vocab_keys[-1] ,'j' )
self.assertEqual(len(lowerCamelCase__ ) ,1_012 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,1_012 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowerCamelCase__ ,['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,)
UpperCAmelCase__ = 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',
'é',
'.',
] ,)
UpperCAmelCase__ = tokenizer.convert_tokens_to_ids(lowerCamelCase__ )
self.assertListEqual(
lowerCamelCase__ ,[
value + tokenizer.fairseq_offset
for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
] ,)
UpperCAmelCase__ = 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 __lowerCAmelCase ( self : Dict ):
return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )
@slow
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello World!'
UpperCAmelCase__ = [35_389, 6_672, 49, 2]
self.assertListEqual(lowerCamelCase__ ,self.big_tokenizer.encode(lowerCamelCase__ ) )
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/xprophetnet-large-wiki100-cased' ,revision='1acad1643ddd54a44df6a1b797ada8373685d90e' ,)
| 632 | 1 |
"""simple docstring"""
from manim import *
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = Rectangle(height=0.5 ,width=0.5 )
UpperCAmelCase__ = Rectangle(height=0.2_5 ,width=0.2_5 )
UpperCAmelCase__ = Rectangle(height=0.4_6 ,width=0.4_6 ).set_stroke(width=0 )
UpperCAmelCase__ = [mem.copy() for i in range(6 )]
UpperCAmelCase__ = [mem.copy() for i in range(6 )]
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = VGroup(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = Text('CPU' ,font_size=24 )
UpperCAmelCase__ = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ )
cpu.move_to([-2.5, -0.5, 0] )
self.add(lowerCamelCase__ )
UpperCAmelCase__ = [mem.copy() for i in range(4 )]
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = Text('GPU' ,font_size=24 )
UpperCAmelCase__ = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ )
gpu.move_to([-1, -1, 0] )
self.add(lowerCamelCase__ )
UpperCAmelCase__ = [mem.copy() for i in range(6 )]
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = Text('Model' ,font_size=24 )
UpperCAmelCase__ = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ )
model.move_to([3, -1.0, 0] )
self.add(lowerCamelCase__ )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i, rect in enumerate(lowerCamelCase__ ):
rect.set_stroke(lowerCamelCase__ )
UpperCAmelCase__ = Rectangle(height=0.4_6 / 4 ,width=0.4_6 / 3 ).set_stroke(width=0.0 ).set_fill(lowerCamelCase__ ,opacity=0.7 )
if i == 0:
cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT ) ,buff=0.0_2 ,direction=lowerCamelCase__ )
cpu_target.set_x(cpu_target.get_x() + 0.1 )
elif i == 3:
cpu_target.next_to(model_cpu_arr[0] ,direction=lowerCamelCase__ ,buff=0.0 )
else:
cpu_target.next_to(model_cpu_arr[i - 1] ,direction=lowerCamelCase__ ,buff=0.0 )
self.add(lowerCamelCase__ )
model_cpu_arr.append(lowerCamelCase__ )
self.add(*lowerCamelCase__ ,*lowerCamelCase__ ,*lowerCamelCase__ )
UpperCAmelCase__ = [mem.copy() for i in range(6 )]
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = Text('Loaded Checkpoint' ,font_size=24 )
UpperCAmelCase__ = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ )
checkpoint.move_to([3, 0.5, 0] )
self.add(lowerCamelCase__ )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i, rect in enumerate(lowerCamelCase__ ):
UpperCAmelCase__ = fill.copy().set_fill(lowerCamelCase__ ,opacity=0.7 )
target.move_to(lowerCamelCase__ )
ckpt_arr.append(lowerCamelCase__ )
UpperCAmelCase__ = target.copy()
if i < 5:
cpu_target.move_to(cpu_left_col_base[i + 1] )
else:
cpu_target.move_to(cpu_right_col_base[i - 5] )
ckpt_cpu_arr.append(lowerCamelCase__ )
self.add(*lowerCamelCase__ ,*lowerCamelCase__ )
UpperCAmelCase__ = Square(side_length=2.2 )
key.move_to([-5, 2, 0] )
UpperCAmelCase__ = MarkupText(
f'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model''' ,font_size=18 ,)
key_text.move_to([-5, 2.4, 0] )
self.add(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = MarkupText(
f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint''' ,font_size=18 ,)
blue_text.next_to(lowerCamelCase__ ,DOWN * 2.4 ,aligned_edge=key_text.get_left() )
self.add(lowerCamelCase__ )
UpperCAmelCase__ = MarkupText(
f'''Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.''' ,font_size=24 ,)
step_a.move_to([2, 2, 0] )
UpperCAmelCase__ = [meta_mem.copy() for i in range(6 )]
UpperCAmelCase__ = [meta_mem.copy() for i in range(6 )]
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = VGroup(*lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = VGroup(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0 )
UpperCAmelCase__ = Text('Disk' ,font_size=24 )
UpperCAmelCase__ = Group(lowerCamelCase__ ,lowerCamelCase__ ).arrange(lowerCamelCase__ ,buff=0.5 ,aligned_edge=lowerCamelCase__ )
disk.move_to([-4.0, -1.2_5, 0] )
self.play(Write(lowerCamelCase__ ,run_time=3 ) ,Write(lowerCamelCase__ ,run_time=1 ) ,Create(lowerCamelCase__ ,run_time=1 ) )
UpperCAmelCase__ = []
for i, rect in enumerate(lowerCamelCase__ ):
UpperCAmelCase__ = rect.copy()
target.generate_target()
target.target.move_to(disk_left_col_base[i] ).scale(0.5 )
animations.append(MoveToTarget(lowerCamelCase__ ,run_time=1.5 ) )
self.play(*lowerCamelCase__ )
self.play(FadeOut(lowerCamelCase__ ) )
UpperCAmelCase__ = MarkupText(f'''Then, the checkpoint is removed from memory\nthrough garbage collection.''' ,font_size=24 )
step_a.move_to([2, 2, 0] )
self.play(Write(lowerCamelCase__ ,run_time=3 ) )
self.play(
FadeOut(lowerCamelCase__ ,lowerCamelCase__ ,*lowerCamelCase__ ,*lowerCamelCase__ ) ,)
self.wait()
| 632 | """simple docstring"""
from __future__ import annotations
import collections
import pprint
from pathlib import Path
def a_ ( lowerCamelCase ):
return "".join(sorted(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
return word_by_signature[signature(lowerCamelCase )]
lowerCAmelCase__ : str = Path(__file__).parent.joinpath('words.txt').read_text(encoding='utf-8')
lowerCAmelCase__ : str = sorted({word.strip().lower() for word in data.splitlines()})
lowerCAmelCase__ : Optional[Any] = collections.defaultdict(list)
for word in word_list:
word_by_signature[signature(word)].append(word)
if __name__ == "__main__":
lowerCAmelCase__ : int = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
with open('anagrams.txt', 'w') as file:
file.write('all_anagrams = \n ')
file.write(pprint.pformat(all_anagrams))
| 632 | 1 |
"""simple docstring"""
# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py
import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = multiprocessing.Manager()
UpperCAmelCase__ = manager.list()
UpperCAmelCase__ = multiprocessing.Process(target=lowerCamelCase , args=(check_program, result, timeout) )
p.start()
p.join(timeout=timeout + 1 )
if p.is_alive():
p.kill()
if not result:
result.append('timed out' )
return {
"task_id": task_id,
"passed": result[0] == "passed",
"result": result[0],
"completion_id": completion_id,
}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
with create_tempdir():
# These system calls are needed when cleaning up tempdir.
import os
import shutil
UpperCAmelCase__ = shutil.rmtree
UpperCAmelCase__ = os.rmdir
UpperCAmelCase__ = os.chdir
# Disable functionalities that can make destructive changes to the test.
reliability_guard()
# Run program.
try:
UpperCAmelCase__ = {}
with swallow_io():
with time_limit(lowerCamelCase ):
exec(lowerCamelCase , lowerCamelCase )
result.append('passed' )
except TimeoutException:
result.append('timed out' )
except BaseException as e:
result.append(f'''failed: {e}''' )
# Needed for cleaning up.
UpperCAmelCase__ = rmtree
UpperCAmelCase__ = rmdir
UpperCAmelCase__ = chdir
@contextlib.contextmanager
def a_ ( lowerCamelCase ):
def signal_handler(lowerCamelCase , lowerCamelCase ):
raise TimeoutException('Timed out!' )
signal.setitimer(signal.ITIMER_REAL , lowerCamelCase )
signal.signal(signal.SIGALRM , lowerCamelCase )
try:
yield
finally:
signal.setitimer(signal.ITIMER_REAL , 0 )
@contextlib.contextmanager
def a_ ( ):
UpperCAmelCase__ = WriteOnlyStringIO()
with contextlib.redirect_stdout(lowerCamelCase ):
with contextlib.redirect_stderr(lowerCamelCase ):
with redirect_stdin(lowerCamelCase ):
yield
@contextlib.contextmanager
def a_ ( ):
with tempfile.TemporaryDirectory() as dirname:
with chdir(lowerCamelCase ):
yield dirname
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
pass
class snake_case ( io.StringIO ):
"""simple docstring"""
def __lowerCAmelCase ( self : Union[str, Any] ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Optional[int] ):
raise OSError
def __lowerCAmelCase ( self : Any ,*lowerCamelCase__ : Optional[int] ,**lowerCamelCase__ : Any ):
raise OSError
def __lowerCAmelCase ( self : Dict ,*lowerCamelCase__ : Optional[Any] ,**lowerCamelCase__ : List[Any] ):
raise OSError
def __lowerCAmelCase ( self : List[Any] ,*lowerCamelCase__ : Tuple ,**lowerCamelCase__ : List[str] ):
return False
class snake_case ( contextlib._RedirectStream ): # type: ignore
"""simple docstring"""
snake_case__ = "stdin"
@contextlib.contextmanager
def a_ ( lowerCamelCase ):
if root == ".":
yield
return
UpperCAmelCase__ = os.getcwd()
os.chdir(lowerCamelCase )
try:
yield
except BaseException as exc:
raise exc
finally:
os.chdir(lowerCamelCase )
def a_ ( lowerCamelCase=None ):
if maximum_memory_bytes is not None:
import resource
resource.setrlimit(resource.RLIMIT_AS , (maximum_memory_bytes, maximum_memory_bytes) )
resource.setrlimit(resource.RLIMIT_DATA , (maximum_memory_bytes, maximum_memory_bytes) )
if not platform.uname().system == "Darwin":
resource.setrlimit(resource.RLIMIT_STACK , (maximum_memory_bytes, maximum_memory_bytes) )
faulthandler.disable()
import builtins
UpperCAmelCase__ = None
UpperCAmelCase__ = None
import os
UpperCAmelCase__ = '1'
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
import shutil
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
import subprocess
UpperCAmelCase__ = None # type: ignore
UpperCAmelCase__ = None
import sys
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = None
| 632 | """simple docstring"""
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class snake_case ( ctypes.Structure ):
"""simple docstring"""
snake_case__ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25l' )
sys.stdout.flush()
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25h' )
sys.stdout.flush()
@contextmanager
def a_ ( ):
try:
hide_cursor()
yield
finally:
show_cursor()
| 632 | 1 |
"""simple docstring"""
import math
import os
import re
import sys
import unittest
from pathlib import Path
from typing import Tuple
from unittest.mock import patch
from parameterized import parameterized
from transformers.testing_utils import (
CaptureStderr,
ExtendSysPath,
TestCasePlus,
execute_subprocess_async,
get_gpu_count,
get_torch_dist_unique_port,
require_apex,
require_bitsandbytes,
require_fairscale,
require_torch,
require_torch_gpu,
require_torch_multi_gpu,
require_torch_non_multi_gpu,
slow,
)
from transformers.trainer_callback import TrainerState
from transformers.trainer_utils import set_seed
lowerCAmelCase__ : Tuple = os.path.abspath(os.path.dirname(__file__))
with ExtendSysPath(F"""{bindir}/../../examples/pytorch/translation"""):
from run_translation import main # noqa
set_seed(42)
lowerCAmelCase__ : List[str] = 'sshleifer/student_marian_en_ro_6_1'
lowerCAmelCase__ : Optional[int] = 'sshleifer/tiny-mbart'
@require_torch
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : Tuple=False ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Union[str, Any]=True ,lowerCamelCase__ : Optional[int]=True ,lowerCamelCase__ : Any=True ,lowerCamelCase__ : int=True ,):
UpperCAmelCase__ = self.run_trainer(
eval_steps=1 ,max_len=12 ,model_name=lowerCamelCase__ ,num_train_epochs=1 ,distributed=lowerCamelCase__ ,extra_args_str=lowerCamelCase__ ,predict_with_generate=lowerCamelCase__ ,do_train=lowerCamelCase__ ,do_eval=lowerCamelCase__ ,do_predict=lowerCamelCase__ ,)
UpperCAmelCase__ = TrainerState.load_from_json(os.path.join(lowerCamelCase__ ,'trainer_state.json' ) ).log_history
if not do_eval:
return
UpperCAmelCase__ = [log for log in logs if 'eval_loss' in log.keys()]
UpperCAmelCase__ = eval_metrics[0]
if predict_with_generate:
assert "eval_bleu" in first_step_stats
UpperCAmelCase__ = eval_metrics[-1]
assert isinstance(last_step_stats['eval_bleu'] ,lowerCamelCase__ )
assert not math.isnan(float(last_step_stats['eval_loss'] ) ), "eval_loss must not be `nan`"
@require_torch_non_multi_gpu
def __lowerCAmelCase ( self : Any ):
self.run_seqaseq_quick()
@require_torch_multi_gpu
def __lowerCAmelCase ( self : Tuple ):
self.run_seqaseq_quick(distributed=lowerCamelCase__ )
@require_torch_multi_gpu
def __lowerCAmelCase ( self : int ):
self.run_seqaseq_quick(distributed=lowerCamelCase__ )
@unittest.skip('Requires an update of the env running those tests' )
@require_torch_multi_gpu
@require_fairscale
def __lowerCAmelCase ( self : Union[str, Any] ):
self.run_seqaseq_quick(distributed=lowerCamelCase__ ,extra_args_str='--sharded_ddp simple' )
@unittest.skip('Requires an update of the env running those tests' )
@require_torch_multi_gpu
@require_fairscale
def __lowerCAmelCase ( self : Optional[int] ):
self.run_seqaseq_quick(distributed=lowerCamelCase__ ,extra_args_str='--sharded_ddp simple --fp16' )
@unittest.skip('Requires an update of the env running those tests' )
@require_torch_multi_gpu
@require_fairscale
def __lowerCAmelCase ( self : Tuple ):
self.run_seqaseq_quick(distributed=lowerCamelCase__ ,extra_args_str='--sharded_ddp zero_dp_2' ,predict_with_generate=lowerCamelCase__ )
@unittest.skip('Requires an update of the env running those tests' )
@require_torch_multi_gpu
@require_fairscale
def __lowerCAmelCase ( self : Dict ):
self.run_seqaseq_quick(
distributed=lowerCamelCase__ ,extra_args_str='--sharded_ddp zero_dp_2 --fp16' ,predict_with_generate=lowerCamelCase__ )
@require_apex
@require_torch_gpu
def __lowerCAmelCase ( self : int ):
# XXX: apex breaks the trainer if it's run twice e.g. run_seq2seq.main() from the same
# program and it breaks other tests that run from the same pytest worker, therefore until this is
# sorted out it must be run only in an external program, that is distributed=True in this
# test and only under one or more gpus - if we want cpu will need to make a special test
#
# specifically to the problem traced it to self.optimizer.step() - if it's run 2nd time via
# 2nd main() call it botches the future eval.
#
self.run_seqaseq_quick(distributed=lowerCamelCase__ ,extra_args_str='--fp16 --fp16_backend=apex' )
# test 2nd time - was getting eval_loss': nan'
# to reproduce the problem set distributed=False
self.run_seqaseq_quick(distributed=lowerCamelCase__ ,extra_args_str='--fp16 --fp16_backend=apex' )
@parameterized.expand(['base', 'low', 'high', 'mixed'] )
@require_torch_multi_gpu
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : Any ):
# as each sub-test is slow-ish split into multiple sub-tests to avoid CI timeout
UpperCAmelCase__ = {
# test with the default log_level - should be info and thus log info once
'base': {'extra_args_str': '', 'n_matches': 1},
# test with low log_level and log_level_replica - should be noisy on all processes
# now the info string should appear twice on 2 processes
'low': {'extra_args_str': '--log_level debug --log_level_replica debug', 'n_matches': 2},
# test with high log_level and low log_level_replica
# now the info string should appear once only on the replica
'high': {'extra_args_str': '--log_level error --log_level_replica debug', 'n_matches': 1},
# test with high log_level and log_level_replica - should be quiet on all processes
'mixed': {'extra_args_str': '--log_level error --log_level_replica error', 'n_matches': 0},
}
UpperCAmelCase__ = experiments[experiment_id]
UpperCAmelCase__ = {'distributed': True, 'predict_with_generate': False, 'do_eval': False, 'do_predict': False}
UpperCAmelCase__ = 'Running training'
with CaptureStderr() as cl:
self.run_seqaseq_quick(**lowerCamelCase__ ,extra_args_str=data['extra_args_str'] )
UpperCAmelCase__ = len(re.findall(lowerCamelCase__ ,cl.err ) )
self.assertEqual(lowerCamelCase__ ,data['n_matches'] )
@slow
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.run_trainer(
eval_steps=2 ,max_len=128 ,model_name=lowerCamelCase__ ,learning_rate=3e-4 ,num_train_epochs=10 ,distributed=lowerCamelCase__ ,)
# Check metrics
UpperCAmelCase__ = TrainerState.load_from_json(os.path.join(lowerCamelCase__ ,'trainer_state.json' ) ).log_history
UpperCAmelCase__ = [log for log in logs if 'eval_loss' in log.keys()]
UpperCAmelCase__ = eval_metrics[0]
UpperCAmelCase__ = eval_metrics[-1]
assert first_step_stats["eval_loss"] > last_step_stats["eval_loss"], "model learned nothing"
assert isinstance(last_step_stats['eval_bleu'] ,lowerCamelCase__ )
# test if do_predict saves generations and metrics
UpperCAmelCase__ = os.listdir(lowerCamelCase__ )
UpperCAmelCase__ = {os.path.basename(lowerCamelCase__ ) for p in contents}
assert "generated_predictions.txt" in contents
assert "predict_results.json" in contents
@slow
@require_bitsandbytes
def __lowerCAmelCase ( self : Tuple ):
from transformers.training_args import OptimizerNames
def train_and_return_metrics(lowerCamelCase__ : str ) -> Tuple[int, float]:
UpperCAmelCase__ = '--skip_memory_metrics 0'
UpperCAmelCase__ = self.run_trainer(
max_len=128 ,model_name=lowerCamelCase__ ,learning_rate=3e-4 ,num_train_epochs=1 ,optim=lowerCamelCase__ ,distributed=lowerCamelCase__ ,extra_args_str=lowerCamelCase__ ,do_eval=lowerCamelCase__ ,do_predict=lowerCamelCase__ ,n_gpus_to_use=1 ,)
# Check metrics
UpperCAmelCase__ = TrainerState.load_from_json(Path(lowerCamelCase__ ,'trainer_state.json' ) ).log_history
UpperCAmelCase__ = int(logs[0]['train_mem_gpu_peaked_delta'] / 2**20 )
UpperCAmelCase__ = int(logs[0]['train_mem_gpu_alloc_delta'] / 2**20 )
UpperCAmelCase__ = logs[0]['train_loss']
return gpu_peak_mem_mb, gpu_alloc_mem_mb, loss
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = train_and_return_metrics(OptimizerNames.ADAMW_TORCH.value )
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = train_and_return_metrics(OptimizerNames.ADAMW_BNB.value )
UpperCAmelCase__ = gpu_alloc_mem_orig - gpu_alloc_mem_bnb
UpperCAmelCase__ = gpu_peak_mem_orig + gpu_alloc_mem_orig
UpperCAmelCase__ = gpu_peak_mem_bnb + gpu_alloc_mem_bnb
UpperCAmelCase__ = gpu_total_mem_orig - gpu_total_mem_bnb
# sshleifer/student_marian_en_ro_6_1 has 54M parameter, 29M of which is `nn.Embedding` which
# doesn't get quantized and remains in fp32. Therefore we only have 25M parameters quantized
# in 2 bytes and the diff in optim memory usage is derived as so:
#
# - normal 25*8=~200MB (8 bytes per param)
# - bnb 25*2= ~50MB (2 bytes per param)
#
# Thus we should expect ~150MB total memory saved.
#
# Peak memory should be the same - the total should be different by about that same margin
#
# After leaving a small margin to accommodate for differences between gpus let's check
# that we have at least 120MB in savings
UpperCAmelCase__ = 120
# uncomment the following if this test starts failing - requires py38 for a new print feature
# gpu_peak_mem_diff = gpu_peak_mem_orig - gpu_peak_mem_bnb
# print(f"{gpu_alloc_mem_orig=}MB {gpu_peak_mem_orig=}MB {gpu_alloc_mem_orig+gpu_peak_mem_orig=}MB")
# print(f" {gpu_alloc_mem_bnb=}MB {gpu_peak_mem_bnb=}MB {gpu_alloc_mem_bnb+gpu_peak_mem_bnb=}MB")
# print(f"{gpu_alloc_mem_diff=}MB")
# print(f"{gpu_peak_mem_diff=}MB")
# print(f"{gpu_total_mem_orig=}MB, {gpu_total_mem_bnb=}MB")
# print(f"{gpu_total_mem_diff=}MB, {gpu_total_mem_diff=}MB")
self.assertGreater(
lowerCamelCase__ ,lowerCamelCase__ ,'should use ~150MB less alloc gpu memory with BNB, compared to without it for this model but got'
f''' a difference of {gpu_alloc_mem_diff}MB, with gpu_alloc_mem_orig={gpu_alloc_mem_orig}MB and'''
f''' gpu_alloc_mem_bnb={gpu_alloc_mem_bnb}MB''' ,)
self.assertGreater(
lowerCamelCase__ ,lowerCamelCase__ ,'should use ~150MB less total gpu memory with BNB, compared to without it for this model but got'
f''' a difference of {gpu_total_mem_diff}MB, with gpu_total_mem_orig={gpu_total_mem_orig}MB and'''
f''' gpu_total_mem_bnb={gpu_total_mem_bnb}MB''' ,)
self.assertEqual(
lowerCamelCase__ ,lowerCamelCase__ ,f'''loss should be the same, but got loss_orig={loss_orig}, loss_bnb={loss_bnb}''' )
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : int ,lowerCamelCase__ : str ,lowerCamelCase__ : int ,lowerCamelCase__ : float = 3e-3 ,lowerCamelCase__ : str = "adafactor" ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : str = None ,lowerCamelCase__ : int = 0 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : int = None ,):
UpperCAmelCase__ = self.test_file_dir / '../fixtures/tests_samples/wmt_en_ro'
UpperCAmelCase__ = self.get_auto_remove_tmp_dir()
UpperCAmelCase__ = f'''
--model_name_or_path {model_name}
--train_file {data_dir}/train.json
--validation_file {data_dir}/val.json
--test_file {data_dir}/test.json
--output_dir {output_dir}
--overwrite_output_dir
--max_train_samples 8
--max_source_length {max_len}
--max_target_length {max_len}
--do_train
--num_train_epochs {str(lowerCamelCase__ )}
--per_device_train_batch_size 4
--learning_rate {learning_rate}
--warmup_steps 8
--logging_steps 0
--logging_strategy no
--save_steps {str(lowerCamelCase__ )}
--group_by_length
--label_smoothing_factor 0.1
--target_lang ro_RO
--source_lang en_XX
'''.split()
UpperCAmelCase__ = f'''
--do_eval
--per_device_eval_batch_size 4
--max_eval_samples 8
--val_max_target_length {max_len}
--evaluation_strategy steps
--eval_steps {str(lowerCamelCase__ )}
'''.split()
UpperCAmelCase__ = '\n --do_predict\n '.split()
UpperCAmelCase__ = []
if do_train:
args += args_train
if do_eval:
args += args_eval
if do_predict:
args += args_predict
if predict_with_generate:
args += "--predict_with_generate".split()
if do_train:
if optim == "adafactor":
args += "--adafactor".split()
else:
args += f'''--optim {optim}'''.split()
if extra_args_str is not None:
args += extra_args_str.split()
if distributed:
if n_gpus_to_use is None:
UpperCAmelCase__ = get_gpu_count()
UpperCAmelCase__ = get_torch_dist_unique_port()
UpperCAmelCase__ = f'''
-m torch.distributed.run
--nproc_per_node={n_gpus_to_use}
--master_port={master_port}
{self.examples_dir_str}/pytorch/translation/run_translation.py
'''.split()
UpperCAmelCase__ = [sys.executable] + distributed_args + args
# keep for quick debug
# print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
execute_subprocess_async(lowerCamelCase__ ,env=self.get_env() )
else:
UpperCAmelCase__ = ['run_translation.py'] + args
with patch.object(lowerCamelCase__ ,'argv' ,lowerCamelCase__ ):
main()
return output_dir
| 632 | """simple docstring"""
import inspect
import tempfile
from collections import OrderedDict, UserDict
from collections.abc import MutableMapping
from contextlib import ExitStack, contextmanager
from dataclasses import fields
from enum import Enum
from typing import Any, ContextManager, List, Tuple
import numpy as np
from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy
if is_flax_available():
import jax.numpy as jnp
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __get__( self : Dict ,lowerCamelCase__ : str ,lowerCamelCase__ : str=None ):
# See docs.python.org/3/howto/descriptor.html#properties
if obj is None:
return self
if self.fget is None:
raise AttributeError('unreadable attribute' )
UpperCAmelCase__ = '__cached_' + self.fget.__name__
UpperCAmelCase__ = getattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
if cached is None:
UpperCAmelCase__ = self.fget(lowerCamelCase__ )
setattr(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
return cached
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = val.lower()
if val in {"y", "yes", "t", "true", "on", "1"}:
return 1
if val in {"n", "no", "f", "false", "off", "0"}:
return 0
raise ValueError(f'''invalid truth value {val!r}''' )
def a_ ( lowerCamelCase ):
if is_torch_fx_proxy(lowerCamelCase ):
return True
if is_torch_available():
import torch
if isinstance(lowerCamelCase , torch.Tensor ):
return True
if is_tf_available():
import tensorflow as tf
if isinstance(lowerCamelCase , tf.Tensor ):
return True
if is_flax_available():
import jax.numpy as jnp
from jax.core import Tracer
if isinstance(lowerCamelCase , (jnp.ndarray, Tracer) ):
return True
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return isinstance(lowerCamelCase , np.ndarray )
def a_ ( lowerCamelCase ):
return _is_numpy(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
return isinstance(lowerCamelCase , torch.device )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_device(lowerCamelCase )
def a_ ( lowerCamelCase ):
import torch
if isinstance(lowerCamelCase , lowerCamelCase ):
if hasattr(lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = getattr(lowerCamelCase , lowerCamelCase )
else:
return False
return isinstance(lowerCamelCase , torch.dtype )
def a_ ( lowerCamelCase ):
return False if not is_torch_available() else _is_torch_dtype(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
return isinstance(lowerCamelCase , tf.Tensor )
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tensorflow(lowerCamelCase )
def a_ ( lowerCamelCase ):
import tensorflow as tf
# the `is_symbolic_tensor` predicate is only available starting with TF 2.14
if hasattr(lowerCamelCase , 'is_symbolic_tensor' ):
return tf.is_symbolic_tensor(lowerCamelCase )
return type(lowerCamelCase ) == tf.Tensor
def a_ ( lowerCamelCase ):
return False if not is_tf_available() else _is_tf_symbolic_tensor(lowerCamelCase )
def a_ ( lowerCamelCase ):
import jax.numpy as jnp # noqa: F811
return isinstance(lowerCamelCase , jnp.ndarray )
def a_ ( lowerCamelCase ):
return False if not is_flax_available() else _is_jax(lowerCamelCase )
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_py_obj(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return [to_py_obj(lowerCamelCase ) for o in obj]
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy().tolist()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().tolist()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase ).tolist()
elif isinstance(lowerCamelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays
return obj.tolist()
else:
return obj
def a_ ( lowerCamelCase ):
if isinstance(lowerCamelCase , (dict, UserDict) ):
return {k: to_numpy(lowerCamelCase ) for k, v in obj.items()}
elif isinstance(lowerCamelCase , (list, tuple) ):
return np.array(lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
return obj.numpy()
elif is_torch_tensor(lowerCamelCase ):
return obj.detach().cpu().numpy()
elif is_jax_tensor(lowerCamelCase ):
return np.asarray(lowerCamelCase )
else:
return obj
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = fields(self )
# Safety and consistency checks
if not len(lowerCamelCase__ ):
raise ValueError(f'''{self.__class__.__name__} has no fields.''' )
if not all(field.default is None for field in class_fields[1:] ):
raise ValueError(f'''{self.__class__.__name__} should not have more than one required field.''' )
UpperCAmelCase__ = getattr(self ,class_fields[0].name )
UpperCAmelCase__ = all(getattr(self ,field.name ) is None for field in class_fields[1:] )
if other_fields_are_none and not is_tensor(lowerCamelCase__ ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = first_field.items()
UpperCAmelCase__ = True
else:
try:
UpperCAmelCase__ = iter(lowerCamelCase__ )
UpperCAmelCase__ = True
except TypeError:
UpperCAmelCase__ = False
# if we provided an iterator as first field and the iterator is a (key, value) iterator
# set the associated fields
if first_field_iterator:
for idx, element in enumerate(lowerCamelCase__ ):
if (
not isinstance(lowerCamelCase__ ,(list, tuple) )
or not len(lowerCamelCase__ ) == 2
or not isinstance(element[0] ,lowerCamelCase__ )
):
if idx == 0:
# If we do not have an iterator of key/values, set it as attribute
UpperCAmelCase__ = first_field
else:
# If we have a mixed iterator, raise an error
raise ValueError(
f'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' )
break
setattr(self ,element[0] ,element[1] )
if element[1] is not None:
UpperCAmelCase__ = element[1]
elif first_field is not None:
UpperCAmelCase__ = first_field
else:
for field in class_fields:
UpperCAmelCase__ = getattr(self ,field.name )
if v is not None:
UpperCAmelCase__ = v
def __delitem__( self : List[Any] ,*lowerCamelCase__ : Any ,**lowerCamelCase__ : Dict ):
raise Exception(f'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : str ,*lowerCamelCase__ : int ,**lowerCamelCase__ : Optional[Any] ):
raise Exception(f'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : List[Any] ,*lowerCamelCase__ : int ,**lowerCamelCase__ : List[Any] ):
raise Exception(f'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' )
def __lowerCAmelCase ( self : Optional[int] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Optional[int] ):
raise Exception(f'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' )
def __getitem__( self : Tuple ,lowerCamelCase__ : List[Any] ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = dict(self.items() )
return inner_dict[k]
else:
return self.to_tuple()[k]
def __setattr__( self : int ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if name in self.keys() and value is not None:
# Don't call self.__setitem__ to avoid recursion errors
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __setitem__( self : Dict ,lowerCamelCase__ : int ,lowerCamelCase__ : Any ):
# Will raise a KeyException if needed
super().__setitem__(lowerCamelCase__ ,lowerCamelCase__ )
# Don't call self.__setattr__ to avoid recursion errors
super().__setattr__(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
return tuple(self[k] for k in self.keys() )
class snake_case ( __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
@classmethod
def __lowerCAmelCase ( cls : str ,lowerCamelCase__ : Optional[int] ):
raise ValueError(
f'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "longest"
snake_case__ = "max_length"
snake_case__ = "do_not_pad"
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "pt"
snake_case__ = "tf"
snake_case__ = "np"
snake_case__ = "jax"
class snake_case :
"""simple docstring"""
def __init__( self : int ,lowerCamelCase__ : List[ContextManager] ):
UpperCAmelCase__ = context_managers
UpperCAmelCase__ = ExitStack()
def __enter__( self : Union[str, Any] ):
for context_manager in self.context_managers:
self.stack.enter_context(lowerCamelCase__ )
def __exit__( self : List[Any] ,*lowerCamelCase__ : List[str] ,**lowerCamelCase__ : Dict ):
self.stack.__exit__(*lowerCamelCase__ ,**lowerCamelCase__ )
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
for p in signature.parameters:
if p == "return_loss" and signature.parameters[p].default is True:
return True
return False
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = model_class.__name__
UpperCAmelCase__ = infer_framework(lowerCamelCase )
if framework == "tf":
UpperCAmelCase__ = inspect.signature(model_class.call ) # TensorFlow models
elif framework == "pt":
UpperCAmelCase__ = inspect.signature(model_class.forward ) # PyTorch models
else:
UpperCAmelCase__ = inspect.signature(model_class.__call__ ) # Flax models
if "QuestionAnswering" in model_name:
return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")]
else:
return [p for p in signature.parameters if "label" in p]
def a_ ( lowerCamelCase , lowerCamelCase = "" , lowerCamelCase = "." ):
def _flatten_dict(lowerCamelCase , lowerCamelCase="" , lowerCamelCase="." ):
for k, v in d.items():
UpperCAmelCase__ = str(lowerCamelCase ) + delimiter + str(lowerCamelCase ) if parent_key else k
if v and isinstance(lowerCamelCase , lowerCamelCase ):
yield from flatten_dict(lowerCamelCase , lowerCamelCase , delimiter=lowerCamelCase ).items()
else:
yield key, v
return dict(_flatten_dict(lowerCamelCase , lowerCamelCase , lowerCamelCase ) )
@contextmanager
def a_ ( lowerCamelCase , lowerCamelCase = False ):
if use_temp_dir:
with tempfile.TemporaryDirectory() as tmp_dir:
yield tmp_dir
else:
yield working_dir
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.transpose(lowerCamelCase , axes=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.T if axes is None else array.permute(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.transpose(lowerCamelCase , perm=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.transpose(lowerCamelCase , axes=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for transpose: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.reshape(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.reshape(*lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.reshape(lowerCamelCase , lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.reshape(lowerCamelCase , lowerCamelCase )
else:
raise ValueError(f'''Type not supported for reshape: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase=None ):
if is_numpy_array(lowerCamelCase ):
return np.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.squeeze() if axis is None else array.squeeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.squeeze(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.squeeze(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for squeeze: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.expand_dims(lowerCamelCase , lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.unsqueeze(dim=lowerCamelCase )
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.expand_dims(lowerCamelCase , axis=lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return jnp.expand_dims(lowerCamelCase , axis=lowerCamelCase )
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase ):
if is_numpy_array(lowerCamelCase ):
return np.size(lowerCamelCase )
elif is_torch_tensor(lowerCamelCase ):
return array.numel()
elif is_tf_tensor(lowerCamelCase ):
import tensorflow as tf
return tf.size(lowerCamelCase )
elif is_jax_tensor(lowerCamelCase ):
return array.size
else:
raise ValueError(f'''Type not supported for expand_dims: {type(lowerCamelCase )}.''' )
def a_ ( lowerCamelCase , lowerCamelCase ):
for key, value in auto_map.items():
if isinstance(lowerCamelCase , (tuple, list) ):
UpperCAmelCase__ = [f'''{repo_id}--{v}''' if (v is not None and '--' not in v) else v for v in value]
elif value is not None and "--" not in value:
UpperCAmelCase__ = f'''{repo_id}--{value}'''
return auto_map
def a_ ( lowerCamelCase ):
for base_class in inspect.getmro(lowerCamelCase ):
UpperCAmelCase__ = base_class.__module__
UpperCAmelCase__ = base_class.__name__
if module.startswith('tensorflow' ) or module.startswith('keras' ) or name == "TFPreTrainedModel":
return "tf"
elif module.startswith('torch' ) or name == "PreTrainedModel":
return "pt"
elif module.startswith('flax' ) or module.startswith('jax' ) or name == "FlaxPreTrainedModel":
return "flax"
else:
raise TypeError(f'''Could not infer framework from class {model_class}.''' )
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return int(input_a == input_a == 0 )
def a_ ( ):
print('Truth Table of NOR Gate:' )
print('| Input 1 | Input 2 | Output |' )
print(f'''| 0 | 0 | {nor_gate(0 , 0 )} |''' )
print(f'''| 0 | 1 | {nor_gate(0 , 1 )} |''' )
print(f'''| 1 | 0 | {nor_gate(1 , 0 )} |''' )
print(f'''| 1 | 1 | {nor_gate(1 , 1 )} |''' )
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 632 | """simple docstring"""
import gc
import tempfile
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
lowerCAmelCase__ : Union[str, Any] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@nightly
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=2 ,output_type='numpy' ,).images
with tempfile.TemporaryDirectory() as tmpdirname:
pipe.save_pretrained(lowerCamelCase__ )
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained(lowerCamelCase__ ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = generator.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt='first prompt' ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,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 __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = VersatileDiffusionPipeline.from_pretrained('shi-labs/versatile-diffusion' ,torch_dtype=torch.floataa )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'cyberpunk 2077'
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.dual_guided(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,text_to_image_strength=0.7_5 ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.1_4_4_8, 0.1_6_1_9, 0.1_7_4_1, 0.1_0_8_6, 0.1_1_4_7, 0.1_1_2_8, 0.1_1_9_9, 0.1_1_6_5, 0.1_0_0_1] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = 'A painting of a squirrel eating a burger '
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe.text_to_image(
prompt=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_3_6_7, 0.3_1_6_9, 0.2_6_5_6, 0.3_8_7_0, 0.4_7_9_0, 0.3_7_9_6, 0.4_0_0_9, 0.4_8_7_8, 0.4_7_7_8] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
UpperCAmelCase__ = pipe.image_variation(lowerCamelCase__ ,generator=lowerCamelCase__ ,output_type='numpy' ).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.3_0_7_6, 0.3_1_2_3, 0.3_2_8_4, 0.3_7_8_2, 0.3_7_7_0, 0.3_8_9_4, 0.4_2_9_7, 0.4_3_3_1, 0.4_4_5_6] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
| 632 | 1 |
"""simple docstring"""
import unittest
from dataclasses import dataclass
import pytest
from accelerate.commands.config.config_args import SageMakerConfig
from accelerate.utils import ComputeEnvironment
from accelerate.utils.launch import _convert_nargs_to_dict
@dataclass
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ComputeEnvironment.AMAZON_SAGEMAKER
snake_case__ = True
snake_case__ = "ml.p3.2xlarge"
snake_case__ = "accelerate_sagemaker_execution_role"
snake_case__ = "hf-sm"
snake_case__ = "us-east-1"
snake_case__ = 1
snake_case__ = "accelerate-sagemaker-1"
snake_case__ = "1.6"
snake_case__ = "4.4"
snake_case__ = "train.py"
snake_case__ = [
"--model_name_or_path",
"bert",
"--do_train",
"False",
"--epochs",
"3",
"--learning_rate",
"5e-5",
"--max_steps",
"50.5",
]
snake_case__ = [
"--model_name_or_path",
"bert",
"--do_train",
"--do_test",
"False",
"--do_predict",
"--epochs",
"3",
"--learning_rate",
"5e-5",
"--max_steps",
"50.5",
]
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[int] ):
# If no defaults are changed, `to_kwargs` returns an empty dict.
UpperCAmelCase__ = _convert_nargs_to_dict(MockLaunchConfig.success_training_script_args )
assert isinstance(converted_args['model_name_or_path'] ,lowerCamelCase__ )
assert isinstance(converted_args['do_train'] ,lowerCamelCase__ )
assert isinstance(converted_args['epochs'] ,lowerCamelCase__ )
assert isinstance(converted_args['learning_rate'] ,lowerCamelCase__ )
assert isinstance(converted_args['max_steps'] ,lowerCamelCase__ )
with pytest.raises(lowerCamelCase__ ):
_convert_nargs_to_dict(MockLaunchConfig.fail_training_script_args )
| 632 | """simple docstring"""
from typing import Optional
import numpy as np
import torch
from torch import nn
from transformers import GPTaConfig, GPTaLMHeadModel
from transformers.modeling_utils import ModuleUtilsMixin
from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = [R"h\.\d+\.attn\.bias", R"h\.\d+\.attn\.masked_bias"]
@register_to_config
def __init__( self : str ,lowerCamelCase__ : int ,lowerCamelCase__ : int ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : int = 50_257 ,lowerCamelCase__ : int = 1_024 ,lowerCamelCase__ : int = 768 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : int = 12 ,lowerCamelCase__ : Optional[int] = None ,lowerCamelCase__ : str = "gelu_new" ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 0.1 ,lowerCamelCase__ : float = 1e-5 ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : bool = False ,lowerCamelCase__ : bool = False ,):
super().__init__()
UpperCAmelCase__ = prefix_length
if prefix_inner_dim != n_embd and prefix_hidden_dim is None:
raise ValueError(
f'''`prefix_hidden_dim` cannot be `None` when `prefix_inner_dim`: {prefix_hidden_dim} and'''
f''' `n_embd`: {n_embd} are not equal.''' )
UpperCAmelCase__ = prefix_inner_dim
UpperCAmelCase__ = prefix_hidden_dim
UpperCAmelCase__ = (
nn.Linear(self.prefix_inner_dim ,self.prefix_hidden_dim )
if self.prefix_hidden_dim is not None
else nn.Identity()
)
UpperCAmelCase__ = (
nn.Linear(self.prefix_hidden_dim ,lowerCamelCase__ ) if self.prefix_hidden_dim is not None else nn.Identity()
)
UpperCAmelCase__ = GPTaConfig(
vocab_size=lowerCamelCase__ ,n_positions=lowerCamelCase__ ,n_embd=lowerCamelCase__ ,n_layer=lowerCamelCase__ ,n_head=lowerCamelCase__ ,n_inner=lowerCamelCase__ ,activation_function=lowerCamelCase__ ,resid_pdrop=lowerCamelCase__ ,embd_pdrop=lowerCamelCase__ ,attn_pdrop=lowerCamelCase__ ,layer_norm_epsilon=lowerCamelCase__ ,initializer_range=lowerCamelCase__ ,scale_attn_weights=lowerCamelCase__ ,use_cache=lowerCamelCase__ ,scale_attn_by_inverse_layer_idx=lowerCamelCase__ ,reorder_and_upcast_attn=lowerCamelCase__ ,)
UpperCAmelCase__ = GPTaLMHeadModel(lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : torch.Tensor ,lowerCamelCase__ : Optional[torch.Tensor] = None ,lowerCamelCase__ : Optional[torch.Tensor] = None ,):
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
UpperCAmelCase__ = self.encode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = self.decode_prefix(lowerCamelCase__ )
UpperCAmelCase__ = torch.cat((prefix_embeds, embedding_text) ,dim=1 )
if labels is not None:
UpperCAmelCase__ = self.get_dummy_token(input_ids.shape[0] ,input_ids.device )
UpperCAmelCase__ = torch.cat((dummy_token, input_ids) ,dim=1 )
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ ,labels=lowerCamelCase__ ,attention_mask=lowerCamelCase__ )
if self.prefix_hidden_dim is not None:
return out, hidden
else:
return out
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : torch.device ):
return torch.zeros(lowerCamelCase__ ,self.prefix_length ,dtype=torch.intaa ,device=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : List[str] ):
return self.encode_prefix(lowerCamelCase__ )
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = torch.split(lowerCamelCase__ ,1 ,dim=0 )
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for feature in features:
UpperCAmelCase__ = self.decode_prefix(feature.to(lowerCamelCase__ ) ) # back to the clip feature
# Only support beam search for now
UpperCAmelCase__ , UpperCAmelCase__ = self.generate_beam(
input_embeds=lowerCamelCase__ ,device=lowerCamelCase__ ,eos_token_id=lowerCamelCase__ )
generated_tokens.append(output_tokens[0] )
generated_seq_lengths.append(seq_lengths[0] )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
UpperCAmelCase__ = torch.stack(lowerCamelCase__ )
return generated_tokens, generated_seq_lengths
@torch.no_grad()
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : str=None ,lowerCamelCase__ : List[Any]=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : int = 5 ,lowerCamelCase__ : int = 67 ,lowerCamelCase__ : float = 1.0 ,lowerCamelCase__ : Optional[int] = None ,):
UpperCAmelCase__ = eos_token_id
UpperCAmelCase__ = None
UpperCAmelCase__ = None
UpperCAmelCase__ = torch.ones(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.int )
UpperCAmelCase__ = torch.zeros(lowerCamelCase__ ,device=lowerCamelCase__ ,dtype=torch.bool )
if input_embeds is not None:
UpperCAmelCase__ = input_embeds
else:
UpperCAmelCase__ = self.transformer.transformer.wte(lowerCamelCase__ )
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = self.transformer(inputs_embeds=lowerCamelCase__ )
UpperCAmelCase__ = outputs.logits
UpperCAmelCase__ = logits[:, -1, :] / (temperature if temperature > 0 else 1.0)
UpperCAmelCase__ = logits.softmax(-1 ).log()
if scores is None:
UpperCAmelCase__ , UpperCAmelCase__ = logits.topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = generated.expand(lowerCamelCase__ ,*generated.shape[1:] )
UpperCAmelCase__ , UpperCAmelCase__ = next_tokens.permute(1 ,0 ), scores.squeeze(0 )
if tokens is None:
UpperCAmelCase__ = next_tokens
else:
UpperCAmelCase__ = tokens.expand(lowerCamelCase__ ,*tokens.shape[1:] )
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
else:
UpperCAmelCase__ = -float(np.inf )
UpperCAmelCase__ = 0
UpperCAmelCase__ = scores[:, None] + logits
seq_lengths[~is_stopped] += 1
UpperCAmelCase__ = scores_sum / seq_lengths[:, None]
UpperCAmelCase__ , UpperCAmelCase__ = scores_sum_average.view(-1 ).topk(lowerCamelCase__ ,-1 )
UpperCAmelCase__ = next_tokens // scores_sum.shape[1]
UpperCAmelCase__ = seq_lengths[next_tokens_source]
UpperCAmelCase__ = next_tokens % scores_sum.shape[1]
UpperCAmelCase__ = next_tokens.unsqueeze(1 )
UpperCAmelCase__ = tokens[next_tokens_source]
UpperCAmelCase__ = torch.cat((tokens, next_tokens) ,dim=1 )
UpperCAmelCase__ = generated[next_tokens_source]
UpperCAmelCase__ = scores_sum_average * seq_lengths
UpperCAmelCase__ = is_stopped[next_tokens_source]
UpperCAmelCase__ = self.transformer.transformer.wte(next_tokens.squeeze() ).view(generated.shape[0] ,1 ,-1 )
UpperCAmelCase__ = torch.cat((generated, next_token_embed) ,dim=1 )
UpperCAmelCase__ = is_stopped + next_tokens.eq(lowerCamelCase__ ).squeeze()
if is_stopped.all():
break
UpperCAmelCase__ = scores / seq_lengths
UpperCAmelCase__ = scores.argsort(descending=lowerCamelCase__ )
# tokens tensors are already padded to max_seq_length
UpperCAmelCase__ = [tokens[i] for i in order]
UpperCAmelCase__ = torch.stack(lowerCamelCase__ ,dim=0 )
UpperCAmelCase__ = torch.tensor([seq_lengths[i] for i in order] ,dtype=seq_lengths.dtype )
return output_texts, seq_lengths
| 632 | 1 |
"""simple docstring"""
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
lowerCAmelCase__ : Union[str, Any] = logging.get_logger(__name__)
lowerCAmelCase__ : List[Any] = {
'google/efficientnet-b7': 'https://huggingface.co/google/efficientnet-b7/resolve/main/config.json',
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "efficientnet"
def __init__( self : List[str] ,lowerCamelCase__ : int = 3 ,lowerCamelCase__ : int = 600 ,lowerCamelCase__ : float = 2.0 ,lowerCamelCase__ : float = 3.1 ,lowerCamelCase__ : int = 8 ,lowerCamelCase__ : List[int] = [3, 3, 5, 3, 5, 5, 3] ,lowerCamelCase__ : List[int] = [32, 16, 24, 40, 80, 112, 192] ,lowerCamelCase__ : List[int] = [16, 24, 40, 80, 112, 192, 320] ,lowerCamelCase__ : List[int] = [] ,lowerCamelCase__ : List[int] = [1, 2, 2, 2, 1, 2, 1] ,lowerCamelCase__ : List[int] = [1, 2, 2, 3, 3, 4, 1] ,lowerCamelCase__ : List[int] = [1, 6, 6, 6, 6, 6, 6] ,lowerCamelCase__ : float = 0.2_5 ,lowerCamelCase__ : str = "swish" ,lowerCamelCase__ : int = 2_560 ,lowerCamelCase__ : str = "mean" ,lowerCamelCase__ : float = 0.0_2 ,lowerCamelCase__ : float = 0.0_0_1 ,lowerCamelCase__ : float = 0.9_9 ,lowerCamelCase__ : float = 0.5 ,lowerCamelCase__ : float = 0.2 ,**lowerCamelCase__ : Dict ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = num_channels
UpperCAmelCase__ = image_size
UpperCAmelCase__ = width_coefficient
UpperCAmelCase__ = depth_coefficient
UpperCAmelCase__ = depth_divisor
UpperCAmelCase__ = kernel_sizes
UpperCAmelCase__ = in_channels
UpperCAmelCase__ = out_channels
UpperCAmelCase__ = depthwise_padding
UpperCAmelCase__ = strides
UpperCAmelCase__ = num_block_repeats
UpperCAmelCase__ = expand_ratios
UpperCAmelCase__ = squeeze_expansion_ratio
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = hidden_dim
UpperCAmelCase__ = pooling_type
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = batch_norm_eps
UpperCAmelCase__ = batch_norm_momentum
UpperCAmelCase__ = dropout_rate
UpperCAmelCase__ = drop_connect_rate
UpperCAmelCase__ = sum(lowerCamelCase__ ) * 4
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = version.parse("1.11" )
@property
def __lowerCAmelCase ( self : int ):
return OrderedDict(
[
('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
] )
@property
def __lowerCAmelCase ( self : Optional[Any] ):
return 1e-5
| 632 | """simple docstring"""
import argparse
import os
import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints
from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
lowerCAmelCase__ : str = 'base_with_context'
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['token_embedder']['embedding'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['input_proj']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
for lyr_num, lyr in enumerate(model.encoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = ly_weight['attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['encoder_norm']['scale'] ) )
return model
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['time_emb_dense1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['Embed_0']['embedding'] ) , requires_grad=lowerCamelCase )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(weights['continuous_inputs_projection']['kernel'].T ) )
for lyr_num, lyr in enumerate(model.decoders ):
UpperCAmelCase__ = weights[f'''layers_{lyr_num}''']
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_self_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_0']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['self_attention']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = ly_weight['MultiHeadDotProductAttention_0']
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['query']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['key']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['value']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(attention_weights['out']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['pre_cross_attention_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['pre_mlp_layer_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(
torch.FloatTensor(ly_weight['FiLMLayer_1']['DenseGeneral_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_0']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wi_1']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(ly_weight['mlp']['wo']['kernel'].T ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['decoder_norm']['scale'] ) )
UpperCAmelCase__ = nn.Parameter(torch.FloatTensor(weights['spec_out_dense']['kernel'].T ) )
return model
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = checkpoints.load_tax_checkpoint(args.checkpoint_path )
UpperCAmelCase__ = jnp.tree_util.tree_map(onp.array , lowerCamelCase )
UpperCAmelCase__ = [
'from __gin__ import dynamic_registration',
'from music_spectrogram_diffusion.models.diffusion import diffusion_utils',
'diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0',
'diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()',
]
UpperCAmelCase__ = os.path.join(args.checkpoint_path , '..' , 'config.gin' )
UpperCAmelCase__ = inference.parse_training_gin_file(lowerCamelCase , lowerCamelCase )
UpperCAmelCase__ = inference.InferenceModel(args.checkpoint_path , lowerCamelCase )
UpperCAmelCase__ = DDPMScheduler(beta_schedule='squaredcos_cap_v2' , variance_type='fixed_large' )
UpperCAmelCase__ = SpectrogramNotesEncoder(
max_length=synth_model.sequence_length['inputs'] , vocab_size=synth_model.model.module.config.vocab_size , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = SpectrogramContEncoder(
input_dims=synth_model.audio_codec.n_dims , targets_context_length=synth_model.sequence_length['targets_context'] , d_model=synth_model.model.module.config.emb_dim , dropout_rate=synth_model.model.module.config.dropout_rate , num_layers=synth_model.model.module.config.num_encoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , feed_forward_proj='gated-gelu' , )
UpperCAmelCase__ = TaFilmDecoder(
input_dims=synth_model.audio_codec.n_dims , targets_length=synth_model.sequence_length['targets_context'] , max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time , d_model=synth_model.model.module.config.emb_dim , num_layers=synth_model.model.module.config.num_decoder_layers , num_heads=synth_model.model.module.config.num_heads , d_kv=synth_model.model.module.config.head_dim , d_ff=synth_model.model.module.config.mlp_dim , dropout_rate=synth_model.model.module.config.dropout_rate , )
UpperCAmelCase__ = load_notes_encoder(ta_checkpoint['target']['token_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_continuous_encoder(ta_checkpoint['target']['continuous_encoder'] , lowerCamelCase )
UpperCAmelCase__ = load_decoder(ta_checkpoint['target']['decoder'] , lowerCamelCase )
UpperCAmelCase__ = OnnxRuntimeModel.from_pretrained('kashif/soundstream_mel_decoder' )
UpperCAmelCase__ = SpectrogramDiffusionPipeline(
notes_encoder=lowerCamelCase , continuous_encoder=lowerCamelCase , decoder=lowerCamelCase , scheduler=lowerCamelCase , melgan=lowerCamelCase , )
if args.save:
pipe.save_pretrained(args.output_path )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
parser.add_argument('--output_path', default=None, type=str, required=True, help='Path to the converted model.')
parser.add_argument(
'--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
)
parser.add_argument(
'--checkpoint_path',
default=F"""{MODEL}/checkpoint_500000""",
type=str,
required=False,
help='Path to the original jax model checkpoint.',
)
lowerCAmelCase__ : List[str] = parser.parse_args()
main(args)
| 632 | 1 |
"""simple docstring"""
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_torch_available,
)
lowerCAmelCase__ : Dict = {
'configuration_resnet': ['RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ResNetConfig', 'ResNetOnnxConfig']
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[int] = [
'RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
'ResNetForImageClassification',
'ResNetModel',
'ResNetPreTrainedModel',
'ResNetBackbone',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : List[Any] = [
'TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFResNetForImageClassification',
'TFResNetModel',
'TFResNetPreTrainedModel',
]
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : int = [
'FlaxResNetForImageClassification',
'FlaxResNetModel',
'FlaxResNetPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_resnet import (
RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
ResNetBackbone,
ResNetForImageClassification,
ResNetModel,
ResNetPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_resnet import (
TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST,
TFResNetForImageClassification,
TFResNetModel,
TFResNetPreTrainedModel,
)
try:
if not is_flax_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel
else:
import sys
lowerCAmelCase__ : Tuple = _LazyModule(__name__, globals()['__file__'], _import_structure)
| 632 | """simple docstring"""
import socket
def a_ ( ):
UpperCAmelCase__ = socket.socket(socket.AF_INET , socket.SOCK_STREAM )
UpperCAmelCase__ = socket.gethostname()
UpperCAmelCase__ = 1_2_3_1_2
sock.connect((host, port) )
sock.send(b'Hello server!' )
with open('Received_file' , 'wb' ) as out_file:
print('File opened' )
print('Receiving data...' )
while True:
UpperCAmelCase__ = sock.recv(1_0_2_4 )
if not data:
break
out_file.write(lowerCamelCase )
print('Successfully received the file' )
sock.close()
print('Connection closed' )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path
import torch_xla.distributed.xla_multiprocessing as xmp
def a_ ( ):
UpperCAmelCase__ = ArgumentParser(
description=(
'PyTorch TPU distributed training launch '
'helper utility that will spawn up '
'multiple distributed processes'
) )
# Optional arguments for the launch helper
parser.add_argument('--num_cores' , type=lowerCamelCase , default=1 , help='Number of TPU cores to use (1 or 8).' )
# positional
parser.add_argument(
'training_script' , type=lowerCamelCase , help=(
'The full path to the single TPU training '
'program/script to be launched in parallel, '
'followed by all the arguments for the '
'training script'
) , )
# rest from the training program
parser.add_argument('training_script_args' , nargs=lowerCamelCase )
return parser.parse_args()
def a_ ( ):
UpperCAmelCase__ = parse_args()
# Import training_script as a module.
UpperCAmelCase__ = Path(args.training_script )
sys.path.append(str(script_fpath.parent.resolve() ) )
UpperCAmelCase__ = script_fpath.stem
UpperCAmelCase__ = importlib.import_module(lowerCamelCase )
# Patch sys.argv
UpperCAmelCase__ = [args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores )]
xmp.spawn(mod._mp_fn , args=() , nprocs=args.num_cores )
if __name__ == "__main__":
main()
| 632 | """simple docstring"""
from __future__ import annotations
class snake_case :
"""simple docstring"""
def __init__( self : Dict ,lowerCamelCase__ : list[list[int]] ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = 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
UpperCAmelCase__ = rows
else:
UpperCAmelCase__ = []
def __lowerCAmelCase ( self : Union[str, Any] ):
return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]
@property
def __lowerCAmelCase ( self : str ):
return len(self.rows )
@property
def __lowerCAmelCase ( self : List[Any] ):
return len(self.rows[0] )
@property
def __lowerCAmelCase ( self : Any ):
return (self.num_rows, self.num_columns)
@property
def __lowerCAmelCase ( self : Optional[int] ):
return self.order[0] == self.order[1]
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = [
[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 __lowerCAmelCase ( self : str ):
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 __lowerCAmelCase ( self : List[str] ):
return bool(self.determinant() )
def __lowerCAmelCase ( self : Any ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
UpperCAmelCase__ = [
[
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 __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : int ,lowerCamelCase__ : int ):
if (row + column) % 2 == 0:
return self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
return -1 * self.get_minor(lowerCamelCase__ ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
return Matrix(
[
[self.get_minor(lowerCamelCase__ ,lowerCamelCase__ ) for column in range(self.num_columns )]
for row in range(self.num_rows )
] )
def __lowerCAmelCase ( self : int ):
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 __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = [
[self.cofactors().rows[column][row] for column in range(self.num_columns )]
for row in range(self.num_rows )
]
return Matrix(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = 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 : Optional[Any] ):
return str(self.rows )
def __str__( self : List[str] ):
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 __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = self.rows[0:position] + [row] + self.rows[position:]
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : int | None = None ):
UpperCAmelCase__ = 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:
UpperCAmelCase__ = [self.rows[i] + [column[i]] for i in range(self.num_rows )]
else:
UpperCAmelCase__ = [
self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
for i in range(self.num_rows )
]
def __eq__( self : List[Any] ,lowerCamelCase__ : object ):
if not isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
return NotImplemented
return self.rows == other.rows
def __ne__( self : Any ,lowerCamelCase__ : object ):
return not self == other
def __neg__( self : Dict ):
return self * -1
def __add__( self : str ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix ):
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 : List[str] ,lowerCamelCase__ : Matrix | int | float ):
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 ):
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' )
UpperCAmelCase__ = self
for _ in range(other - 1 ):
result *= self
return result
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ,lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
return sum(row[i] * column[i] for i in range(len(lowerCamelCase__ ) ) )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 632 | 1 |
"""simple docstring"""
import inspect
import unittest
import warnings
from math import ceil, floor
from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from transformers import (
MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
MODEL_MAPPING,
LevitForImageClassification,
LevitForImageClassificationWithTeacher,
LevitModel,
)
from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST
if is_vision_available():
from PIL import Image
from transformers import LevitImageProcessor
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.config_class(**self.inputs_dict )
self.parent.assertTrue(hasattr(lowerCamelCase__ ,'hidden_sizes' ) )
self.parent.assertTrue(hasattr(lowerCamelCase__ ,'num_attention_heads' ) )
class snake_case :
"""simple docstring"""
def __init__( self : List[Any] ,lowerCamelCase__ : List[Any] ,lowerCamelCase__ : List[str]=13 ,lowerCamelCase__ : Optional[int]=64 ,lowerCamelCase__ : List[Any]=3 ,lowerCamelCase__ : Union[str, Any]=3 ,lowerCamelCase__ : Tuple=2 ,lowerCamelCase__ : Optional[Any]=1 ,lowerCamelCase__ : Union[str, Any]=16 ,lowerCamelCase__ : Any=[128, 256, 384] ,lowerCamelCase__ : Dict=[4, 6, 8] ,lowerCamelCase__ : int=[2, 3, 4] ,lowerCamelCase__ : List[str]=[16, 16, 16] ,lowerCamelCase__ : Tuple=0 ,lowerCamelCase__ : Optional[int]=[2, 2, 2] ,lowerCamelCase__ : int=[2, 2, 2] ,lowerCamelCase__ : str=0.0_2 ,lowerCamelCase__ : str=True ,lowerCamelCase__ : int=True ,lowerCamelCase__ : Any=2 ,):
UpperCAmelCase__ = parent
UpperCAmelCase__ = batch_size
UpperCAmelCase__ = image_size
UpperCAmelCase__ = num_channels
UpperCAmelCase__ = kernel_size
UpperCAmelCase__ = stride
UpperCAmelCase__ = padding
UpperCAmelCase__ = hidden_sizes
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = depths
UpperCAmelCase__ = key_dim
UpperCAmelCase__ = drop_path_rate
UpperCAmelCase__ = patch_size
UpperCAmelCase__ = attention_ratio
UpperCAmelCase__ = mlp_ratio
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = [
['Subsample', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
['Subsample', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
]
UpperCAmelCase__ = is_training
UpperCAmelCase__ = use_labels
UpperCAmelCase__ = num_labels
UpperCAmelCase__ = initializer_range
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
UpperCAmelCase__ = None
if self.use_labels:
UpperCAmelCase__ = ids_tensor([self.batch_size] ,self.num_labels )
UpperCAmelCase__ = self.get_config()
return config, pixel_values, labels
def __lowerCAmelCase ( self : Dict ):
return LevitConfig(
image_size=self.image_size ,num_channels=self.num_channels ,kernel_size=self.kernel_size ,stride=self.stride ,padding=self.padding ,patch_size=self.patch_size ,hidden_sizes=self.hidden_sizes ,num_attention_heads=self.num_attention_heads ,depths=self.depths ,key_dim=self.key_dim ,drop_path_rate=self.drop_path_rate ,mlp_ratio=self.mlp_ratio ,attention_ratio=self.attention_ratio ,initializer_range=self.initializer_range ,down_ops=self.down_ops ,)
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : Any ,lowerCamelCase__ : Any ):
UpperCAmelCase__ = LevitModel(config=lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
UpperCAmelCase__ = model(lowerCamelCase__ )
UpperCAmelCase__ = (self.image_size, self.image_size)
UpperCAmelCase__ , UpperCAmelCase__ = image_size[0], image_size[1]
for _ in range(4 ):
UpperCAmelCase__ = floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1 )
UpperCAmelCase__ = floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1 )
self.parent.assertEqual(
result.last_hidden_state.shape ,(self.batch_size, ceil(height / 4 ) * ceil(width / 4 ), self.hidden_sizes[-1]) ,)
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : Dict ,lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[Any] ):
UpperCAmelCase__ = self.num_labels
UpperCAmelCase__ = LevitForImageClassification(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
UpperCAmelCase__ = model(lowerCamelCase__ ,labels=lowerCamelCase__ )
self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels) )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.prepare_config_and_inputs()
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = config_and_inputs
UpperCAmelCase__ = {'pixel_values': pixel_values}
return config, inputs_dict
@require_torch
class snake_case ( __UpperCAmelCase , __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = (
(LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
if is_torch_available()
else ()
)
snake_case__ = (
{
"feature-extraction": LevitModel,
"image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
}
if is_torch_available()
else {}
)
snake_case__ = False
snake_case__ = False
snake_case__ = False
snake_case__ = False
snake_case__ = False
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = LevitModelTester(self )
UpperCAmelCase__ = ConfigTester(self ,config_class=lowerCamelCase__ ,has_text_modality=lowerCamelCase__ ,hidden_size=37 )
def __lowerCAmelCase ( self : List[Any] ):
self.create_and_test_config_common_properties()
self.config_tester.create_and_test_config_to_json_string()
self.config_tester.create_and_test_config_to_json_file()
self.config_tester.create_and_test_config_from_and_save_pretrained()
self.config_tester.create_and_test_config_with_num_labels()
self.config_tester.check_config_can_be_init_without_params()
self.config_tester.check_config_arguments_init()
def __lowerCAmelCase ( self : int ):
return
@unittest.skip(reason='Levit does not use inputs_embeds' )
def __lowerCAmelCase ( self : List[Any] ):
pass
@unittest.skip(reason='Levit does not support input and output embeddings' )
def __lowerCAmelCase ( self : Tuple ):
pass
@unittest.skip(reason='Levit does not output attentions' )
def __lowerCAmelCase ( self : Union[str, Any] ):
pass
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase__ = model_class(lowerCamelCase__ )
UpperCAmelCase__ = inspect.signature(model.forward )
# signature.parameters is an OrderedDict => so arg_names order is deterministic
UpperCAmelCase__ = [*signature.parameters.keys()]
UpperCAmelCase__ = ['pixel_values']
self.assertListEqual(arg_names[:1] ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
def check_hidden_states_output(lowerCamelCase__ : Tuple ,lowerCamelCase__ : Tuple ,lowerCamelCase__ : int ):
UpperCAmelCase__ = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.eval()
with torch.no_grad():
UpperCAmelCase__ = model(**self._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ) )
UpperCAmelCase__ = outputs.hidden_states
UpperCAmelCase__ = len(self.model_tester.depths ) + 1
self.assertEqual(len(lowerCamelCase__ ) ,lowerCamelCase__ )
UpperCAmelCase__ = (self.model_tester.image_size, self.model_tester.image_size)
UpperCAmelCase__ , UpperCAmelCase__ = image_size[0], image_size[1]
for _ in range(4 ):
UpperCAmelCase__ = floor(
(
(height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
/ self.model_tester.stride
)
+ 1 )
UpperCAmelCase__ = floor(
(
(width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
/ self.model_tester.stride
)
+ 1 )
# verify the first hidden states (first block)
self.assertListEqual(
list(hidden_states[0].shape[-2:] ) ,[
height * width,
self.model_tester.hidden_sizes[0],
] ,)
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
UpperCAmelCase__ = True
check_hidden_states_output(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
# check that output_hidden_states also work using config
del inputs_dict["output_hidden_states"]
UpperCAmelCase__ = True
check_hidden_states_output(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' )
def __lowerCAmelCase ( self : Dict ):
pass
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : int ,lowerCamelCase__ : Union[str, Any]=False ):
UpperCAmelCase__ = super()._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ,return_labels=lowerCamelCase__ )
if return_labels:
if model_class.__name__ == "LevitForImageClassificationWithTeacher":
del inputs_dict["labels"]
return inputs_dict
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
if not self.model_tester.is_training:
return
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
UpperCAmelCase__ = True
for model_class in self.all_model_classes:
# LevitForImageClassificationWithTeacher supports inference-only
if (
model_class in get_values(lowerCamelCase__ )
or model_class.__name__ == "LevitForImageClassificationWithTeacher"
):
continue
UpperCAmelCase__ = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.train()
UpperCAmelCase__ = self._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ,return_labels=lowerCamelCase__ )
UpperCAmelCase__ = model(**lowerCamelCase__ ).loss
loss.backward()
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
if not self.model_tester.is_training:
return
UpperCAmelCase__ = False
UpperCAmelCase__ = True
for model_class in self.all_model_classes:
if model_class in get_values(lowerCamelCase__ ) or not model_class.supports_gradient_checkpointing:
continue
# LevitForImageClassificationWithTeacher supports inference-only
if model_class.__name__ == "LevitForImageClassificationWithTeacher":
continue
UpperCAmelCase__ = model_class(lowerCamelCase__ )
model.gradient_checkpointing_enable()
model.to(lowerCamelCase__ )
model.train()
UpperCAmelCase__ = self._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ,return_labels=lowerCamelCase__ )
UpperCAmelCase__ = model(**lowerCamelCase__ ).loss
loss.backward()
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ , UpperCAmelCase__ = self.model_tester.prepare_config_and_inputs_for_common()
UpperCAmelCase__ = [
{'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
{'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
{'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
]
for model_class in self.all_model_classes:
if (
model_class
not in [
*get_values(lowerCamelCase__ ),
]
or model_class.__name__ == "LevitForImageClassificationWithTeacher"
):
continue
for problem_type in problem_types:
with self.subTest(msg=f'''Testing {model_class} with {problem_type["title"]}''' ):
UpperCAmelCase__ = problem_type['title']
UpperCAmelCase__ = problem_type['num_labels']
UpperCAmelCase__ = model_class(lowerCamelCase__ )
model.to(lowerCamelCase__ )
model.train()
UpperCAmelCase__ = self._prepare_for_class(lowerCamelCase__ ,lowerCamelCase__ ,return_labels=lowerCamelCase__ )
if problem_type["num_labels"] > 1:
UpperCAmelCase__ = inputs['labels'].unsqueeze(1 ).repeat(1 ,problem_type['num_labels'] )
UpperCAmelCase__ = inputs['labels'].to(problem_type['dtype'] )
# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
# they have the same size." which is a symptom something in wrong for the regression problem.
# See https://github.com/huggingface/transformers/issues/11780
with warnings.catch_warnings(record=lowerCamelCase__ ) as warning_list:
UpperCAmelCase__ = model(**lowerCamelCase__ ).loss
for w in warning_list:
if "Using a target size that is different to the input size" in str(w.message ):
raise ValueError(
f'''Something is going wrong in the regression problem: intercepted {w.message}''' )
loss.backward()
@slow
def __lowerCAmelCase ( self : int ):
for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
UpperCAmelCase__ = LevitModel.from_pretrained(lowerCamelCase__ )
self.assertIsNotNone(lowerCamelCase__ )
def a_ ( ):
UpperCAmelCase__ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
return image
@require_torch
@require_vision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@cached_property
def __lowerCAmelCase ( self : Dict ):
return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
@slow
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(
lowerCamelCase__ )
UpperCAmelCase__ = self.default_image_processor
UpperCAmelCase__ = prepare_img()
UpperCAmelCase__ = image_processor(images=lowerCamelCase__ ,return_tensors='pt' ).to(lowerCamelCase__ )
# forward pass
with torch.no_grad():
UpperCAmelCase__ = model(**lowerCamelCase__ )
# verify the logits
UpperCAmelCase__ = torch.Size((1, 1_000) )
self.assertEqual(outputs.logits.shape ,lowerCamelCase__ )
UpperCAmelCase__ = torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7] ).to(lowerCamelCase__ )
self.assertTrue(torch.allclose(outputs.logits[0, :3] ,lowerCamelCase__ ,atol=1e-4 ) )
| 632 | """simple docstring"""
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
lowerCAmelCase__ : int = {
'configuration_tapas': ['TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TapasConfig'],
'tokenization_tapas': ['TapasTokenizer'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Union[str, Any] = [
'TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TapasForMaskedLM',
'TapasForQuestionAnswering',
'TapasForSequenceClassification',
'TapasModel',
'TapasPreTrainedModel',
'load_tf_weights_in_tapas',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCAmelCase__ : Optional[Any] = [
'TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST',
'TFTapasForMaskedLM',
'TFTapasForQuestionAnswering',
'TFTapasForSequenceClassification',
'TFTapasModel',
'TFTapasPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
from .tokenization_tapas import TapasTokenizer
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tapas import (
TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TapasForMaskedLM,
TapasForQuestionAnswering,
TapasForSequenceClassification,
TapasModel,
TapasPreTrainedModel,
load_tf_weights_in_tapas,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_tapas import (
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
TFTapasForMaskedLM,
TFTapasForQuestionAnswering,
TFTapasForSequenceClassification,
TFTapasModel,
TFTapasPreTrainedModel,
)
else:
import sys
lowerCAmelCase__ : Dict = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 632 | 1 |
"""simple docstring"""
from __future__ import annotations
import sys
from collections import deque
from typing import Generic, TypeVar
lowerCAmelCase__ : Any = TypeVar('T')
class snake_case ( Generic[T] ):
"""simple docstring"""
snake_case__ = 42 # Cache store of keys
snake_case__ = 42 # References of the keys in cache
snake_case__ = 10 # Maximum capacity of cache
def __init__( self : List[Any] ,lowerCamelCase__ : int ):
UpperCAmelCase__ = deque()
UpperCAmelCase__ = set()
if not n:
UpperCAmelCase__ = sys.maxsize
elif n < 0:
raise ValueError('n should be an integer greater than 0.' )
else:
UpperCAmelCase__ = n
def __lowerCAmelCase ( self : int ,lowerCamelCase__ : T ):
if x not in self.key_reference:
if len(self.dq_store ) == LRUCache._MAX_CAPACITY:
UpperCAmelCase__ = self.dq_store.pop()
self.key_reference.remove(lowerCamelCase__ )
else:
self.dq_store.remove(lowerCamelCase__ )
self.dq_store.appendleft(lowerCamelCase__ )
self.key_reference.add(lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
for k in self.dq_store:
print(lowerCamelCase__ )
def __repr__( self : List[Any] ):
return f'''LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}'''
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCAmelCase__ : LRUCache[str | int] = LRUCache(4)
lru_cache.refer('A')
lru_cache.refer(2)
lru_cache.refer(3)
lru_cache.refer('A')
lru_cache.refer(4)
lru_cache.refer(5)
lru_cache.display()
print(lru_cache)
assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
| 632 | """simple docstring"""
import unittest
import numpy as np
import torch
from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device
lowerCAmelCase__ : Optional[int] = False
class snake_case ( unittest.TestCase ):
"""simple docstring"""
pass
@slow
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = VersatileDiffusionImageVariationPipeline.from_pretrained('shi-labs/versatile-diffusion' )
pipe.to(lowerCamelCase__ )
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg' )
UpperCAmelCase__ = torch.manual_seed(0 )
UpperCAmelCase__ = pipe(
image=lowerCamelCase__ ,generator=lowerCamelCase__ ,guidance_scale=7.5 ,num_inference_steps=50 ,output_type='numpy' ,).images
UpperCAmelCase__ = image[0, 253:256, 253:256, -1]
assert image.shape == (1, 512, 512, 3)
UpperCAmelCase__ = np.array([0.0_4_4_1, 0.0_4_6_9, 0.0_5_0_7, 0.0_5_7_5, 0.0_6_3_2, 0.0_6_5_0, 0.0_8_6_5, 0.0_9_0_9, 0.0_9_4_5] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
| 632 | 1 |
"""simple docstring"""
import copy
import random
from transformers import CLIPTokenizer
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : int ,*lowerCamelCase__ : int ,**lowerCamelCase__ : str ):
super().__init__(*lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = {}
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : Optional[int] ,*lowerCamelCase__ : str ,**lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = super().add_tokens(lowerCamelCase__ ,*lowerCamelCase__ ,**lowerCamelCase__ )
if num_added_tokens == 0:
raise ValueError(
f'''The tokenizer already contains the token {placeholder_token}. Please pass a different'''
' `placeholder_token` that is not already in the tokenizer.' )
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : Dict ,*lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : str=1 ,**lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = []
if num_vec_per_token == 1:
self.try_adding_tokens(lowerCamelCase__ ,*lowerCamelCase__ ,**lowerCamelCase__ )
output.append(lowerCamelCase__ )
else:
UpperCAmelCase__ = []
for i in range(lowerCamelCase__ ):
UpperCAmelCase__ = placeholder_token + f'''_{i}'''
self.try_adding_tokens(lowerCamelCase__ ,*lowerCamelCase__ ,**lowerCamelCase__ )
output.append(lowerCamelCase__ )
# handle cases where there is a new placeholder token that contains the current placeholder token but is larger
for token in self.token_map:
if token in placeholder_token:
raise ValueError(
f'''The tokenizer already has placeholder token {token} that can get confused with'''
f''' {placeholder_token}keep placeholder tokens independent''' )
UpperCAmelCase__ = output
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Any=False ,lowerCamelCase__ : int=1.0 ):
if isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
output.append(self.replace_placeholder_tokens_in_text(text[i] ,vector_shuffle=lowerCamelCase__ ) )
return output
for placeholder_token in self.token_map:
if placeholder_token in text:
UpperCAmelCase__ = self.token_map[placeholder_token]
UpperCAmelCase__ = tokens[: 1 + int(len(lowerCamelCase__ ) * prop_tokens_to_load )]
if vector_shuffle:
UpperCAmelCase__ = copy.copy(lowerCamelCase__ )
random.shuffle(lowerCamelCase__ )
UpperCAmelCase__ = text.replace(lowerCamelCase__ ,' '.join(lowerCamelCase__ ) )
return text
def __call__( self : Tuple ,lowerCamelCase__ : List[str] ,*lowerCamelCase__ : int ,lowerCamelCase__ : Tuple=False ,lowerCamelCase__ : Optional[int]=1.0 ,**lowerCamelCase__ : int ):
return super().__call__(
self.replace_placeholder_tokens_in_text(
lowerCamelCase__ ,vector_shuffle=lowerCamelCase__ ,prop_tokens_to_load=lowerCamelCase__ ) ,*lowerCamelCase__ ,**lowerCamelCase__ ,)
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : Optional[int] ,*lowerCamelCase__ : Union[str, Any] ,lowerCamelCase__ : Optional[int]=False ,lowerCamelCase__ : Union[str, Any]=1.0 ,**lowerCamelCase__ : Dict ):
return super().encode(
self.replace_placeholder_tokens_in_text(
lowerCamelCase__ ,vector_shuffle=lowerCamelCase__ ,prop_tokens_to_load=lowerCamelCase__ ) ,*lowerCamelCase__ ,**lowerCamelCase__ ,)
| 632 | """simple docstring"""
from __future__ import annotations
from math import ceil, floor, sqrt
def a_ ( lowerCamelCase = 2_0_0_0_0_0_0 ):
UpperCAmelCase__ = [0]
UpperCAmelCase__ = 42
for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ):
triangle_numbers.append(triangle_numbers[-1] + idx )
# we want this to be as close as possible to target
UpperCAmelCase__ = 0
# the area corresponding to the grid that gives the product closest to target
UpperCAmelCase__ = 0
# an estimate of b, using the quadratic formula
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the largest integer less than b_estimate
UpperCAmelCase__ = 42
# the triangle number corresponding to b_floor
UpperCAmelCase__ = 42
# the triangle number corresponding to b_ceil
UpperCAmelCase__ = 42
for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ):
UpperCAmelCase__ = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2
UpperCAmelCase__ = floor(lowerCamelCase )
UpperCAmelCase__ = ceil(lowerCamelCase )
UpperCAmelCase__ = triangle_numbers[b_floor]
UpperCAmelCase__ = triangle_numbers[b_ceil]
if abs(target - triangle_b_first_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_first_guess * triangle_a
UpperCAmelCase__ = idx_a * b_floor
if abs(target - triangle_b_second_guess * triangle_a ) < abs(
target - best_product ):
UpperCAmelCase__ = triangle_b_second_guess * triangle_a
UpperCAmelCase__ = idx_a * b_ceil
return area
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import unittest
from transformers import (
MODEL_FOR_CAUSAL_LM_MAPPING,
TF_MODEL_FOR_CAUSAL_LM_MAPPING,
TextGenerationPipeline,
logging,
pipeline,
)
from transformers.testing_utils import (
CaptureLogger,
is_pipeline_test,
require_accelerate,
require_tf,
require_torch,
require_torch_gpu,
require_torch_or_tf,
)
from .test_pipelines_common import ANY
@is_pipeline_test
@require_torch_or_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
snake_case__ = MODEL_FOR_CAUSAL_LM_MAPPING
snake_case__ = TF_MODEL_FOR_CAUSAL_LM_MAPPING
@require_torch
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = pipeline(task='text-generation' ,model='sshleifer/tiny-ctrl' ,framework='pt' )
# Using `do_sample=False` to force deterministic output
UpperCAmelCase__ = text_generator('This is a test' ,do_sample=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
{
'generated_text': (
'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
' oscope. FiliFili@@'
)
}
] ,)
UpperCAmelCase__ = text_generator(['This is a test', 'This is a second test'] )
self.assertEqual(
lowerCamelCase__ ,[
[
{
'generated_text': (
'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
' oscope. FiliFili@@'
)
}
],
[
{
'generated_text': (
'This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'
' oscope. oscope. FiliFili@@'
)
}
],
] ,)
UpperCAmelCase__ = text_generator('This is a test' ,do_sample=lowerCamelCase__ ,num_return_sequences=2 ,return_tensors=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
{'generated_token_ids': ANY(lowerCamelCase__ )},
{'generated_token_ids': ANY(lowerCamelCase__ )},
] ,)
UpperCAmelCase__ = text_generator.model.config.eos_token_id
UpperCAmelCase__ = '<pad>'
UpperCAmelCase__ = text_generator(
['This is a test', 'This is a second test'] ,do_sample=lowerCamelCase__ ,num_return_sequences=2 ,batch_size=2 ,return_tensors=lowerCamelCase__ ,)
self.assertEqual(
lowerCamelCase__ ,[
[
{'generated_token_ids': ANY(lowerCamelCase__ )},
{'generated_token_ids': ANY(lowerCamelCase__ )},
],
[
{'generated_token_ids': ANY(lowerCamelCase__ )},
{'generated_token_ids': ANY(lowerCamelCase__ )},
],
] ,)
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = pipeline(task='text-generation' ,model='sshleifer/tiny-ctrl' ,framework='tf' )
# Using `do_sample=False` to force deterministic output
UpperCAmelCase__ = text_generator('This is a test' ,do_sample=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
{
'generated_text': (
'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
' please,'
)
}
] ,)
UpperCAmelCase__ = text_generator(['This is a test', 'This is a second test'] ,do_sample=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
[
{
'generated_text': (
'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
' please,'
)
}
],
[
{
'generated_text': (
'This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'
' Cannes 閲閲Cannes Cannes Cannes 攵 please,'
)
}
],
] ,)
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : int ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Dict ):
UpperCAmelCase__ = TextGenerationPipeline(model=lowerCamelCase__ ,tokenizer=lowerCamelCase__ )
return text_generator, ["This is a test", "Another test"]
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = 'Hello I believe in'
UpperCAmelCase__ = pipeline('text-generation' ,model='hf-internal-testing/tiny-random-gpt2' )
UpperCAmelCase__ = text_generator(lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}] ,)
UpperCAmelCase__ = text_generator(lowerCamelCase__ ,stop_sequence=' fe' )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': 'Hello I believe in fe'}] )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : List[str] ,lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = text_generator.model
UpperCAmelCase__ = text_generator.tokenizer
UpperCAmelCase__ = text_generator('This is a test' )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': ANY(lowerCamelCase__ )}] )
self.assertTrue(outputs[0]['generated_text'].startswith('This is a test' ) )
UpperCAmelCase__ = text_generator('This is a test' ,return_full_text=lowerCamelCase__ )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': ANY(lowerCamelCase__ )}] )
self.assertNotIn('This is a test' ,outputs[0]['generated_text'] )
UpperCAmelCase__ = pipeline(task='text-generation' ,model=lowerCamelCase__ ,tokenizer=lowerCamelCase__ ,return_full_text=lowerCamelCase__ )
UpperCAmelCase__ = text_generator('This is a test' )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': ANY(lowerCamelCase__ )}] )
self.assertNotIn('This is a test' ,outputs[0]['generated_text'] )
UpperCAmelCase__ = text_generator('This is a test' ,return_full_text=lowerCamelCase__ )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': ANY(lowerCamelCase__ )}] )
self.assertTrue(outputs[0]['generated_text'].startswith('This is a test' ) )
UpperCAmelCase__ = text_generator(['This is great !', 'Something else'] ,num_return_sequences=2 ,do_sample=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
[{'generated_text': ANY(lowerCamelCase__ )}, {'generated_text': ANY(lowerCamelCase__ )}],
[{'generated_text': ANY(lowerCamelCase__ )}, {'generated_text': ANY(lowerCamelCase__ )}],
] ,)
if text_generator.tokenizer.pad_token is not None:
UpperCAmelCase__ = text_generator(
['This is great !', 'Something else'] ,num_return_sequences=2 ,batch_size=2 ,do_sample=lowerCamelCase__ )
self.assertEqual(
lowerCamelCase__ ,[
[{'generated_text': ANY(lowerCamelCase__ )}, {'generated_text': ANY(lowerCamelCase__ )}],
[{'generated_text': ANY(lowerCamelCase__ )}, {'generated_text': ANY(lowerCamelCase__ )}],
] ,)
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = text_generator('test' ,return_full_text=lowerCamelCase__ ,return_text=lowerCamelCase__ )
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = text_generator('test' ,return_full_text=lowerCamelCase__ ,return_tensors=lowerCamelCase__ )
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = text_generator('test' ,return_text=lowerCamelCase__ ,return_tensors=lowerCamelCase__ )
# Empty prompt is slighly special
# it requires BOS token to exist.
# Special case for Pegasus which will always append EOS so will
# work even without BOS.
if (
text_generator.tokenizer.bos_token_id is not None
or "Pegasus" in tokenizer.__class__.__name__
or "Git" in model.__class__.__name__
):
UpperCAmelCase__ = text_generator('' )
self.assertEqual(lowerCamelCase__ ,[{'generated_text': ANY(lowerCamelCase__ )}] )
else:
with self.assertRaises((ValueError, AssertionError) ):
UpperCAmelCase__ = text_generator('' )
if text_generator.framework == "tf":
# TF generation does not support max_new_tokens, and it's impossible
# to control long generation with only max_length without
# fancy calculation, dismissing tests for now.
return
# We don't care about infinite range models.
# They already work.
# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
UpperCAmelCase__ = ['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
if (
tokenizer.model_max_length < 10_000
and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
):
# Handling of large generations
with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError) ):
text_generator('This is a test' * 500 ,max_new_tokens=20 )
UpperCAmelCase__ = text_generator('This is a test' * 500 ,handle_long_generation='hole' ,max_new_tokens=20 )
# Hole strategy cannot work
with self.assertRaises(lowerCamelCase__ ):
text_generator(
'This is a test' * 500 ,handle_long_generation='hole' ,max_new_tokens=tokenizer.model_max_length + 10 ,)
@require_torch
@require_accelerate
@require_torch_gpu
def __lowerCAmelCase ( self : List[Any] ):
import torch
# Classic `model_kwargs`
UpperCAmelCase__ = pipeline(
model='hf-internal-testing/tiny-random-bloom' ,model_kwargs={'device_map': 'auto', 'torch_dtype': torch.bfloataa} ,)
self.assertEqual(pipe.model.device ,torch.device(0 ) )
self.assertEqual(pipe.model.lm_head.weight.dtype ,torch.bfloataa )
UpperCAmelCase__ = pipe('This is a test' )
self.assertEqual(
lowerCamelCase__ ,[
{
'generated_text': (
'This is a test test test test test test test test test test test test test test test test'
' test'
)
}
] ,)
# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
UpperCAmelCase__ = pipeline(model='hf-internal-testing/tiny-random-bloom' ,device_map='auto' ,torch_dtype=torch.bfloataa )
self.assertEqual(pipe.model.device ,torch.device(0 ) )
self.assertEqual(pipe.model.lm_head.weight.dtype ,torch.bfloataa )
UpperCAmelCase__ = pipe('This is a test' )
self.assertEqual(
lowerCamelCase__ ,[
{
'generated_text': (
'This is a test test test test test test test test test test test test test test test test'
' test'
)
}
] ,)
# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
UpperCAmelCase__ = pipeline(model='hf-internal-testing/tiny-random-bloom' ,device_map='auto' )
self.assertEqual(pipe.model.device ,torch.device(0 ) )
self.assertEqual(pipe.model.lm_head.weight.dtype ,torch.floataa )
UpperCAmelCase__ = pipe('This is a test' )
self.assertEqual(
lowerCamelCase__ ,[
{
'generated_text': (
'This is a test test test test test test test test test test test test test test test test'
' test'
)
}
] ,)
@require_torch
@require_torch_gpu
def __lowerCAmelCase ( self : Tuple ):
import torch
UpperCAmelCase__ = pipeline(model='hf-internal-testing/tiny-random-bloom' ,device=0 ,torch_dtype=torch.floataa )
pipe('This is a test' )
@require_torch
@require_accelerate
@require_torch_gpu
def __lowerCAmelCase ( self : Union[str, Any] ):
import torch
UpperCAmelCase__ = pipeline(model='hf-internal-testing/tiny-random-bloom' ,device_map='auto' ,torch_dtype=torch.floataa )
pipe('This is a test' ,do_sample=lowerCamelCase__ ,top_p=0.5 )
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello world'
UpperCAmelCase__ = pipeline('text-generation' ,model='hf-internal-testing/tiny-random-gpt2' )
if text_generator.model.framework == "tf":
UpperCAmelCase__ = logging.get_logger('transformers.generation.tf_utils' )
else:
UpperCAmelCase__ = logging.get_logger('transformers.generation.utils' )
UpperCAmelCase__ = 'Both `max_new_tokens`' # The beggining of the message to be checked in this test
# Both are set by the user -> log warning
with CaptureLogger(lowerCamelCase__ ) as cl:
UpperCAmelCase__ = text_generator(lowerCamelCase__ ,max_length=10 ,max_new_tokens=1 )
self.assertIn(lowerCamelCase__ ,cl.out )
# The user only sets one -> no warning
with CaptureLogger(lowerCamelCase__ ) as cl:
UpperCAmelCase__ = text_generator(lowerCamelCase__ ,max_new_tokens=1 )
self.assertNotIn(lowerCamelCase__ ,cl.out )
with CaptureLogger(lowerCamelCase__ ) as cl:
UpperCAmelCase__ = text_generator(lowerCamelCase__ ,max_length=10 )
self.assertNotIn(lowerCamelCase__ ,cl.out )
| 632 | """simple docstring"""
import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple
import torch
from audiocraft.models import MusicGen
from transformers import (
AutoFeatureExtractor,
AutoTokenizer,
EncodecModel,
MusicgenDecoderConfig,
MusicgenForConditionalGeneration,
MusicgenProcessor,
TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging
logging.set_verbosity_info()
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[Any] = ['model.decoder.embed_positions.weights']
def a_ ( lowerCamelCase ):
if "emb" in name:
UpperCAmelCase__ = name.replace('emb' , 'model.decoder.embed_tokens' )
if "transformer" in name:
UpperCAmelCase__ = name.replace('transformer' , 'model.decoder' )
if "cross_attention" in name:
UpperCAmelCase__ = name.replace('cross_attention' , 'encoder_attn' )
if "linear1" in name:
UpperCAmelCase__ = name.replace('linear1' , 'fc1' )
if "linear2" in name:
UpperCAmelCase__ = name.replace('linear2' , 'fc2' )
if "norm1" in name:
UpperCAmelCase__ = name.replace('norm1' , 'self_attn_layer_norm' )
if "norm_cross" in name:
UpperCAmelCase__ = name.replace('norm_cross' , 'encoder_attn_layer_norm' )
if "norm2" in name:
UpperCAmelCase__ = name.replace('norm2' , 'final_layer_norm' )
if "out_norm" in name:
UpperCAmelCase__ = name.replace('out_norm' , 'model.decoder.layer_norm' )
if "linears" in name:
UpperCAmelCase__ = name.replace('linears' , 'lm_heads' )
if "condition_provider.conditioners.description.output_proj" in name:
UpperCAmelCase__ = name.replace('condition_provider.conditioners.description.output_proj' , 'enc_to_dec_proj' )
return name
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(state_dict.keys() )
UpperCAmelCase__ = {}
for key in keys:
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
UpperCAmelCase__ = rename_keys(lowerCamelCase )
if "in_proj_weight" in key:
# split fused qkv proj
UpperCAmelCase__ = val[:hidden_size, :]
UpperCAmelCase__ = val[hidden_size : 2 * hidden_size, :]
UpperCAmelCase__ = val[-hidden_size:, :]
elif "enc_to_dec_proj" in key:
UpperCAmelCase__ = val
else:
UpperCAmelCase__ = val
return state_dict, enc_dec_proj_state_dict
def a_ ( lowerCamelCase ):
if checkpoint == "small":
# default config values
UpperCAmelCase__ = 1_0_2_4
UpperCAmelCase__ = 2_4
UpperCAmelCase__ = 1_6
elif checkpoint == "medium":
UpperCAmelCase__ = 1_5_3_6
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 2_4
elif checkpoint == "large":
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 3_2
else:
raise ValueError(f'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' )
UpperCAmelCase__ = MusicgenDecoderConfig(
hidden_size=lowerCamelCase , ffn_dim=hidden_size * 4 , num_hidden_layers=lowerCamelCase , num_attention_heads=lowerCamelCase , )
return config
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase="cpu" ):
UpperCAmelCase__ = MusicGen.get_pretrained(lowerCamelCase , device=lowerCamelCase )
UpperCAmelCase__ = decoder_config_from_checkpoint(lowerCamelCase )
UpperCAmelCase__ = fairseq_model.lm.state_dict()
UpperCAmelCase__ , UpperCAmelCase__ = rename_state_dict(
lowerCamelCase , hidden_size=decoder_config.hidden_size )
UpperCAmelCase__ = TaEncoderModel.from_pretrained('t5-base' )
UpperCAmelCase__ = EncodecModel.from_pretrained('facebook/encodec_32khz' )
UpperCAmelCase__ = MusicgenForCausalLM(lowerCamelCase ).eval()
# load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
UpperCAmelCase__ , UpperCAmelCase__ = decoder.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
for key in missing_keys.copy():
if key.startswith(('text_encoder', 'audio_encoder') ) or key in EXPECTED_MISSING_KEYS:
missing_keys.remove(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Missing key(s) in state_dict: {missing_keys}''' )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Unexpected key(s) in state_dict: {unexpected_keys}''' )
# init the composite model
UpperCAmelCase__ = MusicgenForConditionalGeneration(text_encoder=lowerCamelCase , audio_encoder=lowerCamelCase , decoder=lowerCamelCase )
# load the pre-trained enc-dec projection (from the decoder state dict)
model.enc_to_dec_proj.load_state_dict(lowerCamelCase )
# check we can do a forward pass
UpperCAmelCase__ = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 )
UpperCAmelCase__ = input_ids.reshape(2 * 4 , -1 )
with torch.no_grad():
UpperCAmelCase__ = model(input_ids=lowerCamelCase , decoder_input_ids=lowerCamelCase ).logits
if logits.shape != (8, 1, 2_0_4_8):
raise ValueError('Incorrect shape for logits' )
# now construct the processor
UpperCAmelCase__ = AutoTokenizer.from_pretrained('t5-base' )
UpperCAmelCase__ = AutoFeatureExtractor.from_pretrained('facebook/encodec_32khz' , padding_side='left' )
UpperCAmelCase__ = MusicgenProcessor(feature_extractor=lowerCamelCase , tokenizer=lowerCamelCase )
# set the appropriate bos/pad token ids
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 2_0_4_8
# set other default generation config params
UpperCAmelCase__ = int(3_0 * audio_encoder.config.frame_rate )
UpperCAmelCase__ = True
UpperCAmelCase__ = 3.0
if pytorch_dump_folder is not None:
Path(lowerCamelCase ).mkdir(exist_ok=lowerCamelCase )
logger.info(f'''Saving model {checkpoint} to {pytorch_dump_folder}''' )
model.save_pretrained(lowerCamelCase )
processor.save_pretrained(lowerCamelCase )
if repo_id:
logger.info(f'''Pushing model {checkpoint} to {repo_id}''' )
model.push_to_hub(lowerCamelCase )
processor.push_to_hub(lowerCamelCase )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--checkpoint',
default='small',
type=str,
help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
)
parser.add_argument(
'--pytorch_dump_folder',
required=True,
default=None,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
)
parser.add_argument(
'--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
)
lowerCAmelCase__ : List[str] = parser.parse_args()
convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
| 632 | 1 |
"""simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | """simple docstring"""
lowerCAmelCase__ : Tuple = range(2, 20 + 1)
lowerCAmelCase__ : Optional[Any] = [10**k for k in range(ks[-1] + 1)]
lowerCAmelCase__ : dict[int, dict[int, list[list[int]]]] = {}
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = sum(a_i[j] for j in range(lowerCamelCase , len(lowerCamelCase ) ) )
UpperCAmelCase__ = sum(a_i[j] * base[j] for j in range(min(len(lowerCamelCase ) , lowerCamelCase ) ) )
UpperCAmelCase__ , UpperCAmelCase__ = 0, 0
UpperCAmelCase__ = n - i
UpperCAmelCase__ = memo.get(lowerCamelCase )
if sub_memo is not None:
UpperCAmelCase__ = sub_memo.get(lowerCamelCase )
if jumps is not None and len(lowerCamelCase ) > 0:
# find and make the largest jump without going over
UpperCAmelCase__ = -1
for _k in range(len(lowerCamelCase ) - 1 , -1 , -1 ):
if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
UpperCAmelCase__ = _k
break
if max_jump >= 0:
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = jumps[max_jump]
# since the difference between jumps is cached, add c
UpperCAmelCase__ = diff + c
for j in range(min(lowerCamelCase , len(lowerCamelCase ) ) ):
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
if new_c > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
else:
UpperCAmelCase__ = []
else:
UpperCAmelCase__ = {c: []}
UpperCAmelCase__ = sub_memo
if dn >= max_dn or c + diff >= base[k]:
return diff, dn
if k > ks[0]:
while True:
# keep doing smaller jumps
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , k - 1 , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
if dn >= max_dn or c + diff >= base[k]:
break
else:
# would be too small a jump, just compute sequential terms instead
UpperCAmelCase__ , UpperCAmelCase__ = compute(lowerCamelCase , lowerCamelCase , i + dn , lowerCamelCase )
diff += _diff
dn += terms_jumped
UpperCAmelCase__ = sub_memo[c]
# keep jumps sorted by # of terms skipped
UpperCAmelCase__ = 0
while j < len(lowerCamelCase ):
if jumps[j][1] > dn:
break
j += 1
# cache the jump for this value digitsum(b) and c
sub_memo[c].insert(lowerCamelCase , (diff, dn, k) )
return (diff, dn)
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase ):
if i >= n:
return 0, i
if k > len(lowerCamelCase ):
a_i.extend([0 for _ in range(k - len(lowerCamelCase ) )] )
# note: a_i -> b * 10^k + c
# ds_b -> digitsum(b)
# ds_c -> digitsum(c)
UpperCAmelCase__ = i
UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = 0, 0, 0
for j in range(len(lowerCamelCase ) ):
if j >= k:
ds_b += a_i[j]
else:
ds_c += a_i[j]
while i < n:
i += 1
UpperCAmelCase__ = ds_c + ds_b
diff += addend
UpperCAmelCase__ = 0
for j in range(lowerCamelCase ):
UpperCAmelCase__ = a_i[j] + addend
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
ds_c += a_i[j]
if addend > 0:
break
if addend > 0:
add(lowerCamelCase , lowerCamelCase , lowerCamelCase )
return diff, i - start_i
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
for j in range(lowerCamelCase , len(lowerCamelCase ) ):
UpperCAmelCase__ = digits[j] + addend
if s >= 1_0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
UpperCAmelCase__ = addend // 1_0 + quotient
else:
UpperCAmelCase__ = s
UpperCAmelCase__ = addend // 1_0
if addend == 0:
break
while addend > 0:
UpperCAmelCase__ , UpperCAmelCase__ = divmod(lowerCamelCase , 1_0 )
digits.append(lowerCamelCase )
def a_ ( lowerCamelCase = 1_0**1_5 ):
UpperCAmelCase__ = [1]
UpperCAmelCase__ = 1
UpperCAmelCase__ = 0
while True:
UpperCAmelCase__ , UpperCAmelCase__ = next_term(lowerCamelCase , 2_0 , i + dn , lowerCamelCase )
dn += terms_jumped
if dn == n - i:
break
UpperCAmelCase__ = 0
for j in range(len(lowerCamelCase ) ):
a_n += digits[j] * 1_0**j
return a_n
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import os
import sys
lowerCAmelCase__ : List[str] = os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)
from transformers import (
AutoConfig,
AutoModel,
AutoModelForCausalLM,
AutoModelForMaskedLM,
AutoModelForQuestionAnswering,
AutoModelForSequenceClassification,
AutoTokenizer,
add_start_docstrings,
)
lowerCAmelCase__ : Optional[int] = [
'torch',
'numpy',
'tokenizers',
'filelock',
'requests',
'tqdm',
'regex',
'sentencepiece',
'sacremoses',
'importlib_metadata',
'huggingface_hub',
]
@add_start_docstrings(AutoConfig.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoConfig.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoTokenizer.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoTokenizer.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoModel.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoModel.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoModelForCausalLM.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoModelForCausalLM.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoModelForMaskedLM.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoModelForMaskedLM.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoModelForSequenceClassification.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoModelForSequenceClassification.from_pretrained(*lowerCamelCase , **lowerCamelCase )
@add_start_docstrings(AutoModelForQuestionAnswering.__doc__ )
def a_ ( *lowerCamelCase , **lowerCamelCase ):
return AutoModelForQuestionAnswering.from_pretrained(*lowerCamelCase , **lowerCamelCase )
| 632 | """simple docstring"""
import random
class snake_case :
"""simple docstring"""
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : str ):
UpperCAmelCase__ = [ord(lowerCamelCase__ ) for i in text]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for i in plain:
UpperCAmelCase__ = random.randint(1 ,300 )
UpperCAmelCase__ = (i + k) * k
cipher.append(lowerCamelCase__ )
key.append(lowerCamelCase__ )
return cipher, key
@staticmethod
def __lowerCAmelCase ( lowerCamelCase__ : list[int] ,lowerCamelCase__ : list[int] ):
UpperCAmelCase__ = []
for i in range(len(lowerCamelCase__ ) ):
UpperCAmelCase__ = int((cipher[i] - (key[i]) ** 2) / key[i] )
plain.append(chr(lowerCamelCase__ ) )
return "".join(lowerCamelCase__ )
if __name__ == "__main__":
lowerCAmelCase__ , lowerCAmelCase__ : Dict = Onepad().encrypt('Hello')
print(c, k)
print(Onepad().decrypt(c, k))
| 632 | 1 |
"""simple docstring"""
import numpy as np
from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch
from .test_feature_extraction_common import FeatureExtractionSavingTestMixin
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = None
snake_case__ = None
@property
def __lowerCAmelCase ( self : str ):
return self.feat_extract_tester.prepare_feat_extract_dict()
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
self.assertTrue(hasattr(lowerCamelCase__ ,'feature_size' ) )
self.assertTrue(hasattr(lowerCamelCase__ ,'sampling_rate' ) )
self.assertTrue(hasattr(lowerCamelCase__ ,'padding_value' ) )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common()
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
self.assertTrue(all(len(lowerCamelCase__ ) == len(lowerCamelCase__ ) for x, y in zip(lowerCamelCase__ ,processed_features[input_name] ) ) )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase__ )
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} ,tensor_type='np' )
UpperCAmelCase__ = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
UpperCAmelCase__ = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
@require_torch
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase__ )
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} ,tensor_type='pt' )
UpperCAmelCase__ = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
UpperCAmelCase__ = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
@require_tf
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase__ )
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} ,tensor_type='tf' )
UpperCAmelCase__ = processed_features[input_name]
if len(batch_features_input.shape ) < 3:
UpperCAmelCase__ = batch_features_input[:, :, None]
self.assertTrue(
batch_features_input.shape
== (self.feat_extract_tester.batch_size, len(speech_inputs[0] ), self.feat_extract_tester.feature_size) )
def __lowerCAmelCase ( self : Tuple ,lowerCamelCase__ : Union[str, Any]=False ):
def _inputs_have_equal_length(lowerCamelCase__ : Tuple ):
UpperCAmelCase__ = len(input[0] )
for input_slice in input[1:]:
if len(lowerCamelCase__ ) != length:
return False
return True
def _inputs_are_equal(lowerCamelCase__ : Optional[Any] ,lowerCamelCase__ : Tuple ):
if len(lowerCamelCase__ ) != len(lowerCamelCase__ ):
return False
for input_slice_a, input_slice_a in zip(lowerCamelCase__ ,lowerCamelCase__ ):
if not np.allclose(np.asarray(lowerCamelCase__ ) ,np.asarray(lowerCamelCase__ ) ,atol=1e-3 ):
return False
return True
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase__ )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = self.feat_extract_tester.seq_length_diff
UpperCAmelCase__ = self.feat_extract_tester.max_seq_length + pad_diff
UpperCAmelCase__ = self.feat_extract_tester.min_seq_length
UpperCAmelCase__ = self.feat_extract_tester.batch_size
UpperCAmelCase__ = self.feat_extract_tester.feature_size
# test padding for List[int] + numpy
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding=lowerCamelCase__ )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[-1] ) )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )
UpperCAmelCase__ = input_a[input_name]
# max_length parameter has to be provided when setting `padding="max_length"`
with self.assertRaises(lowerCamelCase__ ):
feat_extract.pad(lowerCamelCase__ ,padding='max_length' )[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = input_a[input_name]
self.assertFalse(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(_inputs_are_equal(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(len(input_a[0] ) == pad_min_length )
self.assertTrue(len(input_a[1] ) == pad_min_length + pad_diff )
self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0] )) )
self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length) )
if feature_size > 1:
self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size )
# test padding for `pad_to_multiple_of` for List[int] + numpy
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,pad_to_multiple_of=10 )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,pad_to_multiple_of=10 )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,pad_to_multiple_of=10 ,max_length=lowerCamelCase__ )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,pad_to_multiple_of=10 ,max_length=lowerCamelCase__ ,return_tensors='np' ,)
UpperCAmelCase__ = input_a[input_name]
self.assertTrue(all(len(lowerCamelCase__ ) % 10 == 0 for x in input_a ) )
self.assertTrue(_inputs_are_equal(lowerCamelCase__ ,lowerCamelCase__ ) )
UpperCAmelCase__ = pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
self.assertTrue(all(len(lowerCamelCase__ ) == expected_mult_pad_length for x in input_a ) )
self.assertEqual(input_a.shape[:2] ,(batch_size, expected_mult_pad_length) )
if feature_size > 1:
self.assertTrue(input_a.shape[2] == feature_size )
# Check padding value is correct
UpperCAmelCase__ = (np.ones(self.feat_extract_tester.feature_size ) * feat_extract.padding_value).sum()
self.assertTrue(
abs(np.asarray(input_a[0] )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length) )
< 1e-3 )
self.assertTrue(
abs(
np.asarray(input_a[1] )[pad_min_length + pad_diff :].sum()
- padding_vector_sum * (pad_max_length - pad_min_length - pad_diff) )
< 1e-3 )
self.assertTrue(
abs(
np.asarray(input_a[2] )[pad_min_length + 2 * pad_diff :].sum()
- padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff) )
< 1e-3 )
self.assertTrue(
abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length) ) < 1e-3 )
self.assertTrue(
abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length) )
< 1e-3 )
def __lowerCAmelCase ( self : Dict ,lowerCamelCase__ : Dict=False ):
def _inputs_have_equal_length(lowerCamelCase__ : Optional[int] ):
UpperCAmelCase__ = len(input[0] )
for input_slice in input[1:]:
if len(lowerCamelCase__ ) != length:
return False
return True
def _inputs_are_equal(lowerCamelCase__ : Optional[int] ,lowerCamelCase__ : Tuple ):
if len(lowerCamelCase__ ) != len(lowerCamelCase__ ):
return False
for input_slice_a, input_slice_a in zip(lowerCamelCase__ ,lowerCamelCase__ ):
if not np.allclose(np.asarray(lowerCamelCase__ ) ,np.asarray(lowerCamelCase__ ) ,atol=1e-3 ):
return False
return True
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase__ )
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
# truncate to smallest
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) ,truncation=lowerCamelCase__ )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) )
UpperCAmelCase__ = input_a[input_name]
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertFalse(_inputs_have_equal_length(lowerCamelCase__ ) )
# truncate to smallest with np
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) ,return_tensors='np' ,truncation=lowerCamelCase__ ,)
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) ,return_tensors='np' )
UpperCAmelCase__ = input_a[input_name]
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(input_a.shape[1] == len(speech_inputs[0] ) )
# since truncation forces padding to be smaller than longest input
# function can't return `np.ndarray`, but has to return list
self.assertFalse(_inputs_have_equal_length(lowerCamelCase__ ) )
# truncate to middle
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[1] ) ,truncation=lowerCamelCase__ ,return_tensors='np' ,)
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[1] ) ,truncation=lowerCamelCase__ )
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[1] ) ,return_tensors='np' )
UpperCAmelCase__ = input_a[input_name]
self.assertTrue(input_a.shape[1] == len(speech_inputs[1] ) )
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(_inputs_are_equal(lowerCamelCase__ ,lowerCamelCase__ ) )
# since truncation forces padding to be smaller than longest input
# function can't return `np.ndarray`, but has to return list
self.assertFalse(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertTrue(len(input_a[-1] ) == len(speech_inputs[-1] ) )
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(lowerCamelCase__ ):
feat_extract.pad(lowerCamelCase__ ,truncation=lowerCamelCase__ )[input_name]
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(lowerCamelCase__ ):
feat_extract.pad(lowerCamelCase__ ,padding='longest' ,truncation=lowerCamelCase__ )[input_name]
# padding has to be max_length when setting `truncation=True`
with self.assertRaises(lowerCamelCase__ ):
feat_extract.pad(lowerCamelCase__ ,padding='longest' ,truncation=lowerCamelCase__ )[input_name]
# max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
with self.assertRaises(lowerCamelCase__ ):
feat_extract.pad(lowerCamelCase__ ,padding='max_length' ,truncation=lowerCamelCase__ )[input_name]
# test truncation for `pad_to_multiple_of` for List[int] + numpy
UpperCAmelCase__ = 12
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) ,pad_to_multiple_of=lowerCamelCase__ ,truncation=lowerCamelCase__ ,)
UpperCAmelCase__ = input_a[input_name]
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=len(speech_inputs[0] ) ,pad_to_multiple_of=lowerCamelCase__ ,)
UpperCAmelCase__ = input_a[input_name]
# retrieve expected_length as multiple of pad_to_multiple_of
UpperCAmelCase__ = len(speech_inputs[0] )
if expected_length % pad_to_multiple_of != 0:
UpperCAmelCase__ = ((len(speech_inputs[0] ) // pad_to_multiple_of) + 1) * pad_to_multiple_of
self.assertTrue(len(input_a[0] ) == expected_length )
self.assertTrue(_inputs_have_equal_length(lowerCamelCase__ ) )
self.assertFalse(_inputs_have_equal_length(lowerCamelCase__ ) )
def __lowerCAmelCase ( self : str ):
self._check_padding(numpify=lowerCamelCase__ )
def __lowerCAmelCase ( self : Any ):
self._check_padding(numpify=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
self._check_truncation(numpify=lowerCamelCase__ )
def __lowerCAmelCase ( self : Dict ):
self._check_truncation(numpify=lowerCamelCase__ )
@require_torch
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common()
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='pt' )[input_name]
self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_pt.numpy().astype(np.floataa ).sum() ) < 1e-2 )
@require_tf
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = self.feature_extraction_class(**self.feat_extract_dict )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common()
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )[input_name]
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='tf' )[input_name]
self.assertTrue(abs(input_np.astype(np.floataa ).sum() - input_tf.numpy().astype(np.floataa ).sum() ) < 1e-2 )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.feat_extract_dict
UpperCAmelCase__ = True
UpperCAmelCase__ = self.feature_extraction_class(**lowerCamelCase__ )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common()
UpperCAmelCase__ = [len(lowerCamelCase__ ) for x in speech_inputs]
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = feat_extract.pad(lowerCamelCase__ ,padding='longest' ,return_tensors='np' )
self.assertIn('attention_mask' ,lowerCamelCase__ )
self.assertListEqual(list(processed.attention_mask.shape ) ,list(processed[input_name].shape[:2] ) )
self.assertListEqual(processed.attention_mask.sum(-1 ).tolist() ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.feat_extract_dict
UpperCAmelCase__ = True
UpperCAmelCase__ = self.feature_extraction_class(**lowerCamelCase__ )
UpperCAmelCase__ = self.feat_extract_tester.prepare_inputs_for_common()
UpperCAmelCase__ = [len(lowerCamelCase__ ) for x in speech_inputs]
UpperCAmelCase__ = feat_extract.model_input_names[0]
UpperCAmelCase__ = BatchFeature({input_name: speech_inputs} )
UpperCAmelCase__ = min(lowerCamelCase__ )
UpperCAmelCase__ = feat_extract.pad(
lowerCamelCase__ ,padding='max_length' ,max_length=lowerCamelCase__ ,truncation=lowerCamelCase__ ,return_tensors='np' )
self.assertIn('attention_mask' ,lowerCamelCase__ )
self.assertListEqual(
list(processed_pad.attention_mask.shape ) ,[processed_pad[input_name].shape[0], max_length] )
self.assertListEqual(
processed_pad.attention_mask[:, :max_length].sum(-1 ).tolist() ,[max_length for x in speech_inputs] )
| 632 | """simple docstring"""
import re
def a_ ( lowerCamelCase ):
return [char.split() for char in re.split(r'[^ a-z A-Z 0-9 \s]' , str_ )]
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = split_input(str_ )
return "".join(
[''.join([char.capitalize() for char in sub_str] ) for sub_str in string_split] )
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ):
try:
UpperCAmelCase__ = split_input(lowerCamelCase )
if upper:
UpperCAmelCase__ = ''.join(
[
separator.join([char.upper() for char in sub_str] )
for sub_str in string_split
] )
else:
UpperCAmelCase__ = ''.join(
[
separator.join([char.lower() for char in sub_str] )
for sub_str in string_split
] )
return res_str
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase ):
return to_simple_case(lowerCamelCase )
def a_ ( lowerCamelCase ):
try:
UpperCAmelCase__ = to_simple_case(lowerCamelCase )
return res_str[0].lower() + res_str[1:]
except IndexError:
return "not valid string"
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '_' )
def a_ ( lowerCamelCase , lowerCamelCase ):
return to_complex_case(lowerCamelCase , lowerCamelCase , '-' )
if __name__ == "__main__":
__import__('doctest').testmod()
| 632 | 1 |
"""simple docstring"""
import os
import shutil
import tempfile
import unittest
import numpy as np
from transformers import AutoTokenizer, BarkProcessor
from transformers.testing_utils import require_torch, slow
@require_torch
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'ylacombe/bark-small'
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = 'en_speaker_1'
UpperCAmelCase__ = 'This is a test string'
UpperCAmelCase__ = 'speaker_embeddings_path.json'
UpperCAmelCase__ = 'speaker_embeddings'
def __lowerCAmelCase ( self : int ,**lowerCamelCase__ : str ):
return AutoTokenizer.from_pretrained(self.checkpoint ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.get_tokenizer()
UpperCAmelCase__ = BarkProcessor(tokenizer=lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = BarkProcessor.from_pretrained(self.tmpdirname )
self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer.get_vocab() )
@slow
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = BarkProcessor.from_pretrained(
pretrained_processor_name_or_path=self.checkpoint ,speaker_embeddings_dict_path=self.speaker_embeddings_dict_path ,)
processor.save_pretrained(
self.tmpdirname ,speaker_embeddings_dict_path=self.speaker_embeddings_dict_path ,speaker_embeddings_directory=self.speaker_embeddings_directory ,)
UpperCAmelCase__ = self.get_tokenizer(bos_token='(BOS)' ,eos_token='(EOS)' )
UpperCAmelCase__ = BarkProcessor.from_pretrained(
self.tmpdirname ,self.speaker_embeddings_dict_path ,bos_token='(BOS)' ,eos_token='(EOS)' ,)
self.assertEqual(processor.tokenizer.get_vocab() ,tokenizer_add_kwargs.get_vocab() )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = BarkProcessor.from_pretrained(
pretrained_processor_name_or_path=self.checkpoint ,speaker_embeddings_dict_path=self.speaker_embeddings_dict_path ,)
UpperCAmelCase__ = 35
UpperCAmelCase__ = 2
UpperCAmelCase__ = 8
UpperCAmelCase__ = {
'semantic_prompt': np.ones(lowerCamelCase__ ),
'coarse_prompt': np.ones((nb_codebooks_coarse, seq_len) ),
'fine_prompt': np.ones((nb_codebooks_total, seq_len) ),
}
# test providing already loaded voice_preset
UpperCAmelCase__ = processor(text=self.input_string ,voice_preset=lowerCamelCase__ )
UpperCAmelCase__ = inputs['history_prompt']
for key in voice_preset:
self.assertListEqual(voice_preset[key].tolist() ,processed_voice_preset.get(lowerCamelCase__ ,np.array([] ) ).tolist() )
# test loading voice preset from npz file
UpperCAmelCase__ = os.path.join(self.tmpdirname ,'file.npz' )
np.savez(lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = processor(text=self.input_string ,voice_preset=lowerCamelCase__ )
UpperCAmelCase__ = inputs['history_prompt']
for key in voice_preset:
self.assertListEqual(voice_preset[key].tolist() ,processed_voice_preset.get(lowerCamelCase__ ,np.array([] ) ).tolist() )
# test loading voice preset from the hub
UpperCAmelCase__ = processor(text=self.input_string ,voice_preset=self.voice_preset )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_tokenizer()
UpperCAmelCase__ = BarkProcessor(tokenizer=lowerCamelCase__ )
UpperCAmelCase__ = processor(text=self.input_string )
UpperCAmelCase__ = tokenizer(
self.input_string ,padding='max_length' ,max_length=256 ,add_special_tokens=lowerCamelCase__ ,return_attention_mask=lowerCamelCase__ ,return_token_type_ids=lowerCamelCase__ ,)
for key in encoded_tok.keys():
self.assertListEqual(encoded_tok[key] ,encoded_processor[key].squeeze().tolist() )
| 632 | """simple docstring"""
import shutil
import tempfile
import unittest
import numpy as np
from transformers.testing_utils import (
is_pt_tf_cross_test,
require_tf,
require_torch,
require_torchvision,
require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available
if is_vision_available():
from PIL import Image
from transformers import AutoProcessor, SamImageProcessor, SamProcessor
if is_torch_available():
import torch
if is_tf_available():
import tensorflow as tf
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Dict ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[int] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop original_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_torch
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [torch.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,torch.tensor(lowerCamelCase__ ) ,torch.tensor(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) )
@require_vision
@require_tf
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Union[str, Any] ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : List[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
def __lowerCAmelCase ( self : Optional[int] ):
UpperCAmelCase__ = SamProcessor(image_processor=self.get_image_processor() )
processor.save_pretrained(self.tmpdirname )
UpperCAmelCase__ = self.get_image_processor(do_normalize=lowerCamelCase__ ,padding_value=1.0 )
UpperCAmelCase__ = SamProcessor.from_pretrained(self.tmpdirname ,do_normalize=lowerCamelCase__ ,padding_value=1.0 )
self.assertEqual(processor.image_processor.to_json_string() ,image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor ,lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='np' )
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='np' )
input_feat_extract.pop('original_sizes' ) # pop original_sizes as it is popped in the processor
input_feat_extract.pop('reshaped_input_sizes' ) # pop reshaped_input_sizes as it is popped in the processor
for key in input_feat_extract.keys():
self.assertAlmostEqual(input_feat_extract[key].sum() ,input_processor[key].sum() ,delta=1e-2 )
@require_tf
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = [tf.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,tf.convert_to_tensor(lowerCamelCase__ ) ,tf.convert_to_tensor(lowerCamelCase__ ) ,return_tensors='tf' ,)
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
# should also work with np
UpperCAmelCase__ = [np.ones((1, 3, 5, 5) )]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
self.assertEqual(masks[0].shape ,(1, 3, 1_764, 2_646) )
UpperCAmelCase__ = [[1, 0], [0, 1]]
with self.assertRaises(tf.errors.InvalidArgumentError ):
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,np.array(lowerCamelCase__ ) ,np.array(lowerCamelCase__ ) ,return_tensors='tf' )
@require_vision
@require_torchvision
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = tempfile.mkdtemp()
UpperCAmelCase__ = SamImageProcessor()
UpperCAmelCase__ = SamProcessor(lowerCamelCase__ )
processor.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ,**lowerCamelCase__ : Any ):
return AutoProcessor.from_pretrained(self.tmpdirname ,**lowerCamelCase__ ).image_processor
def __lowerCAmelCase ( self : Optional[Any] ):
shutil.rmtree(self.tmpdirname )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = [np.random.randint(255 ,size=(3, 30, 400) ,dtype=np.uinta )]
UpperCAmelCase__ = [Image.fromarray(np.moveaxis(lowerCamelCase__ ,0 ,-1 ) ) for x in image_inputs]
return image_inputs
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : List[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = np.random.randint(0 ,2 ,size=(1, 3, 5, 5) ).astype(np.floataa )
UpperCAmelCase__ = [tf.convert_to_tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [torch.tensor(lowerCamelCase__ )]
UpperCAmelCase__ = [[1_764, 2_646]]
UpperCAmelCase__ = [[683, 1_024]]
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='tf' )
UpperCAmelCase__ = processor.post_process_masks(
lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,return_tensors='pt' )
self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy() ) )
@is_pt_tf_cross_test
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.get_image_processor()
UpperCAmelCase__ = SamProcessor(image_processor=lowerCamelCase__ )
UpperCAmelCase__ = self.prepare_image_inputs()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='pt' )['pixel_values'].numpy()
UpperCAmelCase__ = image_processor(lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
UpperCAmelCase__ = processor(images=lowerCamelCase__ ,return_tensors='tf' )['pixel_values'].numpy()
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
self.assertTrue(np.allclose(lowerCamelCase__ ,lowerCamelCase__ ) )
| 632 | 1 |
"""simple docstring"""
import tempfile
import torch
from diffusers import PNDMScheduler
from .test_schedulers import SchedulerCommonTest
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = (PNDMScheduler,)
snake_case__ = (("num_inference_steps", 50),)
def __lowerCAmelCase ( self : List[Any] ,**lowerCamelCase__ : List[Any] ):
UpperCAmelCase__ = {
'num_train_timesteps': 1_000,
'beta_start': 0.0_0_0_1,
'beta_end': 0.0_2,
'beta_schedule': 'linear',
}
config.update(**lowerCamelCase__ )
return config
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : List[str]=0 ,**lowerCamelCase__ : str ):
UpperCAmelCase__ = dict(self.forward_default_kwargs )
UpperCAmelCase__ = kwargs.pop('num_inference_steps' ,lowerCamelCase__ )
UpperCAmelCase__ = self.dummy_sample
UpperCAmelCase__ = 0.1 * sample
UpperCAmelCase__ = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]
for scheduler_class in self.scheduler_classes:
UpperCAmelCase__ = self.get_scheduler_config(**lowerCamelCase__ )
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
scheduler.set_timesteps(lowerCamelCase__ )
# copy over dummy past residuals
UpperCAmelCase__ = dummy_past_residuals[:]
with tempfile.TemporaryDirectory() as tmpdirname:
scheduler.save_config(lowerCamelCase__ )
UpperCAmelCase__ = scheduler_class.from_pretrained(lowerCamelCase__ )
new_scheduler.set_timesteps(lowerCamelCase__ )
# copy over dummy past residuals
UpperCAmelCase__ = dummy_past_residuals[:]
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = new_scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical"
UpperCAmelCase__ = scheduler.step_plms(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = new_scheduler.step_plms(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical"
def __lowerCAmelCase ( self : str ):
pass
def __lowerCAmelCase ( self : Optional[int] ,lowerCamelCase__ : int=0 ,**lowerCamelCase__ : List[Any] ):
UpperCAmelCase__ = dict(self.forward_default_kwargs )
UpperCAmelCase__ = kwargs.pop('num_inference_steps' ,lowerCamelCase__ )
UpperCAmelCase__ = self.dummy_sample
UpperCAmelCase__ = 0.1 * sample
UpperCAmelCase__ = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]
for scheduler_class in self.scheduler_classes:
UpperCAmelCase__ = self.get_scheduler_config()
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
scheduler.set_timesteps(lowerCamelCase__ )
# copy over dummy past residuals (must be after setting timesteps)
UpperCAmelCase__ = dummy_past_residuals[:]
with tempfile.TemporaryDirectory() as tmpdirname:
scheduler.save_config(lowerCamelCase__ )
UpperCAmelCase__ = scheduler_class.from_pretrained(lowerCamelCase__ )
# copy over dummy past residuals
new_scheduler.set_timesteps(lowerCamelCase__ )
# copy over dummy past residual (must be after setting timesteps)
UpperCAmelCase__ = dummy_past_residuals[:]
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = new_scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical"
UpperCAmelCase__ = scheduler.step_plms(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = new_scheduler.step_plms(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
assert torch.sum(torch.abs(output - new_output ) ) < 1e-5, "Scheduler outputs are not identical"
def __lowerCAmelCase ( self : str ,**lowerCamelCase__ : Any ):
UpperCAmelCase__ = self.scheduler_classes[0]
UpperCAmelCase__ = self.get_scheduler_config(**lowerCamelCase__ )
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
UpperCAmelCase__ = 10
UpperCAmelCase__ = self.dummy_model()
UpperCAmelCase__ = self.dummy_sample_deter
scheduler.set_timesteps(lowerCamelCase__ )
for i, t in enumerate(scheduler.prk_timesteps ):
UpperCAmelCase__ = model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ).prev_sample
for i, t in enumerate(scheduler.plms_timesteps ):
UpperCAmelCase__ = model(lowerCamelCase__ ,lowerCamelCase__ )
UpperCAmelCase__ = scheduler.step_plms(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ).prev_sample
return sample
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = dict(self.forward_default_kwargs )
UpperCAmelCase__ = kwargs.pop('num_inference_steps' ,lowerCamelCase__ )
for scheduler_class in self.scheduler_classes:
UpperCAmelCase__ = self.get_scheduler_config()
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
UpperCAmelCase__ = self.dummy_sample
UpperCAmelCase__ = 0.1 * sample
if num_inference_steps is not None and hasattr(lowerCamelCase__ ,'set_timesteps' ):
scheduler.set_timesteps(lowerCamelCase__ )
elif num_inference_steps is not None and not hasattr(lowerCamelCase__ ,'set_timesteps' ):
UpperCAmelCase__ = num_inference_steps
# copy over dummy past residuals (must be done after set_timesteps)
UpperCAmelCase__ = [residual + 0.2, residual + 0.1_5, residual + 0.1, residual + 0.0_5]
UpperCAmelCase__ = dummy_past_residuals[:]
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,0 ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,1 ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
self.assertEqual(output_a.shape ,sample.shape )
self.assertEqual(output_a.shape ,output_a.shape )
UpperCAmelCase__ = scheduler.step_plms(lowerCamelCase__ ,0 ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
UpperCAmelCase__ = scheduler.step_plms(lowerCamelCase__ ,1 ,lowerCamelCase__ ,**lowerCamelCase__ ).prev_sample
self.assertEqual(output_a.shape ,sample.shape )
self.assertEqual(output_a.shape ,output_a.shape )
def __lowerCAmelCase ( self : List[str] ):
for timesteps in [100, 1_000]:
self.check_over_configs(num_train_timesteps=lowerCamelCase__ )
def __lowerCAmelCase ( self : Dict ):
for steps_offset in [0, 1]:
self.check_over_configs(steps_offset=lowerCamelCase__ )
UpperCAmelCase__ = self.scheduler_classes[0]
UpperCAmelCase__ = self.get_scheduler_config(steps_offset=1 )
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
scheduler.set_timesteps(10 )
assert torch.equal(
scheduler.timesteps ,torch.LongTensor(
[901, 851, 851, 801, 801, 751, 751, 701, 701, 651, 651, 601, 601, 501, 401, 301, 201, 101, 1] ) ,)
def __lowerCAmelCase ( self : List[Any] ):
for beta_start, beta_end in zip([0.0_0_0_1, 0.0_0_1] ,[0.0_0_2, 0.0_2] ):
self.check_over_configs(beta_start=lowerCamelCase__ ,beta_end=lowerCamelCase__ )
def __lowerCAmelCase ( self : Tuple ):
for schedule in ["linear", "squaredcos_cap_v2"]:
self.check_over_configs(beta_schedule=lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ):
for prediction_type in ["epsilon", "v_prediction"]:
self.check_over_configs(prediction_type=lowerCamelCase__ )
def __lowerCAmelCase ( self : Optional[Any] ):
for t in [1, 5, 10]:
self.check_over_forward(time_step=lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ):
for t, num_inference_steps in zip([1, 5, 10] ,[10, 50, 100] ):
self.check_over_forward(num_inference_steps=lowerCamelCase__ )
def __lowerCAmelCase ( self : Dict ):
# earlier version of set_timesteps() caused an error indexing alpha's with inference steps as power of 3
UpperCAmelCase__ = 27
for scheduler_class in self.scheduler_classes:
UpperCAmelCase__ = self.dummy_sample
UpperCAmelCase__ = 0.1 * sample
UpperCAmelCase__ = self.get_scheduler_config()
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
scheduler.set_timesteps(lowerCamelCase__ )
# before power of 3 fix, would error on first step, so we only need to do two
for i, t in enumerate(scheduler.prk_timesteps[:2] ):
UpperCAmelCase__ = scheduler.step_prk(lowerCamelCase__ ,lowerCamelCase__ ,lowerCamelCase__ ).prev_sample
def __lowerCAmelCase ( self : Union[str, Any] ):
with self.assertRaises(lowerCamelCase__ ):
UpperCAmelCase__ = self.scheduler_classes[0]
UpperCAmelCase__ = self.get_scheduler_config()
UpperCAmelCase__ = scheduler_class(**lowerCamelCase__ )
scheduler.step_plms(self.dummy_sample ,1 ,self.dummy_sample ).prev_sample
def __lowerCAmelCase ( self : Any ):
UpperCAmelCase__ = self.full_loop()
UpperCAmelCase__ = torch.sum(torch.abs(lowerCamelCase__ ) )
UpperCAmelCase__ = torch.mean(torch.abs(lowerCamelCase__ ) )
assert abs(result_sum.item() - 1_9_8.1_3_1_8 ) < 1e-2
assert abs(result_mean.item() - 0.2_5_8_0 ) < 1e-3
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = self.full_loop(prediction_type='v_prediction' )
UpperCAmelCase__ = torch.sum(torch.abs(lowerCamelCase__ ) )
UpperCAmelCase__ = torch.mean(torch.abs(lowerCamelCase__ ) )
assert abs(result_sum.item() - 6_7.3_9_8_6 ) < 1e-2
assert abs(result_mean.item() - 0.0_8_7_8 ) < 1e-3
def __lowerCAmelCase ( self : int ):
# We specify different beta, so that the first alpha is 0.99
UpperCAmelCase__ = self.full_loop(set_alpha_to_one=lowerCamelCase__ ,beta_start=0.0_1 )
UpperCAmelCase__ = torch.sum(torch.abs(lowerCamelCase__ ) )
UpperCAmelCase__ = torch.mean(torch.abs(lowerCamelCase__ ) )
assert abs(result_sum.item() - 2_3_0.0_3_9_9 ) < 1e-2
assert abs(result_mean.item() - 0.2_9_9_5 ) < 1e-3
def __lowerCAmelCase ( self : Dict ):
# We specify different beta, so that the first alpha is 0.99
UpperCAmelCase__ = self.full_loop(set_alpha_to_one=lowerCamelCase__ ,beta_start=0.0_1 )
UpperCAmelCase__ = torch.sum(torch.abs(lowerCamelCase__ ) )
UpperCAmelCase__ = torch.mean(torch.abs(lowerCamelCase__ ) )
assert abs(result_sum.item() - 1_8_6.9_4_8_2 ) < 1e-2
assert abs(result_mean.item() - 0.2_4_3_4 ) < 1e-3
| 632 | """simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCAmelCase__ : Any = logging.get_logger(__name__)
lowerCAmelCase__ : str = {'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "ctrl"
snake_case__ = ["past_key_values"]
snake_case__ = {
"max_position_embeddings": "n_positions",
"hidden_size": "n_embd",
"num_attention_heads": "n_head",
"num_hidden_layers": "n_layer",
}
def __init__( self : Any ,lowerCamelCase__ : str=246_534 ,lowerCamelCase__ : List[str]=256 ,lowerCamelCase__ : Optional[int]=1_280 ,lowerCamelCase__ : Any=8_192 ,lowerCamelCase__ : int=48 ,lowerCamelCase__ : Optional[Any]=16 ,lowerCamelCase__ : Union[str, Any]=0.1 ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : List[str]=1e-6 ,lowerCamelCase__ : List[str]=0.0_2 ,lowerCamelCase__ : Tuple=True ,**lowerCamelCase__ : Optional[Any] ,):
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = n_positions
UpperCAmelCase__ = n_embd
UpperCAmelCase__ = n_layer
UpperCAmelCase__ = n_head
UpperCAmelCase__ = dff
UpperCAmelCase__ = resid_pdrop
UpperCAmelCase__ = embd_pdrop
UpperCAmelCase__ = layer_norm_epsilon
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = use_cache
super().__init__(**lowerCamelCase__ )
| 632 | 1 |
"""simple docstring"""
import unittest
import numpy as np
from diffusers import OnnxStableDiffusionInpaintPipelineLegacy
from diffusers.utils.testing_utils import (
is_onnx_available,
load_image,
load_numpy,
nightly,
require_onnxruntime,
require_torch_gpu,
)
if is_onnx_available():
import onnxruntime as ort
@nightly
@require_onnxruntime
@require_torch_gpu
class snake_case ( unittest.TestCase ):
"""simple docstring"""
@property
def __lowerCAmelCase ( self : Optional[int] ):
return (
"CUDAExecutionProvider",
{
"gpu_mem_limit": "15000000000", # 15GB
"arena_extend_strategy": "kSameAsRequested",
},
)
@property
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = ort.SessionOptions()
UpperCAmelCase__ = False
return options
def __lowerCAmelCase ( self : Tuple ):
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
'/in_paint/overture-creations-5sI6fQgYIuo.png' )
UpperCAmelCase__ = load_image(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
'/in_paint/overture-creations-5sI6fQgYIuo_mask.png' )
UpperCAmelCase__ = load_numpy(
'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
'/in_paint/red_cat_sitting_on_a_park_bench_onnx.npy' )
# using the PNDM scheduler by default
UpperCAmelCase__ = OnnxStableDiffusionInpaintPipelineLegacy.from_pretrained(
'CompVis/stable-diffusion-v1-4' ,revision='onnx' ,safety_checker=lowerCamelCase__ ,feature_extractor=lowerCamelCase__ ,provider=self.gpu_provider ,sess_options=self.gpu_options ,)
pipe.set_progress_bar_config(disable=lowerCamelCase__ )
UpperCAmelCase__ = 'A red cat sitting on a park bench'
UpperCAmelCase__ = np.random.RandomState(0 )
UpperCAmelCase__ = pipe(
prompt=lowerCamelCase__ ,image=lowerCamelCase__ ,mask_image=lowerCamelCase__ ,strength=0.7_5 ,guidance_scale=7.5 ,num_inference_steps=15 ,generator=lowerCamelCase__ ,output_type='np' ,)
UpperCAmelCase__ = output.images[0]
assert image.shape == (512, 512, 3)
assert np.abs(expected_image - image ).max() < 1e-2
| 632 | """simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import os
from accelerate.utils import ComputeEnvironment
from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401
from .sagemaker import get_sagemaker_input
lowerCAmelCase__ : Dict = 'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'
def a_ ( ):
UpperCAmelCase__ = _ask_options(
'In which compute environment are you running?' , ['This machine', 'AWS (Amazon SageMaker)'] , _convert_compute_environment , )
if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
UpperCAmelCase__ = get_sagemaker_input()
else:
UpperCAmelCase__ = get_cluster_input()
return config
def a_ ( lowerCamelCase=None ):
if subparsers is not None:
UpperCAmelCase__ = subparsers.add_parser('config' , description=lowerCamelCase )
else:
UpperCAmelCase__ = argparse.ArgumentParser('Accelerate config command' , description=lowerCamelCase )
parser.add_argument(
'--config_file' , default=lowerCamelCase , help=(
'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
'with \'huggingface\'.'
) , )
if subparsers is not None:
parser.set_defaults(func=lowerCamelCase )
return parser
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = get_user_input()
if args.config_file is not None:
UpperCAmelCase__ = args.config_file
else:
if not os.path.isdir(lowerCamelCase ):
os.makedirs(lowerCamelCase )
UpperCAmelCase__ = default_yaml_config_file
if config_file.endswith('.json' ):
config.to_json_file(lowerCamelCase )
else:
config.to_yaml_file(lowerCamelCase )
print(f'''accelerate configuration saved at {config_file}''' )
def a_ ( ):
UpperCAmelCase__ = config_command_parser()
UpperCAmelCase__ = parser.parse_args()
config_command(lowerCamelCase )
if __name__ == "__main__":
main()
| 632 | 1 |
"""simple docstring"""
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = current_set.copy()
for row_index, row in enumerate(lowerCamelCase ):
UpperCAmelCase__ = row[0]
for column_index, column in enumerate(lowerCamelCase ):
if magnitude == 0:
UpperCAmelCase__ = column
continue
UpperCAmelCase__ = column / magnitude
# Subtract to cancel term
UpperCAmelCase__ = current_set[0]
UpperCAmelCase__ = [first_row]
UpperCAmelCase__ = current_set[1::]
for row in current_set:
UpperCAmelCase__ = []
# If first term is 0, it is already in form we want, so we preserve it
if row[0] == 0:
final_set.append(lowerCamelCase )
continue
for column_index in range(len(lowerCamelCase ) ):
temp_row.append(first_row[column_index] - row[column_index] )
final_set.append(lowerCamelCase )
# Create next recursion iteration set
if len(final_set[0] ) != 3:
UpperCAmelCase__ = final_set[0]
UpperCAmelCase__ = []
UpperCAmelCase__ = []
for row in final_set[1::]:
current_first_column.append(row[0] )
next_iteration.append(row[1::] )
UpperCAmelCase__ = simplify(lowerCamelCase )
for i in range(len(lowerCamelCase ) ):
resultant[i].insert(0 , current_first_column[i] )
resultant.insert(0 , lowerCamelCase )
UpperCAmelCase__ = resultant
return final_set
def a_ ( lowerCamelCase ):
if len(lowerCamelCase ) == 0:
raise IndexError('solve_simultaneous() requires n lists of length n+1' )
UpperCAmelCase__ = len(lowerCamelCase ) + 1
if any(len(lowerCamelCase ) != _length for item in equations ):
raise IndexError('solve_simultaneous() requires n lists of length n+1' )
for row in equations:
if any(not isinstance(lowerCamelCase , (int, float) ) for column in row ):
raise ValueError('solve_simultaneous() requires lists of integers' )
if len(lowerCamelCase ) == 1:
return [equations[0][-1] / equations[0][0]]
UpperCAmelCase__ = equations.copy()
if any(0 in row for row in data_set ):
UpperCAmelCase__ = data_set.copy()
UpperCAmelCase__ = []
for row_index, row in enumerate(lowerCamelCase ):
if 0 not in row:
UpperCAmelCase__ = data_set.pop(lowerCamelCase )
break
if not full_row:
raise ValueError('solve_simultaneous() requires at least 1 full equation' )
data_set.insert(0 , lowerCamelCase )
UpperCAmelCase__ = data_set.copy()
UpperCAmelCase__ = simplify(lowerCamelCase )
UpperCAmelCase__ = simplified[::-1]
UpperCAmelCase__ = []
for row in simplified:
UpperCAmelCase__ = row[-1]
if not solutions:
if row[-2] == 0:
solutions.append(0 )
continue
solutions.append(current_solution / row[-2] )
continue
UpperCAmelCase__ = row.copy()[: len(lowerCamelCase ) - 1 :]
while temp_row[0] == 0:
temp_row.pop(0 )
if len(lowerCamelCase ) == 0:
solutions.append(0 )
continue
UpperCAmelCase__ = temp_row[1::]
UpperCAmelCase__ = temp_row[::-1]
for column_index, column in enumerate(lowerCamelCase ):
current_solution -= column * solutions[column_index]
solutions.append(lowerCamelCase )
UpperCAmelCase__ = []
for item in solutions:
final.append(float(round(lowerCamelCase , 5 ) ) )
return final[::-1]
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCAmelCase__ : Dict = [
[2, 1, 1, 1, 1, 4],
[1, 2, 1, 1, 1, 5],
[1, 1, 2, 1, 1, 6],
[1, 1, 1, 2, 1, 7],
[1, 1, 1, 1, 2, 8],
]
print(solve_simultaneous(eq))
print(solve_simultaneous([[4, 2]]))
| 632 | """simple docstring"""
def a_ ( lowerCamelCase , lowerCamelCase ):
return x if y == 0 else greatest_common_divisor(lowerCamelCase , x % y )
def a_ ( lowerCamelCase , lowerCamelCase ):
return (x * y) // greatest_common_divisor(lowerCamelCase , lowerCamelCase )
def a_ ( lowerCamelCase = 2_0 ):
UpperCAmelCase__ = 1
for i in range(1 , n + 1 ):
UpperCAmelCase__ = lcm(lowerCamelCase , lowerCamelCase )
return g
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import os
import unittest
from huggingface_hub.utils import are_progress_bars_disabled
import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar
class snake_case ( unittest.TestCase ):
"""simple docstring"""
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = logging.get_logger()
# the current default level is logging.WARNING
UpperCAmelCase__ = logging.get_verbosity()
logging.set_verbosity_error()
self.assertEqual(logger.getEffectiveLevel() ,logging.get_verbosity() )
logging.set_verbosity_warning()
self.assertEqual(logger.getEffectiveLevel() ,logging.get_verbosity() )
logging.set_verbosity_info()
self.assertEqual(logger.getEffectiveLevel() ,logging.get_verbosity() )
logging.set_verbosity_debug()
self.assertEqual(logger.getEffectiveLevel() ,logging.get_verbosity() )
# restore to the original level
logging.set_verbosity(lowerCamelCase__ )
def __lowerCAmelCase ( self : int ):
UpperCAmelCase__ = logging.get_verbosity()
UpperCAmelCase__ = logging.get_logger('transformers.models.bart.tokenization_bart' )
UpperCAmelCase__ = 'Testing 1, 2, 3'
# should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
if level_origin <= logging.WARNING:
with CaptureLogger(lowerCamelCase__ ) as cl:
logger.warning(lowerCamelCase__ )
self.assertEqual(cl.out ,msg + '\n' )
# this is setting the level for all of `transformers.*` loggers
logging.set_verbosity_error()
# should not be able to log warnings
with CaptureLogger(lowerCamelCase__ ) as cl:
logger.warning(lowerCamelCase__ )
self.assertEqual(cl.out ,'' )
# should be able to log warnings again
logging.set_verbosity_warning()
with CaptureLogger(lowerCamelCase__ ) as cl:
logger.warning(lowerCamelCase__ )
self.assertEqual(cl.out ,msg + '\n' )
# restore to the original level
logging.set_verbosity(lowerCamelCase__ )
@mockenv(TRANSFORMERS_VERBOSITY='error' )
def __lowerCAmelCase ( self : str ):
# reset for the env var to take effect, next time some logger call is made
transformers.utils.logging._reset_library_root_logger()
# this action activates the env var
UpperCAmelCase__ = logging.get_logger('transformers.models.bart.tokenization_bart' )
UpperCAmelCase__ = os.getenv('TRANSFORMERS_VERBOSITY' ,lowerCamelCase__ )
UpperCAmelCase__ = logging.log_levels[env_level_str]
UpperCAmelCase__ = logging.get_verbosity()
self.assertEqual(
lowerCamelCase__ ,lowerCamelCase__ ,f'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}''' ,)
# restore to the original level
UpperCAmelCase__ = ''
transformers.utils.logging._reset_library_root_logger()
@mockenv(TRANSFORMERS_VERBOSITY='super-error' )
def __lowerCAmelCase ( self : Any ):
# reset for the env var to take effect, next time some logger call is made
transformers.utils.logging._reset_library_root_logger()
UpperCAmelCase__ = logging.logging.getLogger()
with CaptureLogger(lowerCamelCase__ ) as cl:
# this action activates the env var
logging.get_logger('transformers.models.bart.tokenization_bart' )
self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error' ,cl.out )
# no need to restore as nothing was changed
def __lowerCAmelCase ( self : Optional[Any] ):
# testing `logger.warning_advice()`
transformers.utils.logging._reset_library_root_logger()
UpperCAmelCase__ = logging.get_logger('transformers.models.bart.tokenization_bart' )
UpperCAmelCase__ = 'Testing 1, 2, 3'
with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1' ):
# nothing should be logged as env var disables this method
with CaptureLogger(lowerCamelCase__ ) as cl:
logger.warning_advice(lowerCamelCase__ )
self.assertEqual(cl.out ,'' )
with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='' ):
# should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
with CaptureLogger(lowerCamelCase__ ) as cl:
logger.warning_advice(lowerCamelCase__ )
self.assertEqual(cl.out ,msg + '\n' )
def a_ ( ):
disable_progress_bar()
assert are_progress_bars_disabled()
enable_progress_bar()
assert not are_progress_bars_disabled()
| 632 | """simple docstring"""
import warnings
from functools import wraps
from typing import Callable
def a_ ( lowerCamelCase ):
@wraps(lowerCamelCase )
def _inner_fn(*lowerCamelCase , **lowerCamelCase ):
warnings.warn(
(f'''\'{fn.__name__}\' is experimental and might be subject to breaking changes in the future.''') , lowerCamelCase , )
return fn(*lowerCamelCase , **lowerCamelCase )
return _inner_fn
| 632 | 1 |
"""simple docstring"""
from typing import Dict, List, Optional, Union
import numpy as np
from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
center_crop,
convert_to_rgb,
get_resize_output_image_size,
normalize,
rescale,
resize,
to_channel_dimension_format,
)
from ...image_utils import (
OPENAI_CLIP_MEAN,
OPENAI_CLIP_STD,
ChannelDimension,
ImageInput,
PILImageResampling,
make_list_of_images,
to_numpy_array,
valid_images,
)
from ...utils import TensorType, is_vision_available, logging
lowerCAmelCase__ : Dict = logging.get_logger(__name__)
if is_vision_available():
import PIL
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = ["pixel_values"]
def __init__( self : int ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : PILImageResampling = PILImageResampling.BICUBIC ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Union[int, float] = 1 / 255 ,lowerCamelCase__ : bool = True ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : bool = True ,**lowerCamelCase__ : Any ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = size if size is not None else {'shortest_edge': 224}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ )
UpperCAmelCase__ = crop_size if crop_size is not None else {'height': 224, 'width': 224}
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ ,param_name='crop_size' )
UpperCAmelCase__ = do_resize
UpperCAmelCase__ = size
UpperCAmelCase__ = resample
UpperCAmelCase__ = do_center_crop
UpperCAmelCase__ = crop_size
UpperCAmelCase__ = do_rescale
UpperCAmelCase__ = rescale_factor
UpperCAmelCase__ = do_normalize
UpperCAmelCase__ = image_mean if image_mean is not None else OPENAI_CLIP_MEAN
UpperCAmelCase__ = image_std if image_std is not None else OPENAI_CLIP_STD
UpperCAmelCase__ = do_convert_rgb
def __lowerCAmelCase ( self : Optional[Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : PILImageResampling = PILImageResampling.BICUBIC ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : str ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,default_to_square=lowerCamelCase__ )
if "shortest_edge" not in size:
raise ValueError(f'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}''' )
UpperCAmelCase__ = get_resize_output_image_size(lowerCamelCase__ ,size=size['shortest_edge'] ,default_to_square=lowerCamelCase__ )
return resize(lowerCamelCase__ ,size=lowerCamelCase__ ,resample=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : str ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Dict[str, int] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Optional[int] ,):
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ )
if "height" not in size or "width" not in size:
raise ValueError(f'''The `size` parameter must contain the keys (height, width). Got {size.keys()}''' )
return center_crop(lowerCamelCase__ ,size=(size['height'], size['width']) ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : Union[str, Any] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Union[int, float] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : List[Any] ,):
return rescale(lowerCamelCase__ ,scale=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ,lowerCamelCase__ : np.ndarray ,lowerCamelCase__ : Union[float, List[float]] ,lowerCamelCase__ : Union[float, List[float]] ,lowerCamelCase__ : Optional[Union[str, ChannelDimension]] = None ,**lowerCamelCase__ : Optional[Any] ,):
return normalize(lowerCamelCase__ ,mean=lowerCamelCase__ ,std=lowerCamelCase__ ,data_format=lowerCamelCase__ ,**lowerCamelCase__ )
def __lowerCAmelCase ( self : List[Any] ,lowerCamelCase__ : ImageInput ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Dict[str, int] = None ,lowerCamelCase__ : PILImageResampling = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : int = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : float = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : Optional[Union[float, List[float]]] = None ,lowerCamelCase__ : bool = None ,lowerCamelCase__ : Optional[Union[str, TensorType]] = None ,lowerCamelCase__ : Optional[ChannelDimension] = ChannelDimension.FIRST ,**lowerCamelCase__ : Optional[int] ,):
UpperCAmelCase__ = do_resize if do_resize is not None else self.do_resize
UpperCAmelCase__ = size if size is not None else self.size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='size' ,default_to_square=lowerCamelCase__ )
UpperCAmelCase__ = resample if resample is not None else self.resample
UpperCAmelCase__ = do_center_crop if do_center_crop is not None else self.do_center_crop
UpperCAmelCase__ = crop_size if crop_size is not None else self.crop_size
UpperCAmelCase__ = get_size_dict(lowerCamelCase__ ,param_name='crop_size' ,default_to_square=lowerCamelCase__ )
UpperCAmelCase__ = do_rescale if do_rescale is not None else self.do_rescale
UpperCAmelCase__ = rescale_factor if rescale_factor is not None else self.rescale_factor
UpperCAmelCase__ = do_normalize if do_normalize is not None else self.do_normalize
UpperCAmelCase__ = image_mean if image_mean is not None else self.image_mean
UpperCAmelCase__ = image_std if image_std is not None else self.image_std
UpperCAmelCase__ = do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
UpperCAmelCase__ = make_list_of_images(lowerCamelCase__ )
if not valid_images(lowerCamelCase__ ):
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.' )
# PIL RGBA images are converted to RGB
if do_convert_rgb:
UpperCAmelCase__ = [convert_to_rgb(lowerCamelCase__ ) for image in images]
# All transformations expect numpy arrays.
UpperCAmelCase__ = [to_numpy_array(lowerCamelCase__ ) for image in images]
if do_resize:
UpperCAmelCase__ = [self.resize(image=lowerCamelCase__ ,size=lowerCamelCase__ ,resample=lowerCamelCase__ ) for image in images]
if do_center_crop:
UpperCAmelCase__ = [self.center_crop(image=lowerCamelCase__ ,size=lowerCamelCase__ ) for image in images]
if do_rescale:
UpperCAmelCase__ = [self.rescale(image=lowerCamelCase__ ,scale=lowerCamelCase__ ) for image in images]
if do_normalize:
UpperCAmelCase__ = [self.normalize(image=lowerCamelCase__ ,mean=lowerCamelCase__ ,std=lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = [to_channel_dimension_format(lowerCamelCase__ ,lowerCamelCase__ ) for image in images]
UpperCAmelCase__ = {'pixel_values': images}
return BatchFeature(data=lowerCamelCase__ ,tensor_type=lowerCamelCase__ )
| 632 | """simple docstring"""
from __future__ import annotations
import string
from itertools import cycle, product
from pathlib import Path
lowerCAmelCase__ : str = (
string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCAmelCase__ : list[int] = [ord(letter) for letter in string.ascii_lowercase]
lowerCAmelCase__ : set[int] = {ord(char) for char in VALID_CHARS}
lowerCAmelCase__ : list[str] = ["the", "be", "to", "of", "and", "in", "that", "have"]
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = ""
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
for keychar, cipherchar in zip(cycle(lowerCamelCase ) , lowerCamelCase ):
UpperCAmelCase__ = cipherchar ^ keychar
if decodedchar not in VALID_INTS:
return None
decoded += chr(lowerCamelCase )
return decoded
def a_ ( lowerCamelCase ):
UpperCAmelCase__ = []
for key in product(lowerCamelCase , repeat=3 ):
UpperCAmelCase__ = try_key(lowerCamelCase , lowerCamelCase )
if encoded is not None:
possibles.append(lowerCamelCase )
return possibles
def a_ ( lowerCamelCase , lowerCamelCase ):
return [possible for possible in possibles if common_word in possible.lower()]
def a_ ( lowerCamelCase = "p059_cipher.txt" ):
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = 42
UpperCAmelCase__ = Path(lowerCamelCase ).parent.joinpath(lowerCamelCase ).read_text(encoding='utf-8' )
UpperCAmelCase__ = [int(lowerCamelCase ) for number in data.strip().split(',' )]
UpperCAmelCase__ = filter_valid_chars(lowerCamelCase )
for common_word in COMMON_WORDS:
UpperCAmelCase__ = filter_common_word(lowerCamelCase , lowerCamelCase )
if len(lowerCamelCase ) == 1:
break
UpperCAmelCase__ = possibles[0]
return sum(ord(lowerCamelCase ) for char in decoded_text )
if __name__ == "__main__":
print(F"""{solution() = }""")
| 632 | 1 |
"""simple docstring"""
import argparse
from pathlib import Path
from typing import Dict, OrderedDict, Tuple
import torch
from audiocraft.models import MusicGen
from transformers import (
AutoFeatureExtractor,
AutoTokenizer,
EncodecModel,
MusicgenDecoderConfig,
MusicgenForConditionalGeneration,
MusicgenProcessor,
TaEncoderModel,
)
from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM
from transformers.utils import logging
logging.set_verbosity_info()
lowerCAmelCase__ : Optional[int] = logging.get_logger(__name__)
lowerCAmelCase__ : Optional[Any] = ['model.decoder.embed_positions.weights']
def a_ ( lowerCamelCase ):
if "emb" in name:
UpperCAmelCase__ = name.replace('emb' , 'model.decoder.embed_tokens' )
if "transformer" in name:
UpperCAmelCase__ = name.replace('transformer' , 'model.decoder' )
if "cross_attention" in name:
UpperCAmelCase__ = name.replace('cross_attention' , 'encoder_attn' )
if "linear1" in name:
UpperCAmelCase__ = name.replace('linear1' , 'fc1' )
if "linear2" in name:
UpperCAmelCase__ = name.replace('linear2' , 'fc2' )
if "norm1" in name:
UpperCAmelCase__ = name.replace('norm1' , 'self_attn_layer_norm' )
if "norm_cross" in name:
UpperCAmelCase__ = name.replace('norm_cross' , 'encoder_attn_layer_norm' )
if "norm2" in name:
UpperCAmelCase__ = name.replace('norm2' , 'final_layer_norm' )
if "out_norm" in name:
UpperCAmelCase__ = name.replace('out_norm' , 'model.decoder.layer_norm' )
if "linears" in name:
UpperCAmelCase__ = name.replace('linears' , 'lm_heads' )
if "condition_provider.conditioners.description.output_proj" in name:
UpperCAmelCase__ = name.replace('condition_provider.conditioners.description.output_proj' , 'enc_to_dec_proj' )
return name
def a_ ( lowerCamelCase , lowerCamelCase ):
UpperCAmelCase__ = list(state_dict.keys() )
UpperCAmelCase__ = {}
for key in keys:
UpperCAmelCase__ = state_dict.pop(lowerCamelCase )
UpperCAmelCase__ = rename_keys(lowerCamelCase )
if "in_proj_weight" in key:
# split fused qkv proj
UpperCAmelCase__ = val[:hidden_size, :]
UpperCAmelCase__ = val[hidden_size : 2 * hidden_size, :]
UpperCAmelCase__ = val[-hidden_size:, :]
elif "enc_to_dec_proj" in key:
UpperCAmelCase__ = val
else:
UpperCAmelCase__ = val
return state_dict, enc_dec_proj_state_dict
def a_ ( lowerCamelCase ):
if checkpoint == "small":
# default config values
UpperCAmelCase__ = 1_0_2_4
UpperCAmelCase__ = 2_4
UpperCAmelCase__ = 1_6
elif checkpoint == "medium":
UpperCAmelCase__ = 1_5_3_6
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 2_4
elif checkpoint == "large":
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 4_8
UpperCAmelCase__ = 3_2
else:
raise ValueError(f'''Checkpoint should be one of `[\'small\', \'medium\', \'large\']`, got {checkpoint}.''' )
UpperCAmelCase__ = MusicgenDecoderConfig(
hidden_size=lowerCamelCase , ffn_dim=hidden_size * 4 , num_hidden_layers=lowerCamelCase , num_attention_heads=lowerCamelCase , )
return config
@torch.no_grad()
def a_ ( lowerCamelCase , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase="cpu" ):
UpperCAmelCase__ = MusicGen.get_pretrained(lowerCamelCase , device=lowerCamelCase )
UpperCAmelCase__ = decoder_config_from_checkpoint(lowerCamelCase )
UpperCAmelCase__ = fairseq_model.lm.state_dict()
UpperCAmelCase__ , UpperCAmelCase__ = rename_state_dict(
lowerCamelCase , hidden_size=decoder_config.hidden_size )
UpperCAmelCase__ = TaEncoderModel.from_pretrained('t5-base' )
UpperCAmelCase__ = EncodecModel.from_pretrained('facebook/encodec_32khz' )
UpperCAmelCase__ = MusicgenForCausalLM(lowerCamelCase ).eval()
# load all decoder weights - expect that we'll be missing embeddings and enc-dec projection
UpperCAmelCase__ , UpperCAmelCase__ = decoder.load_state_dict(lowerCamelCase , strict=lowerCamelCase )
for key in missing_keys.copy():
if key.startswith(('text_encoder', 'audio_encoder') ) or key in EXPECTED_MISSING_KEYS:
missing_keys.remove(lowerCamelCase )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Missing key(s) in state_dict: {missing_keys}''' )
if len(lowerCamelCase ) > 0:
raise ValueError(f'''Unexpected key(s) in state_dict: {unexpected_keys}''' )
# init the composite model
UpperCAmelCase__ = MusicgenForConditionalGeneration(text_encoder=lowerCamelCase , audio_encoder=lowerCamelCase , decoder=lowerCamelCase )
# load the pre-trained enc-dec projection (from the decoder state dict)
model.enc_to_dec_proj.load_state_dict(lowerCamelCase )
# check we can do a forward pass
UpperCAmelCase__ = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 )
UpperCAmelCase__ = input_ids.reshape(2 * 4 , -1 )
with torch.no_grad():
UpperCAmelCase__ = model(input_ids=lowerCamelCase , decoder_input_ids=lowerCamelCase ).logits
if logits.shape != (8, 1, 2_0_4_8):
raise ValueError('Incorrect shape for logits' )
# now construct the processor
UpperCAmelCase__ = AutoTokenizer.from_pretrained('t5-base' )
UpperCAmelCase__ = AutoFeatureExtractor.from_pretrained('facebook/encodec_32khz' , padding_side='left' )
UpperCAmelCase__ = MusicgenProcessor(feature_extractor=lowerCamelCase , tokenizer=lowerCamelCase )
# set the appropriate bos/pad token ids
UpperCAmelCase__ = 2_0_4_8
UpperCAmelCase__ = 2_0_4_8
# set other default generation config params
UpperCAmelCase__ = int(3_0 * audio_encoder.config.frame_rate )
UpperCAmelCase__ = True
UpperCAmelCase__ = 3.0
if pytorch_dump_folder is not None:
Path(lowerCamelCase ).mkdir(exist_ok=lowerCamelCase )
logger.info(f'''Saving model {checkpoint} to {pytorch_dump_folder}''' )
model.save_pretrained(lowerCamelCase )
processor.save_pretrained(lowerCamelCase )
if repo_id:
logger.info(f'''Pushing model {checkpoint} to {repo_id}''' )
model.push_to_hub(lowerCamelCase )
processor.push_to_hub(lowerCamelCase )
if __name__ == "__main__":
lowerCAmelCase__ : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--checkpoint',
default='small',
type=str,
help='Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.',
)
parser.add_argument(
'--pytorch_dump_folder',
required=True,
default=None,
type=str,
help='Path to the output PyTorch model directory.',
)
parser.add_argument(
'--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
)
parser.add_argument(
'--device', default='cpu', type=str, help='Torch device to run the conversion, either cpu or cuda.'
)
lowerCAmelCase__ : List[str] = parser.parse_args()
convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
| 632 | """simple docstring"""
import unittest
from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property
from ...test_tokenization_common import TokenizerTesterMixin
lowerCAmelCase__ : Any = get_tests_dir('fixtures/test_sentencepiece.model')
@require_sentencepiece
class snake_case ( __UpperCAmelCase , unittest.TestCase ):
"""simple docstring"""
snake_case__ = XLMProphetNetTokenizer
snake_case__ = False
snake_case__ = True
def __lowerCAmelCase ( self : Any ):
super().setUp()
# We have a SentencePiece fixture for testing
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
tokenizer.save_pretrained(self.tmpdirname )
def __lowerCAmelCase ( self : Dict ):
UpperCAmelCase__ = '[PAD]'
UpperCAmelCase__ = 0
self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase__ ) ,lowerCamelCase__ )
self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase__ ) ,lowerCamelCase__ )
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = list(self.get_tokenizer().get_vocab().keys() )
self.assertEqual(vocab_keys[0] ,'[PAD]' )
self.assertEqual(vocab_keys[1] ,'[CLS]' )
self.assertEqual(vocab_keys[-1] ,'j' )
self.assertEqual(len(lowerCamelCase__ ) ,1_012 )
def __lowerCAmelCase ( self : List[Any] ):
self.assertEqual(self.get_tokenizer().vocab_size ,1_012 )
def __lowerCAmelCase ( self : str ):
UpperCAmelCase__ = XLMProphetNetTokenizer(lowerCamelCase__ ,keep_accents=lowerCamelCase__ )
UpperCAmelCase__ = tokenizer.tokenize('This is a test' )
self.assertListEqual(lowerCamelCase__ ,['▁This', '▁is', '▁a', '▁t', 'est'] )
self.assertListEqual(
tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]] ,)
UpperCAmelCase__ = 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',
'é',
'.',
] ,)
UpperCAmelCase__ = tokenizer.convert_tokens_to_ids(lowerCamelCase__ )
self.assertListEqual(
lowerCamelCase__ ,[
value + tokenizer.fairseq_offset
for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
] ,)
UpperCAmelCase__ = 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 __lowerCAmelCase ( self : Dict ):
return XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased' )
@slow
def __lowerCAmelCase ( self : Optional[Any] ):
UpperCAmelCase__ = 'Hello World!'
UpperCAmelCase__ = [35_389, 6_672, 49, 2]
self.assertListEqual(lowerCamelCase__ ,self.big_tokenizer.encode(lowerCamelCase__ ) )
@slow
def __lowerCAmelCase ( self : List[str] ):
# fmt: off
UpperCAmelCase__ = {'input_ids': [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501
# fmt: on
self.tokenizer_integration_test_util(
expected_encoding=lowerCamelCase__ ,model_name='microsoft/xprophetnet-large-wiki100-cased' ,revision='1acad1643ddd54a44df6a1b797ada8373685d90e' ,)
| 632 | 1 |
"""simple docstring"""
# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import warnings
from typing import List
from unittest.mock import Mock
import torch
from torch.utils.data import DataLoader, IterableDataset, TensorDataset
from accelerate.accelerator import Accelerator
from accelerate.utils.dataclasses import DistributedType
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
def __init__( self : int ,lowerCamelCase__ : int ):
UpperCAmelCase__ = data
def __iter__( self : Tuple ):
for element in self.data:
yield element
def a_ ( lowerCamelCase=True ):
UpperCAmelCase__ = Accelerator(even_batches=lowerCamelCase )
assert accelerator.num_processes == 2, "this script expects that two GPUs are available"
return accelerator
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase = False ):
if iterable:
UpperCAmelCase__ = DummyIterableDataset(torch.as_tensor(range(lowerCamelCase ) ) )
else:
UpperCAmelCase__ = TensorDataset(torch.as_tensor(range(lowerCamelCase ) ) )
UpperCAmelCase__ = DataLoader(lowerCamelCase , batch_size=lowerCamelCase )
UpperCAmelCase__ = accelerator.prepare(lowerCamelCase )
return dl
def a_ ( lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , lowerCamelCase , ):
UpperCAmelCase__ = create_dataloader(accelerator=lowerCamelCase , dataset_size=lowerCamelCase , batch_size=lowerCamelCase )
UpperCAmelCase__ = [len(batch[0] ) for batch in dl]
if accelerator.process_index == 0:
assert batch_sizes == process_0_expected_batch_sizes
elif accelerator.process_index == 1:
assert batch_sizes == process_1_expected_batch_sizes
def a_ ( ):
UpperCAmelCase__ = 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 a_ ( ):
UpperCAmelCase__ = 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 a_ ( ):
UpperCAmelCase__ = create_accelerator(even_batches=lowerCamelCase )
UpperCAmelCase__ = torch.nn.Linear(1 , 1 )
UpperCAmelCase__ = accelerator.prepare(lowerCamelCase )
UpperCAmelCase__ = create_dataloader(lowerCamelCase , dataset_size=3 , batch_size=1 )
UpperCAmelCase__ = []
with accelerator.join_uneven_inputs([ddp_model] ):
for batch_idx, batch in enumerate(lowerCamelCase ):
UpperCAmelCase__ = ddp_model(batch[0].float() )
UpperCAmelCase__ = 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 a_ ( lowerCamelCase ):
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 a_ ( ):
UpperCAmelCase__ = True
UpperCAmelCase__ = False
UpperCAmelCase__ = create_accelerator(even_batches=lowerCamelCase )
UpperCAmelCase__ = torch.nn.Linear(1 , 1 )
UpperCAmelCase__ = accelerator.prepare(lowerCamelCase )
UpperCAmelCase__ = create_dataloader(lowerCamelCase , dataset_size=3 , batch_size=1 )
UpperCAmelCase__ = create_dataloader(lowerCamelCase , dataset_size=3 , batch_size=1 )
with accelerator.join_uneven_inputs([ddp_model] , even_batches=lowerCamelCase ):
UpperCAmelCase__ = train_dl.batch_sampler.even_batches
UpperCAmelCase__ = valid_dl.batch_sampler.even_batches
assert train_dl_overridden_value == overridden_even_batches
assert valid_dl_overridden_value == overridden_even_batches
assert train_dl.batch_sampler.even_batches == default_even_batches
assert valid_dl.batch_sampler.even_batches == default_even_batches
def a_ ( ):
UpperCAmelCase__ = True
UpperCAmelCase__ = False
UpperCAmelCase__ = create_accelerator(even_batches=lowerCamelCase )
UpperCAmelCase__ = torch.nn.Linear(1 , 1 )
UpperCAmelCase__ = accelerator.prepare(lowerCamelCase )
create_dataloader(lowerCamelCase , dataset_size=3 , batch_size=1 , iterable=lowerCamelCase )
UpperCAmelCase__ = 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 ):
UpperCAmelCase__ = batch_dl.batch_sampler.even_batches
except AttributeError:
# ensure attribute error is not raised when processing iterable dl
raise AssertionError
assert batch_dl_overridden_value == overridden_even_batches
assert batch_dl.batch_sampler.even_batches == default_even_batches
def a_ ( ):
UpperCAmelCase__ = create_accelerator()
UpperCAmelCase__ = torch.nn.Linear(1 , 1 )
UpperCAmelCase__ = 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 a_ ( ):
UpperCAmelCase__ = create_accelerator()
accelerator.print('Test that even_batches variable ensures uniform batches across processes' )
test_default_ensures_even_batch_sizes()
accelerator.print('Run tests with even_batches disabled' )
test_can_disable_even_batches()
accelerator.print('Test joining uneven inputs' )
test_can_join_uneven_inputs()
accelerator.print('Test overriding even_batches when joining uneven inputs' )
test_join_can_override_even_batches()
accelerator.print('Test overriding even_batches for mixed dataloader types' )
test_join_can_override_for_mixed_type_dataloaders()
accelerator.print('Test overriding even_batches raises a warning for iterable dataloaders' )
test_join_raises_warning_for_iterable_when_overriding_even_batches()
accelerator.print('Test join with non DDP distributed raises warning' )
UpperCAmelCase__ = accelerator.state.distributed_type
UpperCAmelCase__ = DistributedType.FSDP
test_join_raises_warning_for_non_ddp_distributed(lowerCamelCase )
UpperCAmelCase__ = original_state
if __name__ == "__main__":
main()
| 632 | """simple docstring"""
from __future__ import annotations
import collections
import pprint
from pathlib import Path
def a_ ( lowerCamelCase ):
return "".join(sorted(lowerCamelCase ) )
def a_ ( lowerCamelCase ):
return word_by_signature[signature(lowerCamelCase )]
lowerCAmelCase__ : str = Path(__file__).parent.joinpath('words.txt').read_text(encoding='utf-8')
lowerCAmelCase__ : str = sorted({word.strip().lower() for word in data.splitlines()})
lowerCAmelCase__ : Optional[Any] = collections.defaultdict(list)
for word in word_list:
word_by_signature[signature(word)].append(word)
if __name__ == "__main__":
lowerCAmelCase__ : int = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
with open('anagrams.txt', 'w') as file:
file.write('all_anagrams = \n ')
file.write(pprint.pformat(all_anagrams))
| 632 | 1 |
"""simple docstring"""
import copy
import os
from typing import Union
from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING
lowerCAmelCase__ : str = logging.get_logger(__name__)
lowerCAmelCase__ : str = {
'Salesforce/instruct-blip-flan-t5': 'https://huggingface.co/Salesforce/instruct-blip-flan-t5/resolve/main/config.json',
}
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "instructblip_vision_model"
def __init__( self : List[str] ,lowerCamelCase__ : int=1_408 ,lowerCamelCase__ : Union[str, Any]=6_144 ,lowerCamelCase__ : int=39 ,lowerCamelCase__ : Union[str, Any]=16 ,lowerCamelCase__ : Dict=224 ,lowerCamelCase__ : str=14 ,lowerCamelCase__ : Optional[int]="gelu" ,lowerCamelCase__ : Union[str, Any]=1e-6 ,lowerCamelCase__ : List[str]=0.0 ,lowerCamelCase__ : Optional[int]=1e-10 ,lowerCamelCase__ : Dict=True ,**lowerCamelCase__ : Dict ,):
super().__init__(**lowerCamelCase__ )
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = patch_size
UpperCAmelCase__ = image_size
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = attention_dropout
UpperCAmelCase__ = layer_norm_eps
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = qkv_bias
@classmethod
def __lowerCAmelCase ( cls : Optional[Any] ,lowerCamelCase__ : Union[str, os.PathLike] ,**lowerCamelCase__ : List[Any] ):
cls._set_token_in_kwargs(lowerCamelCase__ )
UpperCAmelCase__ , UpperCAmelCase__ = cls.get_config_dict(lowerCamelCase__ ,**lowerCamelCase__ )
# get the vision config dict if we are loading from InstructBlipConfig
if config_dict.get('model_type' ) == "instructblip":
UpperCAmelCase__ = config_dict['vision_config']
if "model_type" in config_dict and hasattr(cls ,'model_type' ) and config_dict["model_type"] != cls.model_type:
logger.warning(
f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' )
return cls.from_dict(lowerCamelCase__ ,**lowerCamelCase__ )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "instructblip_qformer"
def __init__( self : List[str] ,lowerCamelCase__ : Tuple=30_522 ,lowerCamelCase__ : Union[str, Any]=768 ,lowerCamelCase__ : List[Any]=12 ,lowerCamelCase__ : Tuple=12 ,lowerCamelCase__ : int=3_072 ,lowerCamelCase__ : List[Any]="gelu" ,lowerCamelCase__ : Dict=0.1 ,lowerCamelCase__ : Optional[Any]=0.1 ,lowerCamelCase__ : str=512 ,lowerCamelCase__ : Tuple=0.0_2 ,lowerCamelCase__ : List[Any]=1e-12 ,lowerCamelCase__ : Tuple=0 ,lowerCamelCase__ : List[str]="absolute" ,lowerCamelCase__ : Any=2 ,lowerCamelCase__ : int=1_408 ,**lowerCamelCase__ : int ,):
super().__init__(pad_token_id=lowerCamelCase__ ,**lowerCamelCase__ )
UpperCAmelCase__ = vocab_size
UpperCAmelCase__ = hidden_size
UpperCAmelCase__ = num_hidden_layers
UpperCAmelCase__ = num_attention_heads
UpperCAmelCase__ = hidden_act
UpperCAmelCase__ = intermediate_size
UpperCAmelCase__ = hidden_dropout_prob
UpperCAmelCase__ = attention_probs_dropout_prob
UpperCAmelCase__ = max_position_embeddings
UpperCAmelCase__ = initializer_range
UpperCAmelCase__ = layer_norm_eps
UpperCAmelCase__ = position_embedding_type
UpperCAmelCase__ = cross_attention_frequency
UpperCAmelCase__ = encoder_hidden_size
@classmethod
def __lowerCAmelCase ( cls : Union[str, Any] ,lowerCamelCase__ : Union[str, os.PathLike] ,**lowerCamelCase__ : Union[str, Any] ):
cls._set_token_in_kwargs(lowerCamelCase__ )
UpperCAmelCase__ , UpperCAmelCase__ = cls.get_config_dict(lowerCamelCase__ ,**lowerCamelCase__ )
# get the qformer config dict if we are loading from InstructBlipConfig
if config_dict.get('model_type' ) == "instructblip":
UpperCAmelCase__ = config_dict['qformer_config']
if "model_type" in config_dict and hasattr(cls ,'model_type' ) and config_dict["model_type"] != cls.model_type:
logger.warning(
f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' )
return cls.from_dict(lowerCamelCase__ ,**lowerCamelCase__ )
class snake_case ( __UpperCAmelCase ):
"""simple docstring"""
snake_case__ = "instructblip"
snake_case__ = True
def __init__( self : int ,lowerCamelCase__ : str=None ,lowerCamelCase__ : Dict=None ,lowerCamelCase__ : Tuple=None ,lowerCamelCase__ : str=32 ,**lowerCamelCase__ : Tuple ):
super().__init__(**lowerCamelCase__ )
if vision_config is None:
UpperCAmelCase__ = {}
logger.info('vision_config is None. initializing the InstructBlipVisionConfig with default values.' )
if qformer_config is None:
UpperCAmelCase__ = {}
logger.info('qformer_config is None. Initializing the InstructBlipQFormerConfig with default values.' )
if text_config is None:
UpperCAmelCase__ = {}
logger.info('text_config is None. Initializing the text config with default values (`OPTConfig`).' )
UpperCAmelCase__ = InstructBlipVisionConfig(**lowerCamelCase__ )
UpperCAmelCase__ = InstructBlipQFormerConfig(**lowerCamelCase__ )
UpperCAmelCase__ = text_config['model_type'] if 'model_type' in text_config else 'opt'
UpperCAmelCase__ = CONFIG_MAPPING[text_model_type](**lowerCamelCase__ )
UpperCAmelCase__ = self.text_config.tie_word_embeddings
UpperCAmelCase__ = self.text_config.is_encoder_decoder
UpperCAmelCase__ = num_query_tokens
UpperCAmelCase__ = self.vision_config.hidden_size
UpperCAmelCase__ = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
UpperCAmelCase__ = 1.0
UpperCAmelCase__ = 0.0_2
@classmethod
def __lowerCAmelCase ( cls : Tuple ,lowerCamelCase__ : InstructBlipVisionConfig ,lowerCamelCase__ : InstructBlipQFormerConfig ,lowerCamelCase__ : PretrainedConfig ,**lowerCamelCase__ : int ,):
return cls(
vision_config=vision_config.to_dict() ,qformer_config=qformer_config.to_dict() ,text_config=text_config.to_dict() ,**lowerCamelCase__ ,)
def __lowerCAmelCase ( self : List[str] ):
UpperCAmelCase__ = copy.deepcopy(self.__dict__ )
UpperCAmelCase__ = self.vision_config.to_dict()
UpperCAmelCase__ = self.qformer_config.to_dict()
UpperCAmelCase__ = self.text_config.to_dict()
UpperCAmelCase__ = self.__class__.model_type
return output
| 632 | """simple docstring"""
import os
import sys
from contextlib import contextmanager
# Windows only
if os.name == "nt":
import ctypes
import msvcrt # noqa
class snake_case ( ctypes.Structure ):
"""simple docstring"""
snake_case__ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = False
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25l' )
sys.stdout.flush()
def a_ ( ):
if os.name == "nt":
UpperCAmelCase__ = CursorInfo()
UpperCAmelCase__ = ctypes.windll.kernelaa.GetStdHandle(-1_1 )
ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
UpperCAmelCase__ = True
ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase , ctypes.byref(lowerCamelCase ) )
elif os.name == "posix":
sys.stdout.write('\033[?25h' )
sys.stdout.flush()
@contextmanager
def a_ ( ):
try:
hide_cursor()
yield
finally:
show_cursor()
| 632 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.