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
|
|---|---|---|---|---|
import unittest
import numpy as np
from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available
from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
from transformers import DonutImageProcessor
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : Optional[int] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : str=7 ,lowerCAmelCase__ : List[str]=3 ,lowerCAmelCase__ : Any=18 ,lowerCAmelCase__ : Dict=30 ,lowerCAmelCase__ : Optional[int]=4_00 ,lowerCAmelCase__ : int=True ,lowerCAmelCase__ : Tuple=None ,lowerCAmelCase__ : Optional[Any]=True ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : Optional[Any]=True ,lowerCAmelCase__ : int=True ,lowerCAmelCase__ : Optional[int]=[0.5, 0.5, 0.5] ,lowerCAmelCase__ : List[str]=[0.5, 0.5, 0.5] ,) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = parent
lowerCAmelCase_ : List[Any] = batch_size
lowerCAmelCase_ : Optional[Any] = num_channels
lowerCAmelCase_ : List[Any] = image_size
lowerCAmelCase_ : List[str] = min_resolution
lowerCAmelCase_ : Optional[int] = max_resolution
lowerCAmelCase_ : Tuple = do_resize
lowerCAmelCase_ : Dict = size if size is not None else {"height": 18, "width": 20}
lowerCAmelCase_ : Dict = do_thumbnail
lowerCAmelCase_ : List[str] = do_align_axis
lowerCAmelCase_ : Union[str, Any] = do_pad
lowerCAmelCase_ : Union[str, Any] = do_normalize
lowerCAmelCase_ : str = image_mean
lowerCAmelCase_ : Union[str, Any] = image_std
def UpperCAmelCase_ ( self : Dict ) -> Dict:
'''simple docstring'''
return {
"do_resize": self.do_resize,
"size": self.size,
"do_thumbnail": self.do_thumbnail,
"do_align_long_axis": self.do_align_axis,
"do_pad": self.do_pad,
"do_normalize": self.do_normalize,
"image_mean": self.image_mean,
"image_std": self.image_std,
}
@require_torch
@require_vision
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = DonutImageProcessor if is_vision_available() else None
def UpperCAmelCase_ ( self : Optional[Any] ) -> int:
'''simple docstring'''
lowerCAmelCase_ : int = DonutImageProcessingTester(self )
@property
def UpperCAmelCase_ ( self : List[str] ) -> Tuple:
'''simple docstring'''
return self.image_processor_tester.prepare_image_processor_dict()
def UpperCAmelCase_ ( self : Optional[int] ) -> Union[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = self.image_processing_class(**self.image_processor_dict )
self.assertTrue(hasattr(lowerCAmelCase__ ,"do_resize" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"size" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"do_thumbnail" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"do_align_long_axis" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"do_pad" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"do_normalize" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"image_mean" ) )
self.assertTrue(hasattr(lowerCAmelCase__ ,"image_std" ) )
def UpperCAmelCase_ ( self : Optional[int] ) -> str:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = self.image_processing_class.from_dict(self.image_processor_dict )
self.assertEqual(image_processor.size ,{"height": 18, "width": 20} )
lowerCAmelCase_ : Dict = self.image_processing_class.from_dict(self.image_processor_dict ,size=42 )
self.assertEqual(image_processor.size ,{"height": 42, "width": 42} )
# Previous config had dimensions in (width, height) order
lowerCAmelCase_ : Union[str, Any] = self.image_processing_class.from_dict(self.image_processor_dict ,size=(42, 84) )
self.assertEqual(image_processor.size ,{"height": 84, "width": 42} )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Any:
'''simple docstring'''
pass
@is_flaky()
def UpperCAmelCase_ ( self : int ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = self.image_processing_class(**self.image_processor_dict )
# create random PIL images
lowerCAmelCase_ : Optional[Any] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowerCAmelCase__ )
for image in image_inputs:
self.assertIsInstance(lowerCAmelCase__ ,Image.Image )
# Test not batched input
lowerCAmelCase_ : Tuple = image_processing(image_inputs[0] ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
# Test batched
lowerCAmelCase_ : Optional[int] = image_processing(lowerCAmelCase__ ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
@is_flaky()
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : int = self.image_processing_class(**self.image_processor_dict )
# create random numpy tensors
lowerCAmelCase_ : Tuple = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowerCAmelCase__ ,numpify=lowerCAmelCase__ )
for image in image_inputs:
self.assertIsInstance(lowerCAmelCase__ ,np.ndarray )
# Test not batched input
lowerCAmelCase_ : Optional[Any] = image_processing(image_inputs[0] ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
# Test batched
lowerCAmelCase_ : str = image_processing(lowerCAmelCase__ ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
@is_flaky()
def UpperCAmelCase_ ( self : Optional[Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : int = self.image_processing_class(**self.image_processor_dict )
# create random PyTorch tensors
lowerCAmelCase_ : List[str] = prepare_image_inputs(self.image_processor_tester ,equal_resolution=lowerCAmelCase__ ,torchify=lowerCAmelCase__ )
for image in image_inputs:
self.assertIsInstance(lowerCAmelCase__ ,torch.Tensor )
# Test not batched input
lowerCAmelCase_ : Optional[int] = image_processing(image_inputs[0] ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
1,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
# Test batched
lowerCAmelCase_ : Tuple = image_processing(lowerCAmelCase__ ,return_tensors="pt" ).pixel_values
self.assertEqual(
encoded_images.shape ,(
self.image_processor_tester.batch_size,
self.image_processor_tester.num_channels,
self.image_processor_tester.size["height"],
self.image_processor_tester.size["width"],
) ,)
| 719 |
import copy
from typing import Any, Dict, List, Optional, Union
import numpy as np
import torch
from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = ['input_features', 'is_longer']
def __init__( self : Optional[int] ,lowerCAmelCase__ : List[Any]=64 ,lowerCAmelCase__ : Any=4_80_00 ,lowerCAmelCase__ : Optional[Any]=4_80 ,lowerCAmelCase__ : List[str]=10 ,lowerCAmelCase__ : List[Any]=10_24 ,lowerCAmelCase__ : Union[str, Any]=0.0 ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : float = 0 ,lowerCAmelCase__ : float = 1_40_00 ,lowerCAmelCase__ : int = None ,lowerCAmelCase__ : str = "fusion" ,lowerCAmelCase__ : str = "repeatpad" ,**lowerCAmelCase__ : Union[str, Any] ,) -> Union[str, Any]:
'''simple docstring'''
super().__init__(
feature_size=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,padding_value=lowerCAmelCase__ ,return_attention_mask=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : Optional[Any] = top_db
lowerCAmelCase_ : str = truncation
lowerCAmelCase_ : Tuple = padding
lowerCAmelCase_ : str = fft_window_size
lowerCAmelCase_ : Dict = (fft_window_size >> 1) + 1
lowerCAmelCase_ : Dict = hop_length
lowerCAmelCase_ : Any = max_length_s
lowerCAmelCase_ : int = max_length_s * sampling_rate
lowerCAmelCase_ : Optional[int] = sampling_rate
lowerCAmelCase_ : int = frequency_min
lowerCAmelCase_ : Optional[Any] = frequency_max
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm=lowerCAmelCase__ ,mel_scale="htk" ,)
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm="slaney" ,mel_scale="slaney" ,)
def UpperCAmelCase_ ( self : Dict ) -> Dict[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : int = copy.deepcopy(self.__dict__ )
lowerCAmelCase_ : Optional[int] = self.__class__.__name__
if "mel_filters" in output:
del output["mel_filters"]
if "mel_filters_slaney" in output:
del output["mel_filters_slaney"]
return output
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Optional[np.array] = None ) -> np.ndarray:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = spectrogram(
lowerCAmelCase__ ,window_function(self.fft_window_size ,"hann" ) ,frame_length=self.fft_window_size ,hop_length=self.hop_length ,power=2.0 ,mel_filters=lowerCAmelCase__ ,log_mel="dB" ,)
return log_mel_spectrogram.T
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Tuple = np.array_split(list(range(0 ,total_frames - chunk_frames + 1 ) ) ,3 )
if len(ranges[1] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
if len(ranges[2] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
# randomly choose index for each part
lowerCAmelCase_ : str = np.random.choice(ranges[0] )
lowerCAmelCase_ : Optional[Any] = np.random.choice(ranges[1] )
lowerCAmelCase_ : Any = np.random.choice(ranges[2] )
lowerCAmelCase_ : str = mel[idx_front : idx_front + chunk_frames, :]
lowerCAmelCase_ : Dict = mel[idx_middle : idx_middle + chunk_frames, :]
lowerCAmelCase_ : Optional[Any] = mel[idx_back : idx_back + chunk_frames, :]
lowerCAmelCase_ : List[str] = torch.tensor(mel[None, None, :] )
lowerCAmelCase_ : List[Any] = torch.nn.functional.interpolate(
lowerCAmelCase__ ,size=[chunk_frames, 64] ,mode="bilinear" ,align_corners=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = mel_shrink[0][0].numpy()
lowerCAmelCase_ : str = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,axis=0 )
return mel_fusion
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : int ) -> np.array:
'''simple docstring'''
if waveform.shape[0] > max_length:
if truncation == "rand_trunc":
lowerCAmelCase_ : List[Any] = True
# random crop to max_length (for compatibility) -> this should be handled by self.pad
lowerCAmelCase_ : str = len(lowerCAmelCase__ ) - max_length
lowerCAmelCase_ : Any = np.random.randint(0 ,overflow + 1 )
lowerCAmelCase_ : Dict = waveform[idx : idx + max_length]
lowerCAmelCase_ : List[str] = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
elif truncation == "fusion":
lowerCAmelCase_ : Tuple = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : str = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed
lowerCAmelCase_ : List[str] = mel.shape[0]
if chunk_frames == total_frames:
# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
# In this case, we just use the whole audio.
lowerCAmelCase_ : Dict = np.stack([mel, mel, mel, mel] ,axis=0 )
lowerCAmelCase_ : int = False
else:
lowerCAmelCase_ : str = self._random_mel_fusion(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = True
else:
raise NotImplementedError(f'''data_truncating {truncation} not implemented''' )
else:
lowerCAmelCase_ : Dict = False
# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
if waveform.shape[0] < max_length:
if padding == "repeat":
lowerCAmelCase_ : List[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : int = np.stack(np.tile(lowerCAmelCase__ ,n_repeat + 1 ) )[:max_length]
if padding == "repeatpad":
lowerCAmelCase_ : Optional[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = np.stack(np.tile(lowerCAmelCase__ ,lowerCAmelCase__ ) )
lowerCAmelCase_ : List[Any] = np.pad(lowerCAmelCase__ ,(0, max_length - waveform.shape[0]) ,mode="constant" ,constant_values=0 )
if truncation == "fusion":
lowerCAmelCase_ : int = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : Tuple = np.stack([input_mel, input_mel, input_mel, input_mel] ,axis=0 )
else:
lowerCAmelCase_ : str = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
return input_mel, longer
def __call__( self : int ,lowerCAmelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCAmelCase__ : str = None ,lowerCAmelCase__ : Optional[str] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[Union[str, TensorType]] = None ,**lowerCAmelCase__ : List[Any] ,) -> BatchFeature:
'''simple docstring'''
lowerCAmelCase_ : List[str] = truncation if truncation is not None else self.truncation
lowerCAmelCase_ : List[Any] = padding if padding else self.padding
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
f''' was sampled with {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." )
lowerCAmelCase_ : Dict = 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}''' )
lowerCAmelCase_ : Dict = is_batched_numpy or (
isinstance(lowerCAmelCase__ ,(list, tuple) ) and (isinstance(raw_speech[0] ,(np.ndarray, tuple, list) ))
)
if is_batched:
lowerCAmelCase_ : List[str] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for speech in raw_speech]
elif not is_batched and not isinstance(lowerCAmelCase__ ,np.ndarray ):
lowerCAmelCase_ : Tuple = np.asarray(lowerCAmelCase__ ,dtype=np.floataa )
elif isinstance(lowerCAmelCase__ ,np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ):
lowerCAmelCase_ : Any = raw_speech.astype(np.floataa )
# always return batch
if not is_batched:
lowerCAmelCase_ : Any = [np.asarray(lowerCAmelCase__ )]
# convert to mel spectrogram, truncate and pad if needed.
lowerCAmelCase_ : Optional[Any] = [
self._get_input_mel(lowerCAmelCase__ ,max_length if max_length else self.nb_max_samples ,lowerCAmelCase__ ,lowerCAmelCase__ )
for waveform in raw_speech
]
lowerCAmelCase_ : str = []
lowerCAmelCase_ : str = []
for mel, longer in padded_inputs:
input_mel.append(lowerCAmelCase__ )
is_longer.append(lowerCAmelCase__ )
if truncation == "fusion" and sum(lowerCAmelCase__ ) == 0:
# if no audio is longer than 10s, then randomly select one audio to be longer
lowerCAmelCase_ : Any = np.random.randint(0 ,len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Dict = True
if isinstance(input_mel[0] ,lowerCAmelCase__ ):
lowerCAmelCase_ : Optional[int] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for feature in input_mel]
# is_longer is a list of bool
lowerCAmelCase_ : List[Any] = [[longer] for longer in is_longer]
lowerCAmelCase_ : Optional[Any] = {"input_features": input_mel, "is_longer": is_longer}
lowerCAmelCase_ : Dict = BatchFeature(lowerCAmelCase__ )
if return_tensors is not None:
lowerCAmelCase_ : List[str] = input_features.convert_to_tensors(lowerCAmelCase__ )
return input_features
| 683 | 0 |
_lowercase : Tuple = '''
# Transformers installation
! pip install transformers datasets
# To install from source instead of the last release, comment the command above and uncomment the following one.
# ! pip install git+https://github.com/huggingface/transformers.git
'''
_lowercase : Any = [{'''type''': '''code''', '''content''': INSTALL_CONTENT}]
_lowercase : Dict = {
'''{processor_class}''': '''FakeProcessorClass''',
'''{model_class}''': '''FakeModelClass''',
'''{object_class}''': '''FakeObjectClass''',
}
| 720 |
from multiprocessing import Lock, Pipe, Process
# lock used to ensure that two processes do not access a pipe at the same time
_lowercase = Lock()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
global process_lock
# we perform n swaps since after n swaps we know we are sorted
# we *could* stop early if we are sorted already, but it takes as long to
# find out we are sorted as it does to sort the list with this algorithm
for i in range(0 , 10):
if (i + position) % 2 == 0 and r_send is not None:
# send your value to your right neighbor
process_lock.acquire()
r_send[1].send(snake_case__)
process_lock.release()
# receive your right neighbor's value
process_lock.acquire()
lowerCAmelCase_ : Optional[Any] = rr_cv[0].recv()
process_lock.release()
# take the lower value since you are on the left
lowerCAmelCase_ : Any = min(snake_case__ , snake_case__)
elif (i + position) % 2 != 0 and l_send is not None:
# send your value to your left neighbor
process_lock.acquire()
l_send[1].send(snake_case__)
process_lock.release()
# receive your left neighbor's value
process_lock.acquire()
lowerCAmelCase_ : str = lr_cv[0].recv()
process_lock.release()
# take the higher value since you are on the right
lowerCAmelCase_ : Dict = max(snake_case__ , snake_case__)
# after all swaps are performed, send the values back to main
result_pipe[1].send(snake_case__)
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Union[str, Any] = []
lowerCAmelCase_ : int = []
# initialize the list of pipes where the values will be retrieved
for _ in arr:
result_pipe.append(Pipe())
# creates the processes
# the first and last process only have one neighbor so they are made outside
# of the loop
lowerCAmelCase_ : Tuple = Pipe()
lowerCAmelCase_ : Optional[int] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) , ))
lowerCAmelCase_ : int = temp_rs
lowerCAmelCase_ : List[Any] = temp_rr
for i in range(1 , len(snake_case__) - 1):
lowerCAmelCase_ : Dict = Pipe()
lowerCAmelCase_ : List[str] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]) , ))
lowerCAmelCase_ : Dict = temp_rs
lowerCAmelCase_ : Optional[Any] = temp_rr
process_array_.append(
Process(
target=snake_case__ , args=(
len(snake_case__) - 1,
arr[len(snake_case__) - 1],
temp_ls,
None,
temp_lr,
None,
result_pipe[len(snake_case__) - 1],
) , ))
# start the processes
for p in process_array_:
p.start()
# wait for the processes to end and write their values to the list
for p in range(0 , len(snake_case__)):
lowerCAmelCase_ : Union[str, Any] = result_pipe[p][0].recv()
process_array_[p].join()
return arr
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = list(range(10 , 0 , -1))
print("Initial List")
print(*snake_case__)
lowerCAmelCase_ : Tuple = odd_even_transposition(snake_case__)
print("Sorted List\n")
print(*snake_case__)
if __name__ == "__main__":
main()
| 683 | 0 |
import warnings
from ...utils import logging
from .image_processing_poolformer import PoolFormerImageProcessor
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
def __init__( self : str ,*lowerCAmelCase__ : Optional[int] ,**lowerCAmelCase__ : Any ) -> None:
'''simple docstring'''
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__ )
| 721 |
from typing import Any
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validation(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
# Creates data structures and fill initial step
lowerCAmelCase_ : dict = {}
lowerCAmelCase_ : dict = {}
for state in states_space:
lowerCAmelCase_ : List[Any] = observations_space[0]
lowerCAmelCase_ : int = (
initial_probabilities[state] * emission_probabilities[state][observation]
)
lowerCAmelCase_ : Dict = None
# Fills the data structure with the probabilities of
# different transitions and pointers to previous states
for o in range(1 , len(snake_case__)):
lowerCAmelCase_ : List[Any] = observations_space[o]
lowerCAmelCase_ : Optional[Any] = observations_space[o - 1]
for state in states_space:
# Calculates the argmax for probability function
lowerCAmelCase_ : List[Any] = ""
lowerCAmelCase_ : Tuple = -1
for k_state in states_space:
lowerCAmelCase_ : int = (
probabilities[(k_state, prior_observation)]
* transition_probabilities[k_state][state]
* emission_probabilities[state][observation]
)
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Optional[Any] = k_state
# Update probabilities and pointers dicts
lowerCAmelCase_ : Union[str, Any] = (
probabilities[(arg_max, prior_observation)]
* transition_probabilities[arg_max][state]
* emission_probabilities[state][observation]
)
lowerCAmelCase_ : Any = arg_max
# The final observation
lowerCAmelCase_ : List[Any] = observations_space[len(snake_case__) - 1]
# argmax for given final observation
lowerCAmelCase_ : List[str] = ""
lowerCAmelCase_ : List[str] = -1
for k_state in states_space:
lowerCAmelCase_ : List[str] = probabilities[(k_state, final_observation)]
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Tuple = k_state
lowerCAmelCase_ : str = arg_max
# Process pointers backwards
lowerCAmelCase_ : int = last_state
lowerCAmelCase_ : int = []
for o in range(len(snake_case__) - 1 , -1 , -1):
result.append(snake_case__)
lowerCAmelCase_ : Optional[Any] = pointers[previous, observations_space[o]]
result.reverse()
return result
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validate_not_empty(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
_validate_lists(snake_case__ , snake_case__)
_validate_dicts(
snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
if not all(
[
observations_space,
states_space,
initial_probabilities,
transition_probabilities,
emission_probabilities,
]):
raise ValueError("There's an empty parameter")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_list(snake_case__ , "observations_space")
_validate_list(snake_case__ , "states_space")
def UpperCamelCase ( snake_case__ , snake_case__):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list'''
raise ValueError(snake_case__)
else:
for x in _object:
if not isinstance(snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list of strings'''
raise ValueError(snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , ):
_validate_dict(snake_case__ , "initial_probabilities" , snake_case__)
_validate_nested_dict(snake_case__ , "transition_probabilities")
_validate_nested_dict(snake_case__ , "emission_probabilities")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_dict(_object , snake_case__ , snake_case__)
for x in _object.values():
_validate_dict(snake_case__ , snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ = False):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : List[str] = F'''{var_name} must be a dict'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object):
lowerCAmelCase_ : Dict = F'''{var_name} all keys must be strings'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object.values()):
lowerCAmelCase_ : Union[str, Any] = "nested dictionary " if nested else ""
lowerCAmelCase_ : Any = F'''{var_name} {nested_text}all values must be {value_type.__name__}'''
raise ValueError(snake_case__)
if __name__ == "__main__":
from doctest import testmod
testmod()
| 683 | 0 |
import argparse
import logging
import sys
from unittest.mock import patch
import run_glue_deebert
from transformers.testing_utils import TestCasePlus, get_gpu_count, require_torch_non_multi_gpu, slow
logging.basicConfig(level=logging.DEBUG)
_lowercase = logging.getLogger()
def UpperCamelCase ( ):
lowerCAmelCase_ : Any = argparse.ArgumentParser()
parser.add_argument("-f")
lowerCAmelCase_ : List[Any] = parser.parse_args()
return args.f
class __snake_case ( snake_case__ ):
"""simple docstring"""
def UpperCAmelCase_ ( self : Optional[Any] ) -> None:
'''simple docstring'''
lowerCAmelCase_ : Dict = logging.StreamHandler(sys.stdout )
logger.addHandler(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Tuple ) -> Union[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = get_gpu_count()
if n_gpu > 1:
pass
# XXX: doesn't quite work with n_gpu > 1 https://github.com/huggingface/transformers/issues/10560
# script = f"{self.examples_dir_str}/research_projects/deebert/run_glue_deebert.py"
# distributed_args = f"-m torch.distributed.launch --nproc_per_node={n_gpu} {script}".split()
# cmd = [sys.executable] + distributed_args + args
# execute_subprocess_async(cmd, env=self.get_env())
# XXX: test the results - need to save them first into .json file
else:
args.insert(0 ,"run_glue_deebert.py" )
with patch.object(lowerCAmelCase__ ,"argv" ,lowerCAmelCase__ ):
lowerCAmelCase_ : List[str] = run_glue_deebert.main()
for value in result.values():
self.assertGreaterEqual(lowerCAmelCase__ ,0.666 )
@slow
@require_torch_non_multi_gpu
def UpperCAmelCase_ ( self : Optional[Any] ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = "\n --model_type roberta\n --model_name_or_path roberta-base\n --task_name MRPC\n --do_train\n --do_eval\n --do_lower_case\n --data_dir ./tests/fixtures/tests_samples/MRPC/\n --max_seq_length 128\n --per_gpu_eval_batch_size=1\n --per_gpu_train_batch_size=8\n --learning_rate 2e-4\n --num_train_epochs 3\n --overwrite_output_dir\n --seed 42\n --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage\n --plot_data_dir ./examples/deebert/results/\n --save_steps 0\n --overwrite_cache\n --eval_after_first_stage\n ".split()
self.run_and_check(lowerCAmelCase__ )
lowerCAmelCase_ : Dict = "\n --model_type roberta\n --model_name_or_path ./examples/deebert/saved_models/roberta-base/MRPC/two_stage\n --task_name MRPC\n --do_eval\n --do_lower_case\n --data_dir ./tests/fixtures/tests_samples/MRPC/\n --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage\n --plot_data_dir ./examples/deebert/results/\n --max_seq_length 128\n --eval_each_highway\n --eval_highway\n --overwrite_cache\n --per_gpu_eval_batch_size=1\n ".split()
self.run_and_check(lowerCAmelCase__ )
lowerCAmelCase_ : Dict = "\n --model_type roberta\n --model_name_or_path ./examples/deebert/saved_models/roberta-base/MRPC/two_stage\n --task_name MRPC\n --do_eval\n --do_lower_case\n --data_dir ./tests/fixtures/tests_samples/MRPC/\n --output_dir ./examples/deebert/saved_models/roberta-base/MRPC/two_stage\n --plot_data_dir ./examples/deebert/results/\n --max_seq_length 128\n --early_exit_entropy 0.1\n --eval_highway\n --overwrite_cache\n --per_gpu_eval_batch_size=1\n ".split()
self.run_and_check(lowerCAmelCase__ )
| 700 |
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch
from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool
if is_datasets_available():
from datasets import load_dataset
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'microsoft/speecht5_tts'
UpperCamelCase_ = (
'This is a tool that reads an English text out loud. It takes an input named `text` which should contain the '
'text to read (in English) and returns a waveform object containing the sound.'
)
UpperCamelCase_ = 'text_reader'
UpperCamelCase_ = SpeechTaProcessor
UpperCamelCase_ = SpeechTaForTextToSpeech
UpperCamelCase_ = SpeechTaHifiGan
UpperCamelCase_ = ['text']
UpperCamelCase_ = ['audio']
def UpperCAmelCase_ ( self : Dict ) -> Any:
'''simple docstring'''
if self.post_processor is None:
lowerCAmelCase_ : Any = "microsoft/speecht5_hifigan"
super().setup()
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Optional[int]=None ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Any = self.pre_processor(text=lowerCAmelCase__ ,return_tensors="pt" ,truncation=lowerCAmelCase__ )
if speaker_embeddings is None:
if not is_datasets_available():
raise ImportError("Datasets needs to be installed if not passing speaker embeddings." )
lowerCAmelCase_ : str = load_dataset("Matthijs/cmu-arctic-xvectors" ,split="validation" )
lowerCAmelCase_ : List[Any] = torch.tensor(embeddings_dataset[73_05]["xvector"] ).unsqueeze(0 )
return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Union[str, Any] ) -> Union[str, Any]:
'''simple docstring'''
with torch.no_grad():
return self.model.generate_speech(**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : str ) -> Any:
'''simple docstring'''
with torch.no_grad():
return self.post_processor(lowerCAmelCase__ ).cpu().detach()
| 683 | 0 |
from __future__ import annotations
import math
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = u
for i in range(1 , snake_case__):
lowerCAmelCase_ : Tuple = temp * (u - i)
return temp
def UpperCamelCase ( ):
lowerCAmelCase_ : Dict = int(input("enter the numbers of values: "))
lowerCAmelCase_ : list[list[float]] = []
for _ in range(snake_case__):
y.append([])
for i in range(snake_case__):
for j in range(snake_case__):
y[i].append(snake_case__)
lowerCAmelCase_ : int = 0
print("enter the values of parameters in a list: ")
lowerCAmelCase_ : Tuple = list(map(snake_case__ , input().split()))
print("enter the values of corresponding parameters: ")
for i in range(snake_case__):
lowerCAmelCase_ : int = float(input())
lowerCAmelCase_ : Tuple = int(input("enter the value to interpolate: "))
lowerCAmelCase_ : Tuple = (value - x[0]) / (x[1] - x[0])
# for calculating forward difference table
for i in range(1 , snake_case__):
for j in range(n - i):
lowerCAmelCase_ : List[str] = y[j + 1][i - 1] - y[j][i - 1]
lowerCAmelCase_ : List[Any] = y[0][0]
for i in range(1 , snake_case__):
summ += (ucal(snake_case__ , snake_case__) * y[0][i]) / math.factorial(snake_case__)
print(F'''the value at {value} is {summ}''')
if __name__ == "__main__":
main()
| 701 |
import argparse
import collections
import json
import os
import re
import string
import sys
import numpy as np
_lowercase = re.compile(r'''\b(a|an|the)\b''', re.UNICODE)
_lowercase = None
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = argparse.ArgumentParser("Official evaluation script for SQuAD version 2.0.")
parser.add_argument("data_file" , metavar="data.json" , help="Input data JSON file.")
parser.add_argument("pred_file" , metavar="pred.json" , help="Model predictions.")
parser.add_argument(
"--out-file" , "-o" , metavar="eval.json" , help="Write accuracy metrics to file (default is stdout).")
parser.add_argument(
"--na-prob-file" , "-n" , metavar="na_prob.json" , help="Model estimates of probability of no answer.")
parser.add_argument(
"--na-prob-thresh" , "-t" , type=snake_case__ , default=1.0 , help="Predict \"\" if no-answer probability exceeds this (default = 1.0)." , )
parser.add_argument(
"--out-image-dir" , "-p" , metavar="out_images" , default=snake_case__ , help="Save precision-recall curves to directory.")
parser.add_argument("--verbose" , "-v" , action="store_true")
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
return parser.parse_args()
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : str = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : Dict = bool(qa["answers"]["text"])
return qid_to_has_ans
def UpperCamelCase ( snake_case__):
def remove_articles(snake_case__):
return ARTICLES_REGEX.sub(" " , snake_case__)
def white_space_fix(snake_case__):
return " ".join(text.split())
def remove_punc(snake_case__):
lowerCAmelCase_ : Optional[int] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(snake_case__):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(snake_case__))))
def UpperCamelCase ( snake_case__):
if not s:
return []
return normalize_answer(snake_case__).split()
def UpperCamelCase ( snake_case__ , snake_case__):
return int(normalize_answer(snake_case__) == normalize_answer(snake_case__))
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = get_tokens(snake_case__)
lowerCAmelCase_ : Union[str, Any] = get_tokens(snake_case__)
lowerCAmelCase_ : Any = collections.Counter(snake_case__) & collections.Counter(snake_case__)
lowerCAmelCase_ : Dict = sum(common.values())
if len(snake_case__) == 0 or len(snake_case__) == 0:
# If either is no-answer, then F1 is 1 if they agree, 0 otherwise
return int(gold_toks == pred_toks)
if num_same == 0:
return 0
lowerCAmelCase_ : List[Any] = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : int = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : List[Any] = (2 * precision * recall) / (precision + recall)
return fa
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Tuple = {}
lowerCAmelCase_ : int = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : int = qa["id"]
lowerCAmelCase_ : Any = [t for t in qa["answers"]["text"] if normalize_answer(snake_case__)]
if not gold_answers:
# For unanswerable questions, only correct answer is empty string
lowerCAmelCase_ : Any = [""]
if qid not in preds:
print(F'''Missing prediction for {qid}''')
continue
lowerCAmelCase_ : Tuple = preds[qid]
# Take max over all gold answers
lowerCAmelCase_ : Any = max(compute_exact(snake_case__ , snake_case__) for a in gold_answers)
lowerCAmelCase_ : Optional[Any] = max(compute_fa(snake_case__ , snake_case__) for a in gold_answers)
return exact_scores, fa_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = {}
for qid, s in scores.items():
lowerCAmelCase_ : List[Any] = na_probs[qid] > na_prob_thresh
if pred_na:
lowerCAmelCase_ : List[str] = float(not qid_to_has_ans[qid])
else:
lowerCAmelCase_ : Union[str, Any] = s
return new_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None):
if not qid_list:
lowerCAmelCase_ : Any = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores.values()) / total),
("f1", 100.0 * sum(fa_scores.values()) / total),
("total", total),
])
else:
lowerCAmelCase_ : Tuple = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores[k] for k in qid_list) / total),
("f1", 100.0 * sum(fa_scores[k] for k in qid_list) / total),
("total", total),
])
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
for k in new_eval:
lowerCAmelCase_ : Union[str, Any] = new_eval[k]
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
plt.step(snake_case__ , snake_case__ , color="b" , alpha=0.2 , where="post")
plt.fill_between(snake_case__ , snake_case__ , step="post" , alpha=0.2 , color="b")
plt.xlabel("Recall")
plt.ylabel("Precision")
plt.xlim([0.0, 1.05])
plt.ylim([0.0, 1.05])
plt.title(snake_case__)
plt.savefig(snake_case__)
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__=None , snake_case__=None):
lowerCAmelCase_ : List[Any] = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
lowerCAmelCase_ : Dict = 0.0
lowerCAmelCase_ : int = 1.0
lowerCAmelCase_ : List[str] = 0.0
lowerCAmelCase_ : Tuple = [1.0]
lowerCAmelCase_ : Tuple = [0.0]
lowerCAmelCase_ : Dict = 0.0
for i, qid in enumerate(snake_case__):
if qid_to_has_ans[qid]:
true_pos += scores[qid]
lowerCAmelCase_ : str = true_pos / float(i + 1)
lowerCAmelCase_ : Union[str, Any] = true_pos / float(snake_case__)
if i == len(snake_case__) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]:
# i.e., if we can put a threshold after this point
avg_prec += cur_p * (cur_r - recalls[-1])
precisions.append(snake_case__)
recalls.append(snake_case__)
if out_image:
plot_pr_curve(snake_case__ , snake_case__ , snake_case__ , snake_case__)
return {"ap": 100.0 * avg_prec}
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
if out_image_dir and not os.path.exists(snake_case__):
os.makedirs(snake_case__)
lowerCAmelCase_ : Any = sum(1 for v in qid_to_has_ans.values() if v)
if num_true_pos == 0:
return
lowerCAmelCase_ : Any = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_exact.png") , title="Precision-Recall curve for Exact Match score" , )
lowerCAmelCase_ : Dict = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_f1.png") , title="Precision-Recall curve for F1 score" , )
lowerCAmelCase_ : Dict = {k: float(snake_case__) for k, v in qid_to_has_ans.items()}
lowerCAmelCase_ : str = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_oracle.png") , title="Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)" , )
merge_eval(snake_case__ , snake_case__ , "pr_exact")
merge_eval(snake_case__ , snake_case__ , "pr_f1")
merge_eval(snake_case__ , snake_case__ , "pr_oracle")
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
if not qid_list:
return
lowerCAmelCase_ : Optional[Any] = [na_probs[k] for k in qid_list]
lowerCAmelCase_ : Dict = np.ones_like(snake_case__) / float(len(snake_case__))
plt.hist(snake_case__ , weights=snake_case__ , bins=20 , range=(0.0, 1.0))
plt.xlabel("Model probability of no-answer")
plt.ylabel("Proportion of dataset")
plt.title(F'''Histogram of no-answer probability: {name}''')
plt.savefig(os.path.join(snake_case__ , F'''na_prob_hist_{name}.png'''))
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = sum(1 for k in qid_to_has_ans if not qid_to_has_ans[k])
lowerCAmelCase_ : str = num_no_ans
lowerCAmelCase_ : List[str] = cur_score
lowerCAmelCase_ : List[Any] = 0.0
lowerCAmelCase_ : str = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
for i, qid in enumerate(snake_case__):
if qid not in scores:
continue
if qid_to_has_ans[qid]:
lowerCAmelCase_ : Union[str, Any] = scores[qid]
else:
if preds[qid]:
lowerCAmelCase_ : List[Any] = -1
else:
lowerCAmelCase_ : List[str] = 0
cur_score += diff
if cur_score > best_score:
lowerCAmelCase_ : Optional[Any] = cur_score
lowerCAmelCase_ : Optional[int] = na_probs[qid]
return 100.0 * best_score / len(snake_case__), best_thresh
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ , lowerCAmelCase_ : Optional[int] = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ , lowerCAmelCase_ : Dict = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = best_exact
lowerCAmelCase_ : List[str] = exact_thresh
lowerCAmelCase_ : Any = best_fa
lowerCAmelCase_ : List[str] = fa_thresh
def UpperCamelCase ( ):
with open(OPTS.data_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
lowerCAmelCase_ : List[Any] = dataset_json["data"]
with open(OPTS.pred_file) as f:
lowerCAmelCase_ : int = json.load(snake_case__)
if OPTS.na_prob_file:
with open(OPTS.na_prob_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
else:
lowerCAmelCase_ : List[Any] = {k: 0.0 for k in preds}
lowerCAmelCase_ : Tuple = make_qid_to_has_ans(snake_case__) # maps qid to True/False
lowerCAmelCase_ : Any = [k for k, v in qid_to_has_ans.items() if v]
lowerCAmelCase_ : List[str] = [k for k, v in qid_to_has_ans.items() if not v]
lowerCAmelCase_ , lowerCAmelCase_ : Dict = get_raw_scores(snake_case__ , snake_case__)
lowerCAmelCase_ : str = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Dict = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__)
if has_ans_qids:
lowerCAmelCase_ : str = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "HasAns")
if no_ans_qids:
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "NoAns")
if OPTS.na_prob_file:
find_all_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__)
if OPTS.na_prob_file and OPTS.out_image_dir:
run_precision_recall_analysis(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , OPTS.out_image_dir)
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "hasAns")
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "noAns")
if OPTS.out_file:
with open(OPTS.out_file , "w") as f:
json.dump(snake_case__ , snake_case__)
else:
print(json.dumps(snake_case__ , indent=2))
if __name__ == "__main__":
_lowercase = parse_args()
if OPTS.out_image_dir:
import matplotlib
matplotlib.use('''Agg''')
import matplotlib.pyplot as plt
main()
| 683 | 0 |
import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple
import numpy as np
from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging
if TYPE_CHECKING:
from transformers.pipelines.conversational import Conversation
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.txt''', '''emoji_file''': '''emoji.json'''}
_lowercase = {
'''vocab_file''': {
'''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt''',
},
'''emoji_file''': {
'''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json''',
},
}
_lowercase = {
'''abeja/gpt-neox-japanese-2.7b''': 2048,
}
def UpperCamelCase ( snake_case__ , snake_case__):
with open(snake_case__ , "r" , encoding="utf-8") as f:
lowerCAmelCase_ : Dict = json.loads(f.read())
lowerCAmelCase_ : Tuple = collections.OrderedDict()
lowerCAmelCase_ : Optional[int] = collections.OrderedDict()
lowerCAmelCase_ : List[str] = collections.OrderedDict()
with open(snake_case__ , "r" , encoding="utf-8") as f:
lowerCAmelCase_ : int = f.readlines()
lowerCAmelCase_ : List[str] = [[t.rstrip("\n")] if (t == "," or "," not in t) else t.rstrip("\n").split(",") for t in token]
for idx, b in enumerate(snake_case__):
lowerCAmelCase_ : Optional[int] = b
lowerCAmelCase_ : List[Any] = idx
for wd in b:
lowerCAmelCase_ : Dict = idx
return vocab, raw_vocab, ids_to_tokens, emoji
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = ['input_ids', 'attention_mask']
def __init__( self : List[str] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Tuple ,lowerCAmelCase__ : List[str]="<|endoftext|>" ,lowerCAmelCase__ : Optional[Any]="<|endoftext|>" ,lowerCAmelCase__ : List[Any]="<|startoftext|>" ,lowerCAmelCase__ : Optional[Any]="<|endoftext|>" ,lowerCAmelCase__ : Any=False ,**lowerCAmelCase__ : Union[str, Any] ,) -> List[Any]:
'''simple docstring'''
super().__init__(
unk_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,do_clean_text=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
if not os.path.isfile(lowerCAmelCase__ ):
raise ValueError(
f'''Can\'t find a vocabulary file at path \'{vocab_file}\'. To load the vocabulary from a Google pretrained'''
" model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`" )
if not os.path.isfile(lowerCAmelCase__ ):
raise ValueError(
f'''Can\'t find a emoji file at path \'{emoji_file}\'. To load the emoji information from a Google'''
" pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`" )
lowerCAmelCase_ : Optional[int] = do_clean_text
lowerCAmelCase_ : Optional[int] = load_vocab_and_emoji(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = SubWordJapaneseTokenizer(
vocab=self.vocab ,ids_to_tokens=self.ids_to_tokens ,emoji=self.emoji )
@property
def UpperCAmelCase_ ( self : Optional[int] ) -> str:
'''simple docstring'''
return len(self.raw_vocab )
def UpperCAmelCase_ ( self : Dict ) -> Dict:
'''simple docstring'''
return dict(self.raw_vocab ,**self.added_tokens_encoder )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Any ) -> Any:
'''simple docstring'''
return self.subword_tokenizer.tokenize(lowerCAmelCase__ ,clean=self.do_clean_text )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Any ) -> Union[str, Any]:
'''simple docstring'''
return self.vocab.get(lowerCAmelCase__ ,self.vocab.get(self.unk_token ) )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Tuple ) -> Optional[Any]:
'''simple docstring'''
return self.subword_tokenizer.convert_id_to_token(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : Dict ) -> str:
'''simple docstring'''
lowerCAmelCase_ : str = "".join(lowerCAmelCase__ ).strip()
return out_string
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : "Conversation" ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = []
for is_user, text in conversation.iter_texts():
input_ids.extend(self.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ ) + [self.eos_token_id] )
if len(lowerCAmelCase__ ) > self.model_max_length:
lowerCAmelCase_ : str = input_ids[-self.model_max_length :]
return input_ids
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = 0
if os.path.isdir(lowerCAmelCase__ ):
lowerCAmelCase_ : List[str] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Optional[int] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["emoji_file"] )
else:
lowerCAmelCase_ : List[str] = (
(filename_prefix + "-" if filename_prefix else "") + save_directory + VOCAB_FILES_NAMES["vocab_file"]
)
lowerCAmelCase_ : Optional[Any] = (
(filename_prefix + "-" if filename_prefix else "") + save_directory + VOCAB_FILES_NAMES["emoji_file"]
)
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
for token_index, token in self.ids_to_tokens.items():
if index != token_index:
logger.warning(
f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'''
" Please check that the vocabulary is not corrupted!" )
lowerCAmelCase_ : List[Any] = token_index
writer.write(",".join(lowerCAmelCase__ ) + "\n" )
index += 1
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
json.dump(self.emoji ,lowerCAmelCase__ )
return vocab_file, emoji_file
class __snake_case ( snake_case__ ):
"""simple docstring"""
def __init__( self : Dict ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : int ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : str = vocab # same as swe
lowerCAmelCase_ : List[str] = ids_to_tokens # same as bpe
lowerCAmelCase_ : List[str] = emoji
lowerCAmelCase_ : Union[str, Any] = np.max([len(lowerCAmelCase__ ) for w in self.vocab.keys()] )
lowerCAmelCase_ : List[Any] = re.compile(R"(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)" )
lowerCAmelCase_ : List[str] = re.compile(R"[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*" )
lowerCAmelCase_ : List[str] = re.compile(R"[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}" )
lowerCAmelCase_ : Optional[int] = re.compile(
R"([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*" )
lowerCAmelCase_ : List[str] = re.compile(
R"(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*" )
lowerCAmelCase_ : str = re.compile(
R"((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*" )
lowerCAmelCase_ : List[str] = "─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿"
lowerCAmelCase_ : int = "▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟"
lowerCAmelCase_ : int = str.maketrans({k: "<BLOCK>" for k in keisen + blocks} )
def __len__( self : List[str] ) -> Union[str, Any]:
'''simple docstring'''
return len(self.ids_to_tokens )
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : Tuple ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = self.content_repattera.sub("<URL>" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = self.content_repattera.sub("<EMAIL>" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = self.content_repattera.sub("<TEL>" ,lowerCAmelCase__ )
lowerCAmelCase_ : Dict = self.content_repattera.sub("<DATE>" ,lowerCAmelCase__ )
lowerCAmelCase_ : int = self.content_repattera.sub("<DATE>" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = self.content_repattera.sub("<PRICE>" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = content.translate(self.content_transa )
while "<BLOCK><BLOCK>" in content:
lowerCAmelCase_ : Tuple = content.replace("<BLOCK><BLOCK>" ,"<BLOCK>" )
return content
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Union[str, Any]=False ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = text.replace(" " ,"<SP>" )
lowerCAmelCase_ : int = text.replace(" " ,"<SP>" )
lowerCAmelCase_ : int = text.replace("\r\n" ,"<BR>" )
lowerCAmelCase_ : Union[str, Any] = text.replace("\n" ,"<BR>" )
lowerCAmelCase_ : int = text.replace("\r" ,"<BR>" )
lowerCAmelCase_ : Union[str, Any] = text.replace("\t" ,"<TAB>" )
lowerCAmelCase_ : Optional[Any] = text.replace("—" ,"ー" )
lowerCAmelCase_ : List[Any] = text.replace("−" ,"ー" )
for k, v in self.emoji["emoji"].items():
if k in text:
lowerCAmelCase_ : str = text.replace(lowerCAmelCase__ ,lowerCAmelCase__ )
if clean:
lowerCAmelCase_ : Optional[Any] = self.clean_text(lowerCAmelCase__ )
def check_simbol(lowerCAmelCase__ : List[Any] ):
lowerCAmelCase_ : List[Any] = x.encode()
if len(lowerCAmelCase__ ) == 1 and len(lowerCAmelCase__ ) == 2:
lowerCAmelCase_ : Union[str, Any] = (int(e[0] ) << 8) + int(e[1] )
if (
(c >= 0Xc2a1 and c <= 0Xc2bf)
or (c >= 0Xc780 and c <= 0Xc783)
or (c >= 0Xcab9 and c <= 0Xcbbf)
or (c >= 0Xcc80 and c <= 0Xcda2)
):
return True
return False
def checkuae(lowerCAmelCase__ : int ):
lowerCAmelCase_ : Optional[int] = x.encode()
if len(lowerCAmelCase__ ) == 1 and len(lowerCAmelCase__ ) == 3:
lowerCAmelCase_ : Optional[Any] = (int(e[0] ) << 16) + (int(e[1] ) << 8) + int(e[2] )
if c >= 0Xe28080 and c <= 0Xe2b07f:
return True
return False
lowerCAmelCase_ : Optional[Any] = 0
lowerCAmelCase_ : List[str] = []
while pos < len(lowerCAmelCase__ ):
lowerCAmelCase_ : Dict = min(len(lowerCAmelCase__ ) ,pos + self.maxlen + 1 ) if text[pos] == "<" else pos + 3
lowerCAmelCase_ : Optional[int] = [] # (token_id, token, pos)
for e in range(lowerCAmelCase__ ,lowerCAmelCase__ ,-1 ):
lowerCAmelCase_ : Optional[int] = text[pos:e]
if wd in self.vocab:
if wd[0] == "<" and len(lowerCAmelCase__ ) > 2:
lowerCAmelCase_ : List[str] = [(self.vocab[wd], wd, e)]
break
else:
candidates.append((self.vocab[wd], wd, e) )
if len(lowerCAmelCase__ ) > 0:
# the smallest token_id is adopted
lowerCAmelCase_ : List[Any] = sorted(lowerCAmelCase__ ,key=lambda lowerCAmelCase__ : x[0] )[0]
result.append(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = e
else:
lowerCAmelCase_ : Union[str, Any] = pos + 1
lowerCAmelCase_ : List[str] = text[pos:end]
if check_simbol(lowerCAmelCase__ ):
result.append("<KIGOU>" )
elif checkuae(lowerCAmelCase__ ):
result.append("<U2000U2BFF>" )
else:
for i in wd.encode("utf-8" ):
result.append("<|byte%d|>" % i )
lowerCAmelCase_ : List[str] = end
return result
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Tuple="\n" ) -> int:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = []
lowerCAmelCase_ : Optional[int] = []
lowerCAmelCase_ : Tuple = self.ids_to_tokens[index][0]
if word[:6] == "<|byte" and word[-2:] == "|>":
byte_tokens.append(int(word[6:-2] ) )
else:
if len(lowerCAmelCase__ ) > 0:
words.append(bytearray(lowerCAmelCase__ ).decode("utf-8" ,errors="replace" ) )
lowerCAmelCase_ : List[Any] = []
if word[:7] == "<|emoji" and word[-2:] == "|>":
words.append(self.emoji["emoji_inv"][word] )
elif word == "<SP>":
words.append(" " )
elif word == "<BR>":
words.append(lowerCAmelCase__ )
elif word == "<TAB>":
words.append("\t" )
elif word == "<BLOCK>":
words.append("▀" )
elif word == "<KIGOU>":
words.append("ǀ" )
elif word == "<U2000U2BFF>":
words.append("‖" )
else:
words.append(lowerCAmelCase__ )
if len(lowerCAmelCase__ ) > 0:
words.append(bytearray(lowerCAmelCase__ ).decode("utf-8" ,errors="replace" ) )
lowerCAmelCase_ : Any = "".join(lowerCAmelCase__ )
return text
| 702 |
from math import sqrt
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[int] = 0
for i in range(1 , int(sqrt(snake_case__) + 1)):
if n % i == 0 and i != sqrt(snake_case__):
total += i + n // i
elif i == sqrt(snake_case__):
total += i
return total - n
def UpperCamelCase ( snake_case__ = 1_00_00):
lowerCAmelCase_ : int = sum(
i
for i in range(1 , snake_case__)
if sum_of_divisors(sum_of_divisors(snake_case__)) == i and sum_of_divisors(snake_case__) != i)
return total
if __name__ == "__main__":
print(solution(int(str(input()).strip())))
| 683 | 0 |
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
if height >= 1:
move_tower(height - 1 , snake_case__ , snake_case__ , snake_case__)
move_disk(snake_case__ , snake_case__)
move_tower(height - 1 , snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__):
print("moving disk from" , snake_case__ , "to" , snake_case__)
def UpperCamelCase ( ):
lowerCAmelCase_ : Union[str, Any] = int(input("Height of hanoi: ").strip())
move_tower(snake_case__ , "A" , "B" , "C")
if __name__ == "__main__":
main()
| 703 |
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_sentencepiece_available,
is_speech_available,
is_tf_available,
is_torch_available,
)
_lowercase = {
'''configuration_speech_to_text''': ['''SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Speech2TextConfig'''],
'''processing_speech_to_text''': ['''Speech2TextProcessor'''],
}
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = ['''Speech2TextTokenizer''']
try:
if not is_speech_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = ['''Speech2TextFeatureExtractor''']
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFSpeech2TextForConditionalGeneration''',
'''TFSpeech2TextModel''',
'''TFSpeech2TextPreTrainedModel''',
]
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''Speech2TextForConditionalGeneration''',
'''Speech2TextModel''',
'''Speech2TextPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
from .processing_speech_to_text import SpeechaTextProcessor
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_speech_to_text import SpeechaTextTokenizer
try:
if not is_speech_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_speech_to_text import (
TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFSpeechaTextForConditionalGeneration,
TFSpeechaTextModel,
TFSpeechaTextPreTrainedModel,
)
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_speech_to_text import (
SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
SpeechaTextForConditionalGeneration,
SpeechaTextModel,
SpeechaTextPreTrainedModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 683 | 0 |
from collections import OrderedDict
from typing import Mapping
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {
'''YituTech/conv-bert-base''': '''https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json''',
'''YituTech/conv-bert-medium-small''': (
'''https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json'''
),
'''YituTech/conv-bert-small''': '''https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json''',
# See all ConvBERT models at https://huggingface.co/models?filter=convbert
}
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'convbert'
def __init__( self : Optional[Any] ,lowerCAmelCase__ : List[str]=3_05_22 ,lowerCAmelCase__ : Optional[Any]=7_68 ,lowerCAmelCase__ : Any=12 ,lowerCAmelCase__ : int=12 ,lowerCAmelCase__ : int=30_72 ,lowerCAmelCase__ : Optional[int]="gelu" ,lowerCAmelCase__ : Any=0.1 ,lowerCAmelCase__ : List[str]=0.1 ,lowerCAmelCase__ : Optional[Any]=5_12 ,lowerCAmelCase__ : List[str]=2 ,lowerCAmelCase__ : Union[str, Any]=0.02 ,lowerCAmelCase__ : str=1e-1_2 ,lowerCAmelCase__ : Union[str, Any]=1 ,lowerCAmelCase__ : Optional[Any]=0 ,lowerCAmelCase__ : Union[str, Any]=2 ,lowerCAmelCase__ : int=7_68 ,lowerCAmelCase__ : Tuple=2 ,lowerCAmelCase__ : Optional[Any]=9 ,lowerCAmelCase__ : str=1 ,lowerCAmelCase__ : List[Any]=None ,**lowerCAmelCase__ : List[str] ,) -> List[str]:
'''simple docstring'''
super().__init__(
pad_token_id=lowerCAmelCase__ ,bos_token_id=lowerCAmelCase__ ,eos_token_id=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : List[str] = vocab_size
lowerCAmelCase_ : Dict = hidden_size
lowerCAmelCase_ : List[Any] = num_hidden_layers
lowerCAmelCase_ : Union[str, Any] = num_attention_heads
lowerCAmelCase_ : str = intermediate_size
lowerCAmelCase_ : Union[str, Any] = hidden_act
lowerCAmelCase_ : Dict = hidden_dropout_prob
lowerCAmelCase_ : Tuple = attention_probs_dropout_prob
lowerCAmelCase_ : List[str] = max_position_embeddings
lowerCAmelCase_ : List[str] = type_vocab_size
lowerCAmelCase_ : List[Any] = initializer_range
lowerCAmelCase_ : List[str] = layer_norm_eps
lowerCAmelCase_ : Tuple = embedding_size
lowerCAmelCase_ : Tuple = head_ratio
lowerCAmelCase_ : Any = conv_kernel_size
lowerCAmelCase_ : int = num_groups
lowerCAmelCase_ : Tuple = classifier_dropout
class __snake_case ( snake_case__ ):
"""simple docstring"""
@property
def UpperCAmelCase_ ( self : Tuple ) -> Mapping[str, Mapping[int, str]]:
'''simple docstring'''
if self.task == "multiple-choice":
lowerCAmelCase_ : List[Any] = {0: "batch", 1: "choice", 2: "sequence"}
else:
lowerCAmelCase_ : Union[str, Any] = {0: "batch", 1: "sequence"}
return OrderedDict(
[
("input_ids", dynamic_axis),
("attention_mask", dynamic_axis),
("token_type_ids", dynamic_axis),
] )
| 704 |
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple
import regex as re
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}
_lowercase = {
'''vocab_file''': {
'''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json''',
'''allenai/longformer-large-4096''': (
'''https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json'''
),
'''allenai/longformer-large-4096-finetuned-triviaqa''': (
'''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json'''
),
'''allenai/longformer-base-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json'''
),
'''allenai/longformer-large-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json'''
),
},
'''merges_file''': {
'''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt''',
'''allenai/longformer-large-4096''': (
'''https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt'''
),
'''allenai/longformer-large-4096-finetuned-triviaqa''': (
'''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt'''
),
'''allenai/longformer-base-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt'''
),
'''allenai/longformer-large-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt'''
),
},
}
_lowercase = {
'''allenai/longformer-base-4096''': 4096,
'''allenai/longformer-large-4096''': 4096,
'''allenai/longformer-large-4096-finetuned-triviaqa''': 4096,
'''allenai/longformer-base-4096-extra.pos.embd.only''': 4096,
'''allenai/longformer-large-4096-extra.pos.embd.only''': 4096,
}
@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def UpperCamelCase ( ):
lowerCAmelCase_ : str = (
list(range(ord("!") , ord("~") + 1)) + list(range(ord("¡") , ord("¬") + 1)) + list(range(ord("®") , ord("ÿ") + 1))
)
lowerCAmelCase_ : Tuple = bs[:]
lowerCAmelCase_ : Dict = 0
for b in range(2**8):
if b not in bs:
bs.append(snake_case__)
cs.append(2**8 + n)
n += 1
lowerCAmelCase_ : Union[str, Any] = [chr(snake_case__) for n in cs]
return dict(zip(snake_case__ , snake_case__))
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[Any] = set()
lowerCAmelCase_ : List[Any] = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
lowerCAmelCase_ : Union[str, Any] = char
return pairs
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = ['input_ids', 'attention_mask']
def __init__( self : str ,lowerCAmelCase__ : Dict ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Optional[Any]="replace" ,lowerCAmelCase__ : Dict="<s>" ,lowerCAmelCase__ : str="</s>" ,lowerCAmelCase__ : str="</s>" ,lowerCAmelCase__ : Optional[Any]="<s>" ,lowerCAmelCase__ : List[Any]="<unk>" ,lowerCAmelCase__ : Union[str, Any]="<pad>" ,lowerCAmelCase__ : int="<mask>" ,lowerCAmelCase__ : Any=False ,**lowerCAmelCase__ : int ,) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else bos_token
lowerCAmelCase_ : Tuple = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else eos_token
lowerCAmelCase_ : Dict = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else sep_token
lowerCAmelCase_ : int = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else cls_token
lowerCAmelCase_ : List[str] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else unk_token
lowerCAmelCase_ : List[str] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else pad_token
# Mask token behave like a normal word, i.e. include the space before it
lowerCAmelCase_ : Optional[Any] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else mask_token
super().__init__(
errors=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,sep_token=lowerCAmelCase__ ,cls_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,mask_token=lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
with open(lowerCAmelCase__ ,encoding="utf-8" ) as vocab_handle:
lowerCAmelCase_ : List[Any] = json.load(lowerCAmelCase__ )
lowerCAmelCase_ : Dict = {v: k for k, v in self.encoder.items()}
lowerCAmelCase_ : List[Any] = errors # how to handle errors in decoding
lowerCAmelCase_ : Optional[Any] = bytes_to_unicode()
lowerCAmelCase_ : int = {v: k for k, v in self.byte_encoder.items()}
with open(lowerCAmelCase__ ,encoding="utf-8" ) as merges_handle:
lowerCAmelCase_ : Union[str, Any] = merges_handle.read().split("\n" )[1:-1]
lowerCAmelCase_ : Dict = [tuple(merge.split() ) for merge in bpe_merges]
lowerCAmelCase_ : Dict = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : Any = {}
lowerCAmelCase_ : int = add_prefix_space
# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
lowerCAmelCase_ : Optional[Any] = re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" )
@property
def UpperCAmelCase_ ( self : Optional[int] ) -> Any:
'''simple docstring'''
return len(self.encoder )
def UpperCAmelCase_ ( self : Any ) -> Optional[int]:
'''simple docstring'''
return dict(self.encoder ,**self.added_tokens_encoder )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : List[str] ) -> List[Any]:
'''simple docstring'''
if token in self.cache:
return self.cache[token]
lowerCAmelCase_ : Union[str, Any] = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = get_pairs(lowerCAmelCase__ )
if not pairs:
return token
while True:
lowerCAmelCase_ : Dict = min(lowerCAmelCase__ ,key=lambda lowerCAmelCase__ : self.bpe_ranks.get(lowerCAmelCase__ ,float("inf" ) ) )
if bigram not in self.bpe_ranks:
break
lowerCAmelCase_ , lowerCAmelCase_ : Dict = bigram
lowerCAmelCase_ : Optional[Any] = []
lowerCAmelCase_ : Any = 0
while i < len(lowerCAmelCase__ ):
try:
lowerCAmelCase_ : Optional[int] = word.index(lowerCAmelCase__ ,lowerCAmelCase__ )
except ValueError:
new_word.extend(word[i:] )
break
else:
new_word.extend(word[i:j] )
lowerCAmelCase_ : Tuple = j
if word[i] == first and i < len(lowerCAmelCase__ ) - 1 and word[i + 1] == second:
new_word.append(first + second )
i += 2
else:
new_word.append(word[i] )
i += 1
lowerCAmelCase_ : Optional[Any] = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = new_word
if len(lowerCAmelCase__ ) == 1:
break
else:
lowerCAmelCase_ : Dict = get_pairs(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = " ".join(lowerCAmelCase__ )
lowerCAmelCase_ : Any = word
return word
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Dict = []
for token in re.findall(self.pat ,lowerCAmelCase__ ):
lowerCAmelCase_ : List[str] = "".join(
self.byte_encoder[b] for b in token.encode("utf-8" ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCAmelCase__ ).split(" " ) )
return bpe_tokens
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : int ) -> Tuple:
'''simple docstring'''
return self.encoder.get(lowerCAmelCase__ ,self.encoder.get(self.unk_token ) )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Optional[Any] ) -> Union[str, Any]:
'''simple docstring'''
return self.decoder.get(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Dict ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = "".join(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8" ,errors=self.errors )
return text
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
if not os.path.isdir(lowerCAmelCase__ ):
logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
return
lowerCAmelCase_ : Optional[Any] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as f:
f.write(json.dumps(self.encoder ,indent=2 ,sort_keys=lowerCAmelCase__ ,ensure_ascii=lowerCAmelCase__ ) + "\n" )
lowerCAmelCase_ : Tuple = 0
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
writer.write("#version: 0.2\n" )
for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,key=lambda lowerCAmelCase__ : kv[1] ):
if index != token_index:
logger.warning(
f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
" Please check that the tokenizer is not corrupted!" )
lowerCAmelCase_ : Optional[Any] = token_index
writer.write(" ".join(lowerCAmelCase__ ) + "\n" )
index += 1
return vocab_file, merge_file
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
if token_ids_a is None:
return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
lowerCAmelCase_ : List[Any] = [self.cls_token_id]
lowerCAmelCase_ : List[str] = [self.sep_token_id]
return cls + token_ids_a + sep + sep + token_ids_a + sep
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ,lowerCAmelCase__ : bool = False ) -> List[int]:
'''simple docstring'''
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, 1] + ([0] * len(lowerCAmelCase__ )) + [1]
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = [self.sep_token_id]
lowerCAmelCase_ : Tuple = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : List[str] ,lowerCAmelCase__ : Optional[int]=False ,**lowerCAmelCase__ : Optional[int] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : int = kwargs.pop("add_prefix_space" ,self.add_prefix_space )
if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase__ ) > 0 and not text[0].isspace()):
lowerCAmelCase_ : Union[str, Any] = " " + text
return (text, kwargs)
| 683 | 0 |
'''simple docstring'''
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union
import numpy as np
import PIL
from PIL import Image
from ...utils import BaseOutput, is_torch_available, is_transformers_available
@dataclass
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 4_2
UpperCamelCase_ = 4_2
if is_transformers_available() and is_torch_available():
from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline
| 705 |
from collections.abc import Iterable
from typing import Any
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : int | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Dict = value
lowerCAmelCase_ : Node | None = None # Added in order to delete a node easier
lowerCAmelCase_ : Node | None = None
lowerCAmelCase_ : Node | None = None
def __repr__( self : Union[str, Any] ) -> str:
'''simple docstring'''
from pprint import pformat
if self.left is None and self.right is None:
return str(self.value )
return pformat({f'''{self.value}''': (self.left, self.right)} ,indent=1 )
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Node | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = root
def __str__( self : Dict ) -> str:
'''simple docstring'''
return str(self.root )
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Node ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if new_children is not None: # reset its kids
lowerCAmelCase_ : Optional[int] = node.parent
if node.parent is not None: # reset its parent
if self.is_right(lowerCAmelCase__ ): # If it is the right children
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : Any = new_children
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : Node ) -> bool:
'''simple docstring'''
if node.parent and node.parent.right:
return node == node.parent.right
return False
def UpperCAmelCase_ ( self : List[str] ) -> bool:
'''simple docstring'''
return self.root is None
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Union[str, Any] ) -> None:
'''simple docstring'''
lowerCAmelCase_ : str = Node(lowerCAmelCase__ ) # create a new Node
if self.empty(): # if Tree is empty
lowerCAmelCase_ : Optional[int] = new_node # set its root
else: # Tree is not empty
lowerCAmelCase_ : List[Any] = self.root # from root
if parent_node is None:
return
while True: # While we don't get to a leaf
if value < parent_node.value: # We go left
if parent_node.left is None:
lowerCAmelCase_ : Dict = new_node # We insert the new node in a leaf
break
else:
lowerCAmelCase_ : List[str] = parent_node.left
else:
if parent_node.right is None:
lowerCAmelCase_ : Dict = new_node
break
else:
lowerCAmelCase_ : str = parent_node.right
lowerCAmelCase_ : Optional[int] = parent_node
def UpperCAmelCase_ ( self : int ,*lowerCAmelCase__ : Tuple ) -> None:
'''simple docstring'''
for value in values:
self.__insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Optional[int] ) -> Node | None:
'''simple docstring'''
if self.empty():
raise IndexError("Warning: Tree is empty! please use another." )
else:
lowerCAmelCase_ : Dict = self.root
# use lazy evaluation here to avoid NoneType Attribute error
while node is not None and node.value is not value:
lowerCAmelCase_ : Union[str, Any] = node.left if value < node.value else node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
if self.root is None:
return None
lowerCAmelCase_ : Dict = self.root
if not self.empty():
while node.right is not None:
lowerCAmelCase_ : Union[str, Any] = node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
lowerCAmelCase_ : Dict = self.root
if self.root is None:
return None
if not self.empty():
lowerCAmelCase_ : Dict = self.root
while node.left is not None:
lowerCAmelCase_ : Union[str, Any] = node.left
return node
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : int ) -> None:
'''simple docstring'''
lowerCAmelCase_ : Dict = self.search(lowerCAmelCase__ ) # Look for the node with that label
if node is not None:
if node.left is None and node.right is None: # If it has no children
self.__reassign_nodes(lowerCAmelCase__ ,lowerCAmelCase__ )
elif node.left is None: # Has only right children
self.__reassign_nodes(lowerCAmelCase__ ,node.right )
elif node.right is None: # Has only left children
self.__reassign_nodes(lowerCAmelCase__ ,node.left )
else:
lowerCAmelCase_ : int = self.get_max(
node.left ) # Gets the max value of the left branch
self.remove(tmp_node.value ) # type: ignore
lowerCAmelCase_ : Any = (
tmp_node.value # type: ignore
) # Assigns the value to the node to delete and keep tree structure
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Node | None ) -> Iterable:
'''simple docstring'''
if node is not None:
yield node # Preorder Traversal
yield from self.preorder_traverse(node.left )
yield from self.preorder_traverse(node.right )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Dict=None ) -> Any:
'''simple docstring'''
if traversal_function is None:
return self.preorder_traverse(self.root )
else:
return traversal_function(self.root )
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : list ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if node:
self.inorder(lowerCAmelCase__ ,node.left )
arr.append(node.value )
self.inorder(lowerCAmelCase__ ,node.right )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Node ) -> int:
'''simple docstring'''
lowerCAmelCase_ : list[int] = []
self.inorder(lowerCAmelCase__ ,lowerCAmelCase__ ) # append all values to list using inorder traversal
return arr[k - 1]
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[Any] = []
if curr_node is not None:
lowerCAmelCase_ : Dict = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
return node_list
def UpperCamelCase ( ):
lowerCAmelCase_ : Tuple = (8, 3, 6, 1, 10, 14, 13, 4, 7)
lowerCAmelCase_ : Tuple = BinarySearchTree()
for i in testlist:
t.insert(snake_case__)
# Prints all the elements of the list in order traversal
print(snake_case__)
if t.search(6) is not None:
print("The value 6 exists")
else:
print("The value 6 doesn't exist")
if t.search(-1) is not None:
print("The value -1 exists")
else:
print("The value -1 doesn't exist")
if not t.empty():
print("Max Value: " , t.get_max().value) # type: ignore
print("Min Value: " , t.get_min().value) # type: ignore
for i in testlist:
t.remove(snake_case__)
print(snake_case__)
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
| 683 | 0 |
'''simple docstring'''
from typing import List, Optional
import numpy as np
from ...processing_utils import ProcessorMixin
from ...utils import to_numpy
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'EncodecFeatureExtractor'
UpperCamelCase_ = ('T5Tokenizer', 'T5TokenizerFast')
def __init__( self : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Optional[Any] ) -> str:
'''simple docstring'''
super().__init__(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = self.feature_extractor
lowerCAmelCase_ : List[str] = False
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Dict=None ,lowerCAmelCase__ : Optional[Any]=None ,lowerCAmelCase__ : Union[str, Any]=True ) -> Dict:
'''simple docstring'''
return self.tokenizer.get_decoder_prompt_ids(task=lowerCAmelCase__ ,language=lowerCAmelCase__ ,no_timestamps=lowerCAmelCase__ )
def __call__( self : int ,*lowerCAmelCase__ : int ,**lowerCAmelCase__ : List[str] ) -> str:
'''simple docstring'''
if self._in_target_context_manager:
return self.current_processor(*lowerCAmelCase__ ,**lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = kwargs.pop("audio" ,lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = kwargs.pop("sampling_rate" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = kwargs.pop("text" ,lowerCAmelCase__ )
if len(lowerCAmelCase__ ) > 0:
lowerCAmelCase_ : Dict = args[0]
lowerCAmelCase_ : str = args[1:]
if audio is None and text is None:
raise ValueError("You need to specify either an `audio` or `text` input to process." )
if text is not None:
lowerCAmelCase_ : Union[str, Any] = self.tokenizer(lowerCAmelCase__ ,**lowerCAmelCase__ )
if audio is not None:
lowerCAmelCase_ : int = self.feature_extractor(lowerCAmelCase__ ,*lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,**lowerCAmelCase__ )
if audio is None:
return inputs
elif text is None:
return audio_inputs
else:
lowerCAmelCase_ : Union[str, Any] = audio_inputs["input_values"]
if "padding_mask" in audio_inputs:
lowerCAmelCase_ : List[Any] = audio_inputs["padding_mask"]
return inputs
def UpperCAmelCase_ ( self : Dict ,*lowerCAmelCase__ : Optional[Any] ,**lowerCAmelCase__ : Dict ) -> int:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = kwargs.pop("audio" ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = kwargs.pop("padding_mask" ,lowerCAmelCase__ )
if len(lowerCAmelCase__ ) > 0:
lowerCAmelCase_ : int = args[0]
lowerCAmelCase_ : Union[str, Any] = args[1:]
if audio_values is not None:
return self._decode_audio(lowerCAmelCase__ ,padding_mask=lowerCAmelCase__ )
else:
return self.tokenizer.batch_decode(*lowerCAmelCase__ ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Any ,*lowerCAmelCase__ : Union[str, Any] ,**lowerCAmelCase__ : str ) -> Optional[Any]:
'''simple docstring'''
return self.tokenizer.decode(*lowerCAmelCase__ ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional = None ) -> List[np.ndarray]:
'''simple docstring'''
lowerCAmelCase_ : int = to_numpy(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = audio_values.shape
if padding_mask is None:
return list(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = to_numpy(lowerCAmelCase__ )
# match the sequence length of the padding mask to the generated audio arrays by padding with the **non-padding**
# token (so that the generated audio values are **not** treated as padded tokens)
lowerCAmelCase_ : int = seq_len - padding_mask.shape[-1]
lowerCAmelCase_ : str = 1 - self.feature_extractor.padding_value
lowerCAmelCase_ : str = np.pad(lowerCAmelCase__ ,((0, 0), (0, difference)) ,"constant" ,constant_values=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = audio_values.tolist()
for i in range(lowerCAmelCase__ ):
lowerCAmelCase_ : Dict = np.asarray(audio_values[i] )[
padding_mask[i][None, :] != self.feature_extractor.padding_value
]
lowerCAmelCase_ : Dict = sliced_audio.reshape(lowerCAmelCase__ ,-1 )
return audio_values
| 706 |
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[int] ,lowerCAmelCase__ : str = "" ,lowerCAmelCase__ : bool = False ) -> None:
'''simple docstring'''
lowerCAmelCase_ : dict[str, RadixNode] = {}
# A node will be a leaf if the tree contains its word
lowerCAmelCase_ : int = is_leaf
lowerCAmelCase_ : Optional[Any] = prefix
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : str ) -> tuple[str, str, str]:
'''simple docstring'''
lowerCAmelCase_ : Any = 0
for q, w in zip(self.prefix ,lowerCAmelCase__ ):
if q != w:
break
x += 1
return self.prefix[:x], self.prefix[x:], word[x:]
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : list[str] ) -> None:
'''simple docstring'''
for word in words:
self.insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : str ) -> None:
'''simple docstring'''
if self.prefix == word:
lowerCAmelCase_ : Optional[Any] = True
# Case 2: The node has no edges that have a prefix to the word
# Solution: We create an edge from the current node to a new one
# containing the word
elif word[0] not in self.nodes:
lowerCAmelCase_ : List[Any] = RadixNode(prefix=lowerCAmelCase__ ,is_leaf=lowerCAmelCase__ )
else:
lowerCAmelCase_ : Tuple = self.nodes[word[0]]
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : List[str] = incoming_node.match(
lowerCAmelCase__ )
# Case 3: The node prefix is equal to the matching
# Solution: We insert remaining word on the next node
if remaining_prefix == "":
self.nodes[matching_string[0]].insert(lowerCAmelCase__ )
# Case 4: The word is greater equal to the matching
# Solution: Create a node in between both nodes, change
# prefixes and add the new node for the remaining word
else:
lowerCAmelCase_ : Optional[int] = remaining_prefix
lowerCAmelCase_ : Optional[int] = self.nodes[matching_string[0]]
lowerCAmelCase_ : List[Any] = RadixNode(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Dict = aux_node
if remaining_word == "":
lowerCAmelCase_ : List[str] = True
else:
self.nodes[matching_string[0]].insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : str ) -> bool:
'''simple docstring'''
lowerCAmelCase_ : Any = self.nodes.get(word[0] ,lowerCAmelCase__ )
if not incoming_node:
return False
else:
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : List[Any] = incoming_node.match(
lowerCAmelCase__ )
# If there is remaining prefix, the word can't be on the tree
if remaining_prefix != "":
return False
# This applies when the word and the prefix are equal
elif remaining_word == "":
return incoming_node.is_leaf
# We have word remaining so we check the next node
else:
return incoming_node.find(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : str ) -> bool:
'''simple docstring'''
lowerCAmelCase_ : int = self.nodes.get(word[0] ,lowerCAmelCase__ )
if not incoming_node:
return False
else:
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : Union[str, Any] = incoming_node.match(
lowerCAmelCase__ )
# If there is remaining prefix, the word can't be on the tree
if remaining_prefix != "":
return False
# We have word remaining so we check the next node
elif remaining_word != "":
return incoming_node.delete(lowerCAmelCase__ )
else:
# If it is not a leaf, we don't have to delete
if not incoming_node.is_leaf:
return False
else:
# We delete the nodes if no edges go from it
if len(incoming_node.nodes ) == 0:
del self.nodes[word[0]]
# We merge the current node with its only child
if len(self.nodes ) == 1 and not self.is_leaf:
lowerCAmelCase_ : str = list(self.nodes.values() )[0]
lowerCAmelCase_ : Tuple = merging_node.is_leaf
self.prefix += merging_node.prefix
lowerCAmelCase_ : Optional[int] = merging_node.nodes
# If there is more than 1 edge, we just mark it as non-leaf
elif len(incoming_node.nodes ) > 1:
lowerCAmelCase_ : Optional[Any] = False
# If there is 1 edge, we merge it with its child
else:
lowerCAmelCase_ : Tuple = list(incoming_node.nodes.values() )[0]
lowerCAmelCase_ : Union[str, Any] = merging_node.is_leaf
incoming_node.prefix += merging_node.prefix
lowerCAmelCase_ : str = merging_node.nodes
return True
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : int = 0 ) -> None:
'''simple docstring'''
if self.prefix != "":
print("-" * height ,self.prefix ," (leaf)" if self.is_leaf else "" )
for value in self.nodes.values():
value.print_tree(height + 1 )
def UpperCamelCase ( ):
lowerCAmelCase_ : Dict = "banana bananas bandana band apple all beast".split()
lowerCAmelCase_ : List[Any] = RadixNode()
root.insert_many(snake_case__)
assert all(root.find(snake_case__) for word in words)
assert not root.find("bandanas")
assert not root.find("apps")
root.delete("all")
assert not root.find("all")
root.delete("banana")
assert not root.find("banana")
assert root.find("bananas")
return True
def UpperCamelCase ( ):
assert test_trie()
def UpperCamelCase ( ):
lowerCAmelCase_ : List[str] = RadixNode()
lowerCAmelCase_ : Optional[Any] = "banana bananas bandanas bandana band apple all beast".split()
root.insert_many(snake_case__)
print("Words:" , snake_case__)
print("Tree:")
root.print_tree()
if __name__ == "__main__":
main()
| 683 | 0 |
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional
from packaging import version
if TYPE_CHECKING:
from ... import PreTrainedTokenizer, TensorType
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging
_lowercase = logging.get_logger(__name__)
_lowercase = {
'''bigscience/bloom''': '''https://huggingface.co/bigscience/bloom/resolve/main/config.json''',
'''bigscience/bloom-560m''': '''https://huggingface.co/bigscience/bloom-560m/blob/main/config.json''',
'''bigscience/bloom-1b1''': '''https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json''',
'''bigscience/bloom-1b7''': '''https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json''',
'''bigscience/bloom-3b''': '''https://huggingface.co/bigscience/bloom-3b/blob/main/config.json''',
'''bigscience/bloom-7b1''': '''https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json''',
}
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'bloom'
UpperCamelCase_ = ['past_key_values']
UpperCamelCase_ = {
'num_hidden_layers': 'n_layer',
'num_attention_heads': 'n_head',
}
def __init__( self : Union[str, Any] ,lowerCAmelCase__ : Union[str, Any]=25_08_80 ,lowerCAmelCase__ : Tuple=64 ,lowerCAmelCase__ : Optional[Any]=2 ,lowerCAmelCase__ : int=8 ,lowerCAmelCase__ : List[str]=1e-5 ,lowerCAmelCase__ : Any=0.02 ,lowerCAmelCase__ : List[str]=True ,lowerCAmelCase__ : Optional[Any]=1 ,lowerCAmelCase__ : Dict=2 ,lowerCAmelCase__ : Dict=False ,lowerCAmelCase__ : Optional[Any]=0.0 ,lowerCAmelCase__ : Union[str, Any]=0.0 ,lowerCAmelCase__ : str=1 ,lowerCAmelCase__ : Optional[Any]=False ,**lowerCAmelCase__ : List[str] ,) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = vocab_size
# Backward compatibility with n_embed kwarg
lowerCAmelCase_ : List[str] = kwargs.pop("n_embed" ,lowerCAmelCase__ )
lowerCAmelCase_ : int = hidden_size if n_embed is None else n_embed
lowerCAmelCase_ : str = n_layer
lowerCAmelCase_ : Any = n_head
lowerCAmelCase_ : Dict = layer_norm_epsilon
lowerCAmelCase_ : List[str] = initializer_range
lowerCAmelCase_ : int = use_cache
lowerCAmelCase_ : Tuple = pretraining_tp
lowerCAmelCase_ : Optional[int] = apply_residual_connection_post_layernorm
lowerCAmelCase_ : str = hidden_dropout
lowerCAmelCase_ : Tuple = attention_dropout
lowerCAmelCase_ : Optional[Any] = bos_token_id
lowerCAmelCase_ : Tuple = eos_token_id
lowerCAmelCase_ : Any = slow_but_exact
super().__init__(bos_token_id=lowerCAmelCase__ ,eos_token_id=lowerCAmelCase__ ,**lowerCAmelCase__ )
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = version.parse('1.12' )
def __init__( self : List[Any] ,lowerCAmelCase__ : PretrainedConfig ,lowerCAmelCase__ : str = "default" ,lowerCAmelCase__ : List[PatchingSpec] = None ,lowerCAmelCase__ : bool = False ,) -> str:
'''simple docstring'''
super().__init__(lowerCAmelCase__ ,task=lowerCAmelCase__ ,patching_specs=lowerCAmelCase__ ,use_past=lowerCAmelCase__ )
if not getattr(self._config ,"pad_token_id" ,lowerCAmelCase__ ):
# TODO: how to do that better?
lowerCAmelCase_ : str = 0
@property
def UpperCAmelCase_ ( self : List[Any] ) -> Mapping[str, Mapping[int, str]]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = OrderedDict({"input_ids": {0: "batch", 1: "sequence"}} )
if self.use_past:
# BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
self.fill_with_past_key_values_(lowerCAmelCase__ ,direction="inputs" ,inverted_values_shape=lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = {0: "batch", 1: "past_sequence + sequence"}
else:
lowerCAmelCase_ : int = {0: "batch", 1: "sequence"}
return common_inputs
@property
def UpperCAmelCase_ ( self : List[Any] ) -> int:
'''simple docstring'''
return self._config.n_layer
@property
def UpperCAmelCase_ ( self : Optional[int] ) -> int:
'''simple docstring'''
return self._config.n_head
@property
def UpperCAmelCase_ ( self : Dict ) -> float:
'''simple docstring'''
return 1e-3
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : "PreTrainedTokenizer" ,lowerCAmelCase__ : int = -1 ,lowerCAmelCase__ : int = -1 ,lowerCAmelCase__ : bool = False ,lowerCAmelCase__ : Optional["TensorType"] = None ,) -> Mapping[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = super(lowerCAmelCase__ ,self ).generate_dummy_inputs(
lowerCAmelCase__ ,batch_size=lowerCAmelCase__ ,seq_length=lowerCAmelCase__ ,is_pair=lowerCAmelCase__ ,framework=lowerCAmelCase__ )
# We need to order the input in the way they appears in the forward()
lowerCAmelCase_ : int = OrderedDict({"input_ids": common_inputs["input_ids"]} )
# Need to add the past_keys
if self.use_past:
if not is_torch_available():
raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed." )
else:
import torch
lowerCAmelCase_ : Dict = common_inputs["input_ids"].shape
# Not using the same length for past_key_values
lowerCAmelCase_ : List[str] = seqlen + 2
lowerCAmelCase_ : Optional[int] = self._config.hidden_size // self.num_attention_heads
lowerCAmelCase_ : Union[str, Any] = (
batch * self.num_attention_heads,
head_dim,
past_key_values_length,
)
lowerCAmelCase_ : Union[str, Any] = (
batch * self.num_attention_heads,
past_key_values_length,
head_dim,
)
lowerCAmelCase_ : Optional[Any] = [
(torch.zeros(lowerCAmelCase__ ), torch.zeros(lowerCAmelCase__ )) for _ in range(self.num_layers )
]
lowerCAmelCase_ : List[str] = common_inputs["attention_mask"]
if self.use_past:
lowerCAmelCase_ : Dict = ordered_inputs["attention_mask"].dtype
lowerCAmelCase_ : Tuple = torch.cat(
[ordered_inputs["attention_mask"], torch.ones(lowerCAmelCase__ ,lowerCAmelCase__ ,dtype=lowerCAmelCase__ )] ,dim=1 )
return ordered_inputs
@property
def UpperCAmelCase_ ( self : Optional[Any] ) -> int:
'''simple docstring'''
return 13
| 707 |
from __future__ import annotations
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , ):
if (electron_conc, hole_conc, intrinsic_conc).count(0) != 1:
raise ValueError("You cannot supply more or less than 2 values")
elif electron_conc < 0:
raise ValueError("Electron concentration cannot be negative in a semiconductor")
elif hole_conc < 0:
raise ValueError("Hole concentration cannot be negative in a semiconductor")
elif intrinsic_conc < 0:
raise ValueError(
"Intrinsic concentration cannot be negative in a semiconductor")
elif electron_conc == 0:
return (
"electron_conc",
intrinsic_conc**2 / hole_conc,
)
elif hole_conc == 0:
return (
"hole_conc",
intrinsic_conc**2 / electron_conc,
)
elif intrinsic_conc == 0:
return (
"intrinsic_conc",
(electron_conc * hole_conc) ** 0.5,
)
else:
return (-1, -1)
if __name__ == "__main__":
import doctest
doctest.testmod()
| 683 | 0 |
from collections.abc import Iterable
from typing import Any
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : int | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Dict = value
lowerCAmelCase_ : Node | None = None # Added in order to delete a node easier
lowerCAmelCase_ : Node | None = None
lowerCAmelCase_ : Node | None = None
def __repr__( self : Union[str, Any] ) -> str:
'''simple docstring'''
from pprint import pformat
if self.left is None and self.right is None:
return str(self.value )
return pformat({f'''{self.value}''': (self.left, self.right)} ,indent=1 )
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Node | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = root
def __str__( self : Dict ) -> str:
'''simple docstring'''
return str(self.root )
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Node ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if new_children is not None: # reset its kids
lowerCAmelCase_ : Optional[int] = node.parent
if node.parent is not None: # reset its parent
if self.is_right(lowerCAmelCase__ ): # If it is the right children
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : Any = new_children
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : Node ) -> bool:
'''simple docstring'''
if node.parent and node.parent.right:
return node == node.parent.right
return False
def UpperCAmelCase_ ( self : List[str] ) -> bool:
'''simple docstring'''
return self.root is None
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Union[str, Any] ) -> None:
'''simple docstring'''
lowerCAmelCase_ : str = Node(lowerCAmelCase__ ) # create a new Node
if self.empty(): # if Tree is empty
lowerCAmelCase_ : Optional[int] = new_node # set its root
else: # Tree is not empty
lowerCAmelCase_ : List[Any] = self.root # from root
if parent_node is None:
return
while True: # While we don't get to a leaf
if value < parent_node.value: # We go left
if parent_node.left is None:
lowerCAmelCase_ : Dict = new_node # We insert the new node in a leaf
break
else:
lowerCAmelCase_ : List[str] = parent_node.left
else:
if parent_node.right is None:
lowerCAmelCase_ : Dict = new_node
break
else:
lowerCAmelCase_ : str = parent_node.right
lowerCAmelCase_ : Optional[int] = parent_node
def UpperCAmelCase_ ( self : int ,*lowerCAmelCase__ : Tuple ) -> None:
'''simple docstring'''
for value in values:
self.__insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Optional[int] ) -> Node | None:
'''simple docstring'''
if self.empty():
raise IndexError("Warning: Tree is empty! please use another." )
else:
lowerCAmelCase_ : Dict = self.root
# use lazy evaluation here to avoid NoneType Attribute error
while node is not None and node.value is not value:
lowerCAmelCase_ : Union[str, Any] = node.left if value < node.value else node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
if self.root is None:
return None
lowerCAmelCase_ : Dict = self.root
if not self.empty():
while node.right is not None:
lowerCAmelCase_ : Union[str, Any] = node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
lowerCAmelCase_ : Dict = self.root
if self.root is None:
return None
if not self.empty():
lowerCAmelCase_ : Dict = self.root
while node.left is not None:
lowerCAmelCase_ : Union[str, Any] = node.left
return node
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : int ) -> None:
'''simple docstring'''
lowerCAmelCase_ : Dict = self.search(lowerCAmelCase__ ) # Look for the node with that label
if node is not None:
if node.left is None and node.right is None: # If it has no children
self.__reassign_nodes(lowerCAmelCase__ ,lowerCAmelCase__ )
elif node.left is None: # Has only right children
self.__reassign_nodes(lowerCAmelCase__ ,node.right )
elif node.right is None: # Has only left children
self.__reassign_nodes(lowerCAmelCase__ ,node.left )
else:
lowerCAmelCase_ : int = self.get_max(
node.left ) # Gets the max value of the left branch
self.remove(tmp_node.value ) # type: ignore
lowerCAmelCase_ : Any = (
tmp_node.value # type: ignore
) # Assigns the value to the node to delete and keep tree structure
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Node | None ) -> Iterable:
'''simple docstring'''
if node is not None:
yield node # Preorder Traversal
yield from self.preorder_traverse(node.left )
yield from self.preorder_traverse(node.right )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Dict=None ) -> Any:
'''simple docstring'''
if traversal_function is None:
return self.preorder_traverse(self.root )
else:
return traversal_function(self.root )
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : list ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if node:
self.inorder(lowerCAmelCase__ ,node.left )
arr.append(node.value )
self.inorder(lowerCAmelCase__ ,node.right )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Node ) -> int:
'''simple docstring'''
lowerCAmelCase_ : list[int] = []
self.inorder(lowerCAmelCase__ ,lowerCAmelCase__ ) # append all values to list using inorder traversal
return arr[k - 1]
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[Any] = []
if curr_node is not None:
lowerCAmelCase_ : Dict = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
return node_list
def UpperCamelCase ( ):
lowerCAmelCase_ : Tuple = (8, 3, 6, 1, 10, 14, 13, 4, 7)
lowerCAmelCase_ : Tuple = BinarySearchTree()
for i in testlist:
t.insert(snake_case__)
# Prints all the elements of the list in order traversal
print(snake_case__)
if t.search(6) is not None:
print("The value 6 exists")
else:
print("The value 6 doesn't exist")
if t.search(-1) is not None:
print("The value -1 exists")
else:
print("The value -1 doesn't exist")
if not t.empty():
print("Max Value: " , t.get_max().value) # type: ignore
print("Min Value: " , t.get_min().value) # type: ignore
for i in testlist:
t.remove(snake_case__)
print(snake_case__)
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
| 708 |
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
_lowercase = {
'''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
'''processing_git''': ['''GitProcessor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''GitForCausalLM''',
'''GitModel''',
'''GitPreTrainedModel''',
'''GitVisionModel''',
]
if TYPE_CHECKING:
from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
from .processing_git import GitProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_git import (
GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
GitForCausalLM,
GitModel,
GitPreTrainedModel,
GitVisionModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 683 | 0 |
import unittest
import numpy as np
from transformers import is_flax_available
from transformers.testing_utils import require_flax
from ..test_modeling_flax_common import ids_tensor
if is_flax_available():
import jax
import jax.numpy as jnp
from transformers.generation import (
FlaxForcedBOSTokenLogitsProcessor,
FlaxForcedEOSTokenLogitsProcessor,
FlaxLogitsProcessorList,
FlaxMinLengthLogitsProcessor,
FlaxTemperatureLogitsWarper,
FlaxTopKLogitsWarper,
FlaxTopPLogitsWarper,
)
@require_flax
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Any = jnp.ones((batch_size, length) ) / length
return scores
def UpperCAmelCase_ ( self : List[str] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Any = None
lowerCAmelCase_ : Any = 20
lowerCAmelCase_ : Optional[Any] = self._get_uniform_logits(batch_size=2 ,length=lowerCAmelCase__ )
# tweak scores to not be uniform anymore
lowerCAmelCase_ : List[str] = scores.at[1, 5].set((1 / length) + 0.1 ) # peak, 1st batch
lowerCAmelCase_ : Union[str, Any] = scores.at[1, 10].set((1 / length) - 0.4 ) # valley, 1st batch
# compute softmax
lowerCAmelCase_ : Optional[Any] = jax.nn.softmax(lowerCAmelCase__ ,axis=-1 )
lowerCAmelCase_ : Optional[Any] = FlaxTemperatureLogitsWarper(temperature=0.5 )
lowerCAmelCase_ : str = FlaxTemperatureLogitsWarper(temperature=1.3 )
lowerCAmelCase_ : int = jax.nn.softmax(temp_dist_warper_sharper(lowerCAmelCase__ ,scores.copy() ,cur_len=lowerCAmelCase__ ) ,axis=-1 )
lowerCAmelCase_ : Optional[Any] = jax.nn.softmax(temp_dist_warper_smoother(lowerCAmelCase__ ,scores.copy() ,cur_len=lowerCAmelCase__ ) ,axis=-1 )
# uniform distribution stays uniform
self.assertTrue(jnp.allclose(probs[0, :] ,warped_prob_sharp[0, :] ,atol=1e-3 ) )
self.assertTrue(jnp.allclose(probs[0, :] ,warped_prob_smooth[0, :] ,atol=1e-3 ) )
# sharp peaks get higher, valleys get lower
self.assertLess(probs[1, :].max() ,warped_prob_sharp[1, :].max() )
self.assertGreater(probs[1, :].min() ,warped_prob_sharp[1, :].min() )
# smooth peaks get lower, valleys get higher
self.assertGreater(probs[1, :].max() ,warped_prob_smooth[1, :].max() )
self.assertLess(probs[1, :].min() ,warped_prob_smooth[1, :].min() )
def UpperCAmelCase_ ( self : List[str] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = None
lowerCAmelCase_ : Dict = 10
lowerCAmelCase_ : Tuple = 2
# create ramp distribution
lowerCAmelCase_ : List[Any] = np.broadcast_to(np.arange(lowerCAmelCase__ )[None, :] ,(batch_size, vocab_size) ).copy()
lowerCAmelCase_ : int = ramp_logits[1:, : vocab_size // 2] + vocab_size
lowerCAmelCase_ : str = FlaxTopKLogitsWarper(3 )
lowerCAmelCase_ : Any = top_k_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
# check that correct tokens are filtered
self.assertListEqual(jnp.isinf(scores[0] ).tolist() ,7 * [True] + 3 * [False] )
self.assertListEqual(jnp.isinf(scores[1] ).tolist() ,2 * [True] + 3 * [False] + 5 * [True] )
# check special case
lowerCAmelCase_ : List[Any] = 5
lowerCAmelCase_ : Dict = FlaxTopKLogitsWarper(top_k=1 ,filter_value=0.0 ,min_tokens_to_keep=3 )
lowerCAmelCase_ : List[Any] = np.broadcast_to(np.arange(lowerCAmelCase__ )[None, :] ,(batch_size, length) ).copy()
lowerCAmelCase_ : List[Any] = top_k_warp_safety_check(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
# min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
self.assertListEqual((scores == 0.0).sum(axis=-1 ).tolist() ,[2, 2] )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : List[str] = None
lowerCAmelCase_ : List[str] = 10
lowerCAmelCase_ : Optional[int] = 2
# create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
lowerCAmelCase_ : Optional[Any] = np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.15, 0.3, 0.3, 0.25]] ) )
lowerCAmelCase_ : Any = FlaxTopPLogitsWarper(0.8 )
lowerCAmelCase_ : Union[str, Any] = np.exp(top_p_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ ) )
# dist should be filtered to keep min num values so that sum is >= top_p
# exp (-inf) => 0
lowerCAmelCase_ : Optional[Any] = np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.25]] )
self.assertTrue(np.allclose(lowerCAmelCase__ ,lowerCAmelCase__ ,atol=1e-3 ) )
# check edge cases with negative and extreme logits
lowerCAmelCase_ : Optional[Any] = np.broadcast_to(np.arange(lowerCAmelCase__ )[None, :] ,(batch_size, vocab_size) ).copy() - (
vocab_size // 2
)
# make ramp_logits more extreme
lowerCAmelCase_ : Optional[Any] = ramp_logits[1] * 100.0
# make sure at least 2 tokens are kept
lowerCAmelCase_ : Tuple = FlaxTopPLogitsWarper(0.9 ,min_tokens_to_keep=2 ,filter_value=0.0 )
lowerCAmelCase_ : Any = top_p_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
# first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
self.assertListEqual((filtered_dist != 0.0).sum(axis=-1 ).tolist() ,[3, 2] )
def UpperCAmelCase_ ( self : Dict ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = 20
lowerCAmelCase_ : List[str] = 4
lowerCAmelCase_ : Dict = 0
lowerCAmelCase_ : List[Any] = FlaxMinLengthLogitsProcessor(min_length=10 ,eos_token_id=lowerCAmelCase__ )
# check that min length is applied at length 5
lowerCAmelCase_ : Any = ids_tensor((batch_size, 20) ,vocab_size=20 )
lowerCAmelCase_ : Dict = 5
lowerCAmelCase_ : Any = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : int = min_dist_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist() ,4 * [-float("inf" )] )
# check that min length is not applied anymore at length 15
lowerCAmelCase_ : Union[str, Any] = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = 15
lowerCAmelCase_ : Optional[int] = min_dist_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertFalse(jnp.isinf(lowerCAmelCase__ ).any() )
def UpperCAmelCase_ ( self : int ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : int = 20
lowerCAmelCase_ : Any = 4
lowerCAmelCase_ : Dict = 0
lowerCAmelCase_ : str = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=lowerCAmelCase__ )
# check that all scores are -inf except the bos_token_id score
lowerCAmelCase_ : Any = ids_tensor((batch_size, 1) ,vocab_size=20 )
lowerCAmelCase_ : Any = 1
lowerCAmelCase_ : int = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = logits_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :] ).all() )
self.assertListEqual(scores[:, bos_token_id].tolist() ,4 * [0] ) # score for bos_token_id shold be zero
# check that bos_token_id is not forced if current length is greater than 1
lowerCAmelCase_ : List[str] = 3
lowerCAmelCase_ : Optional[Any] = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = logits_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertFalse(jnp.isinf(lowerCAmelCase__ ).any() )
def UpperCAmelCase_ ( self : Dict ) -> Union[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : Any = 20
lowerCAmelCase_ : int = 4
lowerCAmelCase_ : List[Any] = 0
lowerCAmelCase_ : Any = 5
lowerCAmelCase_ : Any = FlaxForcedEOSTokenLogitsProcessor(max_length=lowerCAmelCase__ ,eos_token_id=lowerCAmelCase__ )
# check that all scores are -inf except the eos_token_id when max_length is reached
lowerCAmelCase_ : Optional[Any] = ids_tensor((batch_size, 4) ,vocab_size=20 )
lowerCAmelCase_ : Union[str, Any] = 4
lowerCAmelCase_ : Any = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Dict = logits_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :] ).all() )
self.assertListEqual(scores[:, eos_token_id].tolist() ,4 * [0] ) # score for eos_token_id should be zero
# check that eos_token_id is not forced if max_length is not reached
lowerCAmelCase_ : Union[str, Any] = 3
lowerCAmelCase_ : Optional[int] = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = logits_processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
self.assertFalse(jnp.isinf(lowerCAmelCase__ ).any() )
def UpperCAmelCase_ ( self : Optional[int] ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = 4
lowerCAmelCase_ : Union[str, Any] = 10
lowerCAmelCase_ : List[Any] = 15
lowerCAmelCase_ : Tuple = 2
lowerCAmelCase_ : List[str] = 1
lowerCAmelCase_ : Dict = 15
# dummy input_ids and scores
lowerCAmelCase_ : List[Any] = ids_tensor((batch_size, sequence_length) ,lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = input_ids.copy()
lowerCAmelCase_ : str = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : int = scores.copy()
# instantiate all dist processors
lowerCAmelCase_ : Optional[int] = FlaxTemperatureLogitsWarper(temperature=0.5 )
lowerCAmelCase_ : List[Any] = FlaxTopKLogitsWarper(3 )
lowerCAmelCase_ : str = FlaxTopPLogitsWarper(0.8 )
# instantiate all logits processors
lowerCAmelCase_ : Any = FlaxMinLengthLogitsProcessor(min_length=10 ,eos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = FlaxForcedEOSTokenLogitsProcessor(max_length=lowerCAmelCase__ ,eos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = 10
# no processor list
lowerCAmelCase_ : int = temp_dist_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = top_k_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = top_p_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = min_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = bos_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = eos_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
# with processor list
lowerCAmelCase_ : Dict = FlaxLogitsProcessorList(
[temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc] )
lowerCAmelCase_ : List[str] = processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
# scores should be equal
self.assertTrue(jnp.allclose(lowerCAmelCase__ ,lowerCAmelCase__ ,atol=1e-3 ) )
# input_ids should never be changed
self.assertListEqual(input_ids.tolist() ,input_ids_comp.tolist() )
def UpperCAmelCase_ ( self : List[str] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Any = 4
lowerCAmelCase_ : Dict = 10
lowerCAmelCase_ : int = 15
lowerCAmelCase_ : Union[str, Any] = 2
lowerCAmelCase_ : Dict = 1
lowerCAmelCase_ : List[Any] = 15
# dummy input_ids and scores
lowerCAmelCase_ : str = ids_tensor((batch_size, sequence_length) ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = input_ids.copy()
lowerCAmelCase_ : Optional[int] = self._get_uniform_logits(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = scores.copy()
# instantiate all dist processors
lowerCAmelCase_ : Optional[Any] = FlaxTemperatureLogitsWarper(temperature=0.5 )
lowerCAmelCase_ : List[Any] = FlaxTopKLogitsWarper(3 )
lowerCAmelCase_ : List[Any] = FlaxTopPLogitsWarper(0.8 )
# instantiate all logits processors
lowerCAmelCase_ : str = FlaxMinLengthLogitsProcessor(min_length=10 ,eos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = FlaxForcedBOSTokenLogitsProcessor(bos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = FlaxForcedEOSTokenLogitsProcessor(max_length=lowerCAmelCase__ ,eos_token_id=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = 10
# no processor list
def run_no_processor_list(lowerCAmelCase__ : Optional[Any] ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Union[str, Any] ):
lowerCAmelCase_ : Union[str, Any] = temp_dist_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = top_k_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Any = top_p_warp(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = min_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = bos_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = eos_dist_proc(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
return scores
# with processor list
def run_processor_list(lowerCAmelCase__ : str ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Union[str, Any] ):
lowerCAmelCase_ : List[Any] = FlaxLogitsProcessorList(
[temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc] )
lowerCAmelCase_ : Any = processor(lowerCAmelCase__ ,lowerCAmelCase__ ,cur_len=lowerCAmelCase__ )
return scores
lowerCAmelCase_ : Any = jax.jit(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = jax.jit(lowerCAmelCase__ )
lowerCAmelCase_ : str = jitted_run_no_processor_list(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = jitted_run_processor_list(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
# scores should be equal
self.assertTrue(jnp.allclose(lowerCAmelCase__ ,lowerCAmelCase__ ,atol=1e-3 ) )
# input_ids should never be changed
self.assertListEqual(input_ids.tolist() ,input_ids_comp.tolist() )
| 709 |
from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments
def UpperCamelCase ( ):
lowerCAmelCase_ : List[str] = HfArgumentParser(snake_case__)
lowerCAmelCase_ : List[Any] = parser.parse_args_into_dataclasses()[0]
lowerCAmelCase_ : Optional[int] = TensorFlowBenchmark(args=snake_case__)
try:
lowerCAmelCase_ : Tuple = parser.parse_args_into_dataclasses()[0]
except ValueError as e:
lowerCAmelCase_ : Union[str, Any] = "Arg --no_{0} is no longer used, please use --no-{0} instead."
lowerCAmelCase_ : Tuple = " ".join(str(snake_case__).split(" ")[:-1])
lowerCAmelCase_ : Union[str, Any] = ""
lowerCAmelCase_ : Optional[Any] = eval(str(snake_case__).split(" ")[-1])
lowerCAmelCase_ : Tuple = []
for arg in depreciated_args:
# arg[2:] removes '--'
if arg[2:] in TensorFlowBenchmark.deprecated_args:
# arg[5:] removes '--no_'
full_error_msg += arg_error_msg.format(arg[5:])
else:
wrong_args.append(snake_case__)
if len(snake_case__) > 0:
lowerCAmelCase_ : Optional[Any] = full_error_msg + begin_error_msg + str(snake_case__)
raise ValueError(snake_case__)
benchmark.run()
if __name__ == "__main__":
main()
| 683 | 0 |
'''simple docstring'''
import argparse
import collections
import json
import os
import re
import string
import sys
import numpy as np
_lowercase = re.compile(r'''\b(a|an|the)\b''', re.UNICODE)
_lowercase = None
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = argparse.ArgumentParser("Official evaluation script for SQuAD version 2.0.")
parser.add_argument("data_file" , metavar="data.json" , help="Input data JSON file.")
parser.add_argument("pred_file" , metavar="pred.json" , help="Model predictions.")
parser.add_argument(
"--out-file" , "-o" , metavar="eval.json" , help="Write accuracy metrics to file (default is stdout).")
parser.add_argument(
"--na-prob-file" , "-n" , metavar="na_prob.json" , help="Model estimates of probability of no answer.")
parser.add_argument(
"--na-prob-thresh" , "-t" , type=snake_case__ , default=1.0 , help="Predict \"\" if no-answer probability exceeds this (default = 1.0)." , )
parser.add_argument(
"--out-image-dir" , "-p" , metavar="out_images" , default=snake_case__ , help="Save precision-recall curves to directory.")
parser.add_argument("--verbose" , "-v" , action="store_true")
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
return parser.parse_args()
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : str = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : Dict = bool(qa["answers"]["text"])
return qid_to_has_ans
def UpperCamelCase ( snake_case__):
def remove_articles(snake_case__):
return ARTICLES_REGEX.sub(" " , snake_case__)
def white_space_fix(snake_case__):
return " ".join(text.split())
def remove_punc(snake_case__):
lowerCAmelCase_ : Optional[int] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(snake_case__):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(snake_case__))))
def UpperCamelCase ( snake_case__):
if not s:
return []
return normalize_answer(snake_case__).split()
def UpperCamelCase ( snake_case__ , snake_case__):
return int(normalize_answer(snake_case__) == normalize_answer(snake_case__))
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = get_tokens(snake_case__)
lowerCAmelCase_ : Union[str, Any] = get_tokens(snake_case__)
lowerCAmelCase_ : Any = collections.Counter(snake_case__) & collections.Counter(snake_case__)
lowerCAmelCase_ : Dict = sum(common.values())
if len(snake_case__) == 0 or len(snake_case__) == 0:
# If either is no-answer, then F1 is 1 if they agree, 0 otherwise
return int(gold_toks == pred_toks)
if num_same == 0:
return 0
lowerCAmelCase_ : List[Any] = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : int = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : List[Any] = (2 * precision * recall) / (precision + recall)
return fa
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Tuple = {}
lowerCAmelCase_ : int = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : int = qa["id"]
lowerCAmelCase_ : Any = [t for t in qa["answers"]["text"] if normalize_answer(snake_case__)]
if not gold_answers:
# For unanswerable questions, only correct answer is empty string
lowerCAmelCase_ : Any = [""]
if qid not in preds:
print(F'''Missing prediction for {qid}''')
continue
lowerCAmelCase_ : Tuple = preds[qid]
# Take max over all gold answers
lowerCAmelCase_ : Any = max(compute_exact(snake_case__ , snake_case__) for a in gold_answers)
lowerCAmelCase_ : Optional[Any] = max(compute_fa(snake_case__ , snake_case__) for a in gold_answers)
return exact_scores, fa_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = {}
for qid, s in scores.items():
lowerCAmelCase_ : List[Any] = na_probs[qid] > na_prob_thresh
if pred_na:
lowerCAmelCase_ : List[str] = float(not qid_to_has_ans[qid])
else:
lowerCAmelCase_ : Union[str, Any] = s
return new_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None):
if not qid_list:
lowerCAmelCase_ : Any = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores.values()) / total),
("f1", 100.0 * sum(fa_scores.values()) / total),
("total", total),
])
else:
lowerCAmelCase_ : Tuple = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores[k] for k in qid_list) / total),
("f1", 100.0 * sum(fa_scores[k] for k in qid_list) / total),
("total", total),
])
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
for k in new_eval:
lowerCAmelCase_ : Union[str, Any] = new_eval[k]
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
plt.step(snake_case__ , snake_case__ , color="b" , alpha=0.2 , where="post")
plt.fill_between(snake_case__ , snake_case__ , step="post" , alpha=0.2 , color="b")
plt.xlabel("Recall")
plt.ylabel("Precision")
plt.xlim([0.0, 1.05])
plt.ylim([0.0, 1.05])
plt.title(snake_case__)
plt.savefig(snake_case__)
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__=None , snake_case__=None):
lowerCAmelCase_ : List[Any] = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
lowerCAmelCase_ : Dict = 0.0
lowerCAmelCase_ : int = 1.0
lowerCAmelCase_ : List[str] = 0.0
lowerCAmelCase_ : Tuple = [1.0]
lowerCAmelCase_ : Tuple = [0.0]
lowerCAmelCase_ : Dict = 0.0
for i, qid in enumerate(snake_case__):
if qid_to_has_ans[qid]:
true_pos += scores[qid]
lowerCAmelCase_ : str = true_pos / float(i + 1)
lowerCAmelCase_ : Union[str, Any] = true_pos / float(snake_case__)
if i == len(snake_case__) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]:
# i.e., if we can put a threshold after this point
avg_prec += cur_p * (cur_r - recalls[-1])
precisions.append(snake_case__)
recalls.append(snake_case__)
if out_image:
plot_pr_curve(snake_case__ , snake_case__ , snake_case__ , snake_case__)
return {"ap": 100.0 * avg_prec}
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
if out_image_dir and not os.path.exists(snake_case__):
os.makedirs(snake_case__)
lowerCAmelCase_ : Any = sum(1 for v in qid_to_has_ans.values() if v)
if num_true_pos == 0:
return
lowerCAmelCase_ : Any = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_exact.png") , title="Precision-Recall curve for Exact Match score" , )
lowerCAmelCase_ : Dict = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_f1.png") , title="Precision-Recall curve for F1 score" , )
lowerCAmelCase_ : Dict = {k: float(snake_case__) for k, v in qid_to_has_ans.items()}
lowerCAmelCase_ : str = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_oracle.png") , title="Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)" , )
merge_eval(snake_case__ , snake_case__ , "pr_exact")
merge_eval(snake_case__ , snake_case__ , "pr_f1")
merge_eval(snake_case__ , snake_case__ , "pr_oracle")
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
if not qid_list:
return
lowerCAmelCase_ : Optional[Any] = [na_probs[k] for k in qid_list]
lowerCAmelCase_ : Dict = np.ones_like(snake_case__) / float(len(snake_case__))
plt.hist(snake_case__ , weights=snake_case__ , bins=20 , range=(0.0, 1.0))
plt.xlabel("Model probability of no-answer")
plt.ylabel("Proportion of dataset")
plt.title(F'''Histogram of no-answer probability: {name}''')
plt.savefig(os.path.join(snake_case__ , F'''na_prob_hist_{name}.png'''))
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = sum(1 for k in qid_to_has_ans if not qid_to_has_ans[k])
lowerCAmelCase_ : str = num_no_ans
lowerCAmelCase_ : List[str] = cur_score
lowerCAmelCase_ : List[Any] = 0.0
lowerCAmelCase_ : str = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
for i, qid in enumerate(snake_case__):
if qid not in scores:
continue
if qid_to_has_ans[qid]:
lowerCAmelCase_ : Union[str, Any] = scores[qid]
else:
if preds[qid]:
lowerCAmelCase_ : List[Any] = -1
else:
lowerCAmelCase_ : List[str] = 0
cur_score += diff
if cur_score > best_score:
lowerCAmelCase_ : Optional[Any] = cur_score
lowerCAmelCase_ : Optional[int] = na_probs[qid]
return 100.0 * best_score / len(snake_case__), best_thresh
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : Dict = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = best_exact
lowerCAmelCase_ : List[str] = exact_thresh
lowerCAmelCase_ : Any = best_fa
lowerCAmelCase_ : List[str] = fa_thresh
def UpperCamelCase ( ):
with open(OPTS.data_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
lowerCAmelCase_ : List[Any] = dataset_json["data"]
with open(OPTS.pred_file) as f:
lowerCAmelCase_ : int = json.load(snake_case__)
if OPTS.na_prob_file:
with open(OPTS.na_prob_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
else:
lowerCAmelCase_ : List[Any] = {k: 0.0 for k in preds}
lowerCAmelCase_ : Tuple = make_qid_to_has_ans(snake_case__) # maps qid to True/False
lowerCAmelCase_ : Any = [k for k, v in qid_to_has_ans.items() if v]
lowerCAmelCase_ : List[str] = [k for k, v in qid_to_has_ans.items() if not v]
lowerCAmelCase_ : Dict = get_raw_scores(snake_case__ , snake_case__)
lowerCAmelCase_ : str = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Dict = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__)
if has_ans_qids:
lowerCAmelCase_ : str = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "HasAns")
if no_ans_qids:
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "NoAns")
if OPTS.na_prob_file:
find_all_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__)
if OPTS.na_prob_file and OPTS.out_image_dir:
run_precision_recall_analysis(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , OPTS.out_image_dir)
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "hasAns")
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "noAns")
if OPTS.out_file:
with open(OPTS.out_file , "w") as f:
json.dump(snake_case__ , snake_case__)
else:
print(json.dumps(snake_case__ , indent=2))
if __name__ == "__main__":
_lowercase = parse_args()
if OPTS.out_image_dir:
import matplotlib
matplotlib.use('''Agg''')
import matplotlib.pyplot as plt
main()
| 710 |
_lowercase = {
0: '''0''',
1: '''1''',
2: '''2''',
3: '''3''',
4: '''4''',
5: '''5''',
6: '''6''',
7: '''7''',
8: '''8''',
9: '''9''',
10: '''a''',
11: '''b''',
12: '''c''',
13: '''d''',
14: '''e''',
15: '''f''',
}
def UpperCamelCase ( snake_case__):
assert type(snake_case__) in (int, float) and decimal == int(snake_case__)
lowerCAmelCase_ : Optional[Any] = int(snake_case__)
lowerCAmelCase_ : Tuple = ""
lowerCAmelCase_ : str = False
if decimal < 0:
lowerCAmelCase_ : Tuple = True
decimal *= -1
while decimal > 0:
lowerCAmelCase_ , lowerCAmelCase_ : Any = divmod(snake_case__ , 16)
lowerCAmelCase_ : Dict = values[remainder] + hexadecimal
lowerCAmelCase_ : List[str] = "0x" + hexadecimal
if negative:
lowerCAmelCase_ : Optional[Any] = "-" + hexadecimal
return hexadecimal
if __name__ == "__main__":
import doctest
doctest.testmod()
| 683 | 0 |
import collections
import os
from typing import List, Optional, Tuple
from transformers.utils import is_jieba_available, requires_backends
if is_jieba_available():
import jieba
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.txt'''}
_lowercase = {
'''vocab_file''': {
'''openbmb/cpm-ant-10b''': '''https://huggingface.co/openbmb/cpm-ant-10b/blob/main/vocab.txt''',
},
}
_lowercase = {
'''openbmb/cpm-ant-10b''': 1024,
}
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Any = collections.OrderedDict()
with open(snake_case__ , "r" , encoding="utf-8") as reader:
lowerCAmelCase_ : Any = reader.readlines()
for index, token in enumerate(snake_case__):
lowerCAmelCase_ : Optional[int] = token.rstrip("\n")
lowerCAmelCase_ : Union[str, Any] = index
return vocab
class __snake_case ( snake_case__ ):
"""simple docstring"""
def __init__( self : Any ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Any="<unk>" ,lowerCAmelCase__ : Union[str, Any]=2_00 ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = vocab
lowerCAmelCase_ : Any = unk_token
lowerCAmelCase_ : List[str] = max_input_chars_per_word
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Dict ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : str = list(lowerCAmelCase__ )
if len(lowerCAmelCase__ ) > self.max_input_chars_per_word:
return [self.unk_token]
lowerCAmelCase_ : Tuple = 0
lowerCAmelCase_ : Union[str, Any] = []
while start < len(lowerCAmelCase__ ):
lowerCAmelCase_ : List[Any] = len(lowerCAmelCase__ )
lowerCAmelCase_ : str = None
while start < end:
lowerCAmelCase_ : int = "".join(chars[start:end] )
if substr in self.vocab:
lowerCAmelCase_ : Dict = substr
break
end -= 1
if cur_substr is None:
sub_tokens.append(self.unk_token )
start += 1
else:
sub_tokens.append(lowerCAmelCase__ )
lowerCAmelCase_ : Any = end
return sub_tokens
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = ['input_ids', 'attention_mask']
UpperCamelCase_ = False
def __init__( self : Union[str, Any] ,lowerCAmelCase__ : Tuple ,lowerCAmelCase__ : List[str]="<d>" ,lowerCAmelCase__ : Union[str, Any]="</d>" ,lowerCAmelCase__ : str="<s>" ,lowerCAmelCase__ : List[Any]="</s>" ,lowerCAmelCase__ : str="<pad>" ,lowerCAmelCase__ : List[str]="<unk>" ,lowerCAmelCase__ : int="</n>" ,lowerCAmelCase__ : Optional[int]="</_>" ,lowerCAmelCase__ : List[Any]="left" ,**lowerCAmelCase__ : Tuple ,) -> Optional[int]:
'''simple docstring'''
requires_backends(self ,["jieba"] )
super().__init__(
bod_token=lowerCAmelCase__ ,eod_token=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,line_token=lowerCAmelCase__ ,space_token=lowerCAmelCase__ ,padding_side=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : List[str] = bod_token
lowerCAmelCase_ : Tuple = eod_token
lowerCAmelCase_ : Tuple = load_vocab(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = self.encoder[space_token]
lowerCAmelCase_ : Optional[Any] = self.encoder[line_token]
del self.encoder[space_token]
del self.encoder[line_token]
lowerCAmelCase_ : Tuple = collections.OrderedDict(sorted(self.encoder.items() ,key=lambda lowerCAmelCase__ : x[1] ) )
lowerCAmelCase_ : List[Any] = {v: k for k, v in self.encoder.items()}
lowerCAmelCase_ : Union[str, Any] = WordpieceTokenizer(vocab=self.encoder ,unk_token=self.unk_token )
@property
def UpperCAmelCase_ ( self : Dict ) -> Any:
'''simple docstring'''
return self.encoder[self.bod_token]
@property
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[Any]:
'''simple docstring'''
return self.encoder[self.eod_token]
@property
def UpperCAmelCase_ ( self : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
return self.encoder["\n"]
@property
def UpperCAmelCase_ ( self : List[Any] ) -> int:
'''simple docstring'''
return len(self.encoder )
def UpperCAmelCase_ ( self : str ) -> Dict:
'''simple docstring'''
return dict(self.encoder ,**self.added_tokens_encoder )
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Dict ) -> str:
'''simple docstring'''
lowerCAmelCase_ : Tuple = []
for x in jieba.cut(lowerCAmelCase__ ,cut_all=lowerCAmelCase__ ):
output_tokens.extend(self.wordpiece_tokenizer.tokenize(lowerCAmelCase__ ) )
return output_tokens
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : Any ,**lowerCAmelCase__ : Union[str, Any] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : int = [i for i in token_ids if i >= 0]
lowerCAmelCase_ : List[Any] = [
x for x in token_ids if x != self.pad_token_id and x != self.eos_token_id and x != self.bos_token_id
]
return super()._decode(lowerCAmelCase__ ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
return token in self.encoder
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : List[str] ) -> str:
'''simple docstring'''
return "".join(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
return self.encoder.get(lowerCAmelCase__ ,self.encoder.get(self.unk_token ) )
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : List[str] ) -> str:
'''simple docstring'''
return self.decoder.get(lowerCAmelCase__ ,self.unk_token )
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
if os.path.isdir(lowerCAmelCase__ ):
lowerCAmelCase_ : List[str] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
else:
lowerCAmelCase_ : List[str] = (filename_prefix + "-" if filename_prefix else "") + save_directory
lowerCAmelCase_ : str = 0
if " " in self.encoder:
lowerCAmelCase_ : str = self.encoder[" "]
del self.encoder[" "]
if "\n" in self.encoder:
lowerCAmelCase_ : List[str] = self.encoder["\n"]
del self.encoder["\n"]
lowerCAmelCase_ : str = collections.OrderedDict(sorted(self.encoder.items() ,key=lambda lowerCAmelCase__ : x[1] ) )
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
for token, token_index in self.encoder.items():
if index != token_index:
logger.warning(
f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'''
" Please check that the vocabulary is not corrupted!" )
lowerCAmelCase_ : Dict = token_index
writer.write(token + "\n" )
index += 1
return (vocab_file,)
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : List[int] = None ) -> List[int]:
'''simple docstring'''
if token_ids_a is None:
return [self.bos_token_id] + token_ids_a
return [self.bos_token_id] + token_ids_a + [self.bos_token_id] + token_ids_a
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ,lowerCAmelCase__ : bool = False ) -> List[int]:
'''simple docstring'''
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 not None:
return [1] + ([0] * len(lowerCAmelCase__ )) + [1] + ([0] * len(lowerCAmelCase__ ))
return [1] + ([0] * len(lowerCAmelCase__ ))
| 711 |
from pathlib import Path
from typing import List
from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
_lowercase = ['''text''', '''image''', '''audio''']
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : int = []
for input_type in input_types:
if input_type == "text":
inputs.append("Text input")
elif input_type == "image":
inputs.append(
Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO")) / "000000039769.png").resize((5_12, 5_12)))
elif input_type == "audio":
inputs.append(torch.ones(30_00))
elif isinstance(snake_case__ , snake_case__):
inputs.append(create_inputs(snake_case__))
else:
raise ValueError(F'''Invalid type requested: {input_type}''')
return inputs
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : List[Any] = []
for output in outputs:
if isinstance(snake_case__ , (str, AgentText)):
output_types.append("text")
elif isinstance(snake_case__ , (Image.Image, AgentImage)):
output_types.append("image")
elif isinstance(snake_case__ , (torch.Tensor, AgentAudio)):
output_types.append("audio")
else:
raise ValueError(F'''Invalid output: {output}''')
return output_types
@is_tool_test
class __snake_case :
"""simple docstring"""
def UpperCAmelCase_ ( self : int ) -> int:
'''simple docstring'''
self.assertTrue(hasattr(self.tool ,"inputs" ) )
self.assertTrue(hasattr(self.tool ,"outputs" ) )
lowerCAmelCase_ : List[Any] = self.tool.inputs
for _input in inputs:
if isinstance(_input ,lowerCAmelCase__ ):
for __input in _input:
self.assertTrue(__input in authorized_types )
else:
self.assertTrue(_input in authorized_types )
lowerCAmelCase_ : Any = self.tool.outputs
for _output in outputs:
self.assertTrue(_output in authorized_types )
def UpperCAmelCase_ ( self : List[Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Any = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
# There is a single output
if len(self.tool.outputs ) == 1:
lowerCAmelCase_ : Optional[int] = [outputs]
self.assertListEqual(output_types(lowerCAmelCase__ ) ,self.tool.outputs )
def UpperCAmelCase_ ( self : int ) -> Any:
'''simple docstring'''
self.assertTrue(hasattr(self.tool ,"description" ) )
self.assertTrue(hasattr(self.tool ,"default_checkpoint" ) )
self.assertTrue(self.tool.description.startswith("This is a tool that" ) )
def UpperCAmelCase_ ( self : List[Any] ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
if not isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : str = [outputs]
self.assertEqual(len(lowerCAmelCase__ ) ,len(self.tool.outputs ) )
for output, output_type in zip(lowerCAmelCase__ ,self.tool.outputs ):
lowerCAmelCase_ : Tuple = AGENT_TYPE_MAPPING[output_type]
self.assertTrue(isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) )
def UpperCAmelCase_ ( self : Any ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Tuple = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = []
for _input, input_type in zip(lowerCAmelCase__ ,self.tool.inputs ):
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] )
else:
_inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) )
# Should not raise an error
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
if not isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : int = [outputs]
self.assertEqual(len(lowerCAmelCase__ ) ,len(self.tool.outputs ) )
| 683 | 0 |
import json
import os
import re
import unittest
from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = CodeGenTokenizer
UpperCamelCase_ = CodeGenTokenizerFast
UpperCamelCase_ = True
UpperCamelCase_ = {'add_prefix_space': True}
UpperCamelCase_ = False
def UpperCAmelCase_ ( self : str ) -> Tuple:
'''simple docstring'''
super().setUp()
# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
lowerCAmelCase_ : Optional[Any] = [
"l",
"o",
"w",
"e",
"r",
"s",
"t",
"i",
"d",
"n",
"\u0120",
"\u0120l",
"\u0120n",
"\u0120lo",
"\u0120low",
"er",
"\u0120lowest",
"\u0120newer",
"\u0120wider",
"<unk>",
"<|endoftext|>",
]
lowerCAmelCase_ : int = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : Dict = ["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
lowerCAmelCase_ : List[Any] = {"unk_token": "<unk>"}
lowerCAmelCase_ : List[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = 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 UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : str ) -> int:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizer.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : Optional[Any] ) -> Tuple:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizerFast.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = "lower newer"
lowerCAmelCase_ : Tuple = "lower newer"
return input_text, output_text
def UpperCAmelCase_ ( self : Optional[Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer(self.vocab_file ,self.merges_file ,**self.special_tokens_map )
lowerCAmelCase_ : Dict = "lower newer"
lowerCAmelCase_ : Dict = ["\u0120low", "er", "\u0120", "n", "e", "w", "er"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokens + [tokenizer.unk_token]
lowerCAmelCase_ : Union[str, Any] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : List[str] ) -> Optional[Any]:
'''simple docstring'''
if not self.test_rust_tokenizer:
return
lowerCAmelCase_ : Tuple = self.get_tokenizer()
lowerCAmelCase_ : Optional[int] = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = "lower newer"
# Testing tokenization
lowerCAmelCase_ : Tuple = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.tokenize(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids without special tokens
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids with special tokens
lowerCAmelCase_ : int = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = rust_tokenizer.encode(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing the unknown token
lowerCAmelCase_ : Union[str, Any] = tokens + [rust_tokenizer.unk_token]
lowerCAmelCase_ : List[str] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,*lowerCAmelCase__ : List[str] ,**lowerCAmelCase__ : Optional[Any] ) -> List[str]:
'''simple docstring'''
pass
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Any=15 ) -> str:
'''simple docstring'''
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
lowerCAmelCase_ : Any = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__ ,**lowerCAmelCase__ )
# Simple input
lowerCAmelCase_ : int = "This is a simple input"
lowerCAmelCase_ : Dict = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : str = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : Optional[int] = [
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
]
# Simple input tests
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = CodeGenTokenizer.from_pretrained(self.tmpdirname ,pad_token="<pad>" )
# Simple input
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : List[str] = ["This is a simple input looooooooong", "This is a simple input"]
lowerCAmelCase_ : Any = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : List[str] = [
("This is a simple input loooooong", "This is a simple input"),
("This is a simple pair loooooong", "This is a simple pair"),
]
lowerCAmelCase_ : Dict = tokenizer.pad_token_id
lowerCAmelCase_ : Union[str, Any] = tokenizer(lowerCAmelCase__ ,padding="max_length" ,max_length=30 ,return_tensors="np" )
lowerCAmelCase_ : Tuple = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
lowerCAmelCase_ : Any = tokenizer(*lowerCAmelCase__ ,padding="max_length" ,max_length=60 ,return_tensors="np" )
lowerCAmelCase_ : Optional[int] = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
# s
# test single string max_length padding
self.assertEqual(out_s["input_ids"].shape[-1] ,30 )
self.assertTrue(pad_token_id in out_s["input_ids"] )
self.assertTrue(0 in out_s["attention_mask"] )
# s2
# test automatic padding
self.assertEqual(out_sa["input_ids"].shape[-1] ,33 )
# long slice doesn't have padding
self.assertFalse(pad_token_id in out_sa["input_ids"][0] )
self.assertFalse(0 in out_sa["attention_mask"][0] )
# short slice does have padding
self.assertTrue(pad_token_id in out_sa["input_ids"][1] )
self.assertTrue(0 in out_sa["attention_mask"][1] )
# p
# test single pair max_length padding
self.assertEqual(out_p["input_ids"].shape[-1] ,60 )
self.assertTrue(pad_token_id in out_p["input_ids"] )
self.assertTrue(0 in out_p["attention_mask"] )
# p2
# test automatic padding pair
self.assertEqual(out_pa["input_ids"].shape[-1] ,52 )
# long slice pair doesn't have padding
self.assertFalse(pad_token_id in out_pa["input_ids"][0] )
self.assertFalse(0 in out_pa["attention_mask"][0] )
# short slice pair does have padding
self.assertTrue(pad_token_id in out_pa["input_ids"][1] )
self.assertTrue(0 in out_pa["attention_mask"][1] )
def UpperCAmelCase_ ( self : Union[str, Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Any = "$$$"
lowerCAmelCase_ : List[str] = CodeGenTokenizer.from_pretrained(self.tmpdirname ,bos_token=lowerCAmelCase__ ,add_bos_token=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : Union[str, Any] = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : int = tokenizer.bos_token_id
lowerCAmelCase_ : List[Any] = tokenizer(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokenizer(lowerCAmelCase__ )
self.assertEqual(out_s.input_ids[0] ,lowerCAmelCase__ )
self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids ) )
lowerCAmelCase_ : List[str] = tokenizer.decode(out_s.input_ids )
lowerCAmelCase_ : Optional[Any] = tokenizer.batch_decode(out_sa.input_ids )
self.assertEqual(decode_s.split()[0] ,lowerCAmelCase__ )
self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa ) )
@slow
def UpperCAmelCase_ ( self : Any ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer.from_pretrained("Salesforce/codegen-350M-mono" )
lowerCAmelCase_ : str = "\nif len_a > len_b:\n result = a\nelse:\n result = b\n\n\n\n#"
lowerCAmelCase_ : int = "\nif len_a > len_b: result = a\nelse: result = b"
lowerCAmelCase_ : Dict = tokenizer.encode(lowerCAmelCase__ )
lowerCAmelCase_ : str = ["^#", re.escape("<|endoftext|>" ), "^'''", "^\"\"\"", "\n\n\n"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.decode(lowerCAmelCase__ ,truncate_before_pattern=lowerCAmelCase__ )
self.assertEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
pass | 712 |
import pytest
_lowercase = '''__dummy_dataset1__'''
_lowercase = '''
import json
import os
import datasets
REPO_URL = "https://huggingface.co/datasets/albertvillanova/tests-raw-jsonl/resolve/main/"
URLS = {"train": REPO_URL + "wikiann-bn-train.jsonl", "validation": REPO_URL + "wikiann-bn-validation.jsonl"}
class __DummyDataset1__(datasets.GeneratorBasedBuilder):
def _info(self):
features = datasets.Features(
{
"tokens": datasets.Sequence(datasets.Value("string")),
"ner_tags": datasets.Sequence(
datasets.features.ClassLabel(
names=[
"O",
"B-PER",
"I-PER",
"B-ORG",
"I-ORG",
"B-LOC",
"I-LOC",
]
)
),
"langs": datasets.Sequence(datasets.Value("string")),
"spans": datasets.Sequence(datasets.Value("string")),
}
)
return datasets.DatasetInfo(features=features)
def _split_generators(self, dl_manager):
dl_path = dl_manager.download(URLS)
return [
datasets.SplitGenerator(datasets.Split.TRAIN, gen_kwargs={"filepath": dl_path["train"]}),
datasets.SplitGenerator(datasets.Split.VALIDATION, gen_kwargs={"filepath": dl_path["validation"]}),
]
def _generate_examples(self, filepath):
with open(filepath, "r", encoding="utf-8") as f:
for i, line in enumerate(f):
yield i, json.loads(line)
'''
@pytest.fixture
def UpperCamelCase ( ):
return DATASET_LOADING_SCRIPT_NAME
@pytest.fixture
def UpperCamelCase ( ):
return DATASET_LOADING_SCRIPT_CODE
@pytest.fixture
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = dataset_loading_script_name
lowerCAmelCase_ : List[str] = tmp_path / "datasets" / script_name
script_dir.mkdir(parents=snake_case__)
lowerCAmelCase_ : List[Any] = script_dir / F'''{script_name}.py'''
with open(snake_case__ , "w") as f:
f.write(snake_case__)
return str(snake_case__)
| 683 | 0 |
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 ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = TextToVideoSDPipeline
UpperCamelCase_ = TEXT_TO_IMAGE_PARAMS
UpperCamelCase_ = TEXT_TO_IMAGE_BATCH_PARAMS
# No `output_type`.
UpperCamelCase_ = frozenset(
[
'num_inference_steps',
'generator',
'latents',
'return_dict',
'callback',
'callback_steps',
] )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Dict:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : Union[str, Any] = 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 ,)
lowerCAmelCase_ : Tuple = DDIMScheduler(
beta_start=0.00_085 ,beta_end=0.012 ,beta_schedule="scaled_linear" ,clip_sample=lowerCAmelCase__ ,set_alpha_to_one=lowerCAmelCase__ ,)
torch.manual_seed(0 )
lowerCAmelCase_ : int = AutoencoderKL(
block_out_channels=[32, 64] ,in_channels=3 ,out_channels=3 ,down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"] ,up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"] ,latent_channels=4 ,sample_size=1_28 ,)
torch.manual_seed(0 )
lowerCAmelCase_ : Optional[int] = CLIPTextConfig(
bos_token_id=0 ,eos_token_id=2 ,hidden_size=32 ,intermediate_size=37 ,layer_norm_eps=1e-0_5 ,num_attention_heads=4 ,num_hidden_layers=5 ,pad_token_id=1 ,vocab_size=10_00 ,hidden_act="gelu" ,projection_dim=5_12 ,)
lowerCAmelCase_ : Dict = CLIPTextModel(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )
lowerCAmelCase_ : int = {
"unet": unet,
"scheduler": scheduler,
"vae": vae,
"text_encoder": text_encoder,
"tokenizer": tokenizer,
}
return components
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : List[str]=0 ) -> Optional[int]:
'''simple docstring'''
if str(lowerCAmelCase__ ).startswith("mps" ):
lowerCAmelCase_ : Union[str, Any] = torch.manual_seed(lowerCAmelCase__ )
else:
lowerCAmelCase_ : Optional[int] = torch.Generator(device=lowerCAmelCase__ ).manual_seed(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = {
"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 UpperCAmelCase_ ( self : Optional[int] ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Tuple = "cpu" # ensure determinism for the device-dependent torch.Generator
lowerCAmelCase_ : List[str] = self.get_dummy_components()
lowerCAmelCase_ : int = TextToVideoSDPipeline(**lowerCAmelCase__ )
lowerCAmelCase_ : Any = sd_pipe.to(lowerCAmelCase__ )
sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = self.get_dummy_inputs(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = "np"
lowerCAmelCase_ : Dict = sd_pipe(**lowerCAmelCase__ ).frames
lowerCAmelCase_ : int = frames[0][-3:, -3:, -1]
assert frames[0].shape == (64, 64, 3)
lowerCAmelCase_ : Optional[Any] = np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
def UpperCAmelCase_ ( self : List[str] ) -> Dict:
'''simple docstring'''
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 UpperCAmelCase_ ( self : Dict ) -> List[str]:
'''simple docstring'''
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 UpperCAmelCase_ ( self : Dict ) -> Dict:
'''simple docstring'''
pass
@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline." )
def UpperCAmelCase_ ( self : Union[str, Any] ) -> Optional[int]:
'''simple docstring'''
pass
@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline." )
def UpperCAmelCase_ ( self : Any ) -> Union[str, Any]:
'''simple docstring'''
pass
def UpperCAmelCase_ ( self : Optional[Any] ) -> Tuple:
'''simple docstring'''
return super().test_progress_bar()
@slow
@skip_mps
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : str ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : str = load_numpy(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy" )
lowerCAmelCase_ : int = TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b" )
lowerCAmelCase_ : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
lowerCAmelCase_ : Optional[Any] = pipe.to("cuda" )
lowerCAmelCase_ : List[str] = "Spiderman is surfing"
lowerCAmelCase_ : str = torch.Generator(device="cpu" ).manual_seed(0 )
lowerCAmelCase_ : Any = pipe(lowerCAmelCase__ ,generator=lowerCAmelCase__ ,num_inference_steps=25 ,output_type="pt" ).frames
lowerCAmelCase_ : Dict = video_frames.cpu().numpy()
assert np.abs(expected_video - video ).mean() < 5e-2
def UpperCAmelCase_ ( self : int ) -> int:
'''simple docstring'''
lowerCAmelCase_ : List[str] = load_numpy(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy" )
lowerCAmelCase_ : Union[str, Any] = TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b" )
lowerCAmelCase_ : str = pipe.to("cuda" )
lowerCAmelCase_ : str = "Spiderman is surfing"
lowerCAmelCase_ : Union[str, Any] = torch.Generator(device="cpu" ).manual_seed(0 )
lowerCAmelCase_ : List[str] = pipe(lowerCAmelCase__ ,generator=lowerCAmelCase__ ,num_inference_steps=2 ,output_type="pt" ).frames
lowerCAmelCase_ : Optional[Any] = video_frames.cpu().numpy()
assert np.abs(expected_video - video ).mean() < 5e-2
| 713 |
import json
import os
import re
import unittest
from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = CodeGenTokenizer
UpperCamelCase_ = CodeGenTokenizerFast
UpperCamelCase_ = True
UpperCamelCase_ = {'add_prefix_space': True}
UpperCamelCase_ = False
def UpperCAmelCase_ ( self : str ) -> Tuple:
'''simple docstring'''
super().setUp()
# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
lowerCAmelCase_ : Optional[Any] = [
"l",
"o",
"w",
"e",
"r",
"s",
"t",
"i",
"d",
"n",
"\u0120",
"\u0120l",
"\u0120n",
"\u0120lo",
"\u0120low",
"er",
"\u0120lowest",
"\u0120newer",
"\u0120wider",
"<unk>",
"<|endoftext|>",
]
lowerCAmelCase_ : int = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : Dict = ["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
lowerCAmelCase_ : List[Any] = {"unk_token": "<unk>"}
lowerCAmelCase_ : List[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = 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 UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : str ) -> int:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizer.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : Optional[Any] ) -> Tuple:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizerFast.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = "lower newer"
lowerCAmelCase_ : Tuple = "lower newer"
return input_text, output_text
def UpperCAmelCase_ ( self : Optional[Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer(self.vocab_file ,self.merges_file ,**self.special_tokens_map )
lowerCAmelCase_ : Dict = "lower newer"
lowerCAmelCase_ : Dict = ["\u0120low", "er", "\u0120", "n", "e", "w", "er"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokens + [tokenizer.unk_token]
lowerCAmelCase_ : Union[str, Any] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : List[str] ) -> Optional[Any]:
'''simple docstring'''
if not self.test_rust_tokenizer:
return
lowerCAmelCase_ : Tuple = self.get_tokenizer()
lowerCAmelCase_ : Optional[int] = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = "lower newer"
# Testing tokenization
lowerCAmelCase_ : Tuple = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.tokenize(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids without special tokens
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids with special tokens
lowerCAmelCase_ : int = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = rust_tokenizer.encode(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing the unknown token
lowerCAmelCase_ : Union[str, Any] = tokens + [rust_tokenizer.unk_token]
lowerCAmelCase_ : List[str] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,*lowerCAmelCase__ : List[str] ,**lowerCAmelCase__ : Optional[Any] ) -> List[str]:
'''simple docstring'''
pass
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Any=15 ) -> str:
'''simple docstring'''
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
lowerCAmelCase_ : Any = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__ ,**lowerCAmelCase__ )
# Simple input
lowerCAmelCase_ : int = "This is a simple input"
lowerCAmelCase_ : Dict = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : str = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : Optional[int] = [
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
]
# Simple input tests
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = CodeGenTokenizer.from_pretrained(self.tmpdirname ,pad_token="<pad>" )
# Simple input
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : List[str] = ["This is a simple input looooooooong", "This is a simple input"]
lowerCAmelCase_ : Any = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : List[str] = [
("This is a simple input loooooong", "This is a simple input"),
("This is a simple pair loooooong", "This is a simple pair"),
]
lowerCAmelCase_ : Dict = tokenizer.pad_token_id
lowerCAmelCase_ : Union[str, Any] = tokenizer(lowerCAmelCase__ ,padding="max_length" ,max_length=30 ,return_tensors="np" )
lowerCAmelCase_ : Tuple = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
lowerCAmelCase_ : Any = tokenizer(*lowerCAmelCase__ ,padding="max_length" ,max_length=60 ,return_tensors="np" )
lowerCAmelCase_ : Optional[int] = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
# s
# test single string max_length padding
self.assertEqual(out_s["input_ids"].shape[-1] ,30 )
self.assertTrue(pad_token_id in out_s["input_ids"] )
self.assertTrue(0 in out_s["attention_mask"] )
# s2
# test automatic padding
self.assertEqual(out_sa["input_ids"].shape[-1] ,33 )
# long slice doesn't have padding
self.assertFalse(pad_token_id in out_sa["input_ids"][0] )
self.assertFalse(0 in out_sa["attention_mask"][0] )
# short slice does have padding
self.assertTrue(pad_token_id in out_sa["input_ids"][1] )
self.assertTrue(0 in out_sa["attention_mask"][1] )
# p
# test single pair max_length padding
self.assertEqual(out_p["input_ids"].shape[-1] ,60 )
self.assertTrue(pad_token_id in out_p["input_ids"] )
self.assertTrue(0 in out_p["attention_mask"] )
# p2
# test automatic padding pair
self.assertEqual(out_pa["input_ids"].shape[-1] ,52 )
# long slice pair doesn't have padding
self.assertFalse(pad_token_id in out_pa["input_ids"][0] )
self.assertFalse(0 in out_pa["attention_mask"][0] )
# short slice pair does have padding
self.assertTrue(pad_token_id in out_pa["input_ids"][1] )
self.assertTrue(0 in out_pa["attention_mask"][1] )
def UpperCAmelCase_ ( self : Union[str, Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Any = "$$$"
lowerCAmelCase_ : List[str] = CodeGenTokenizer.from_pretrained(self.tmpdirname ,bos_token=lowerCAmelCase__ ,add_bos_token=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : Union[str, Any] = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : int = tokenizer.bos_token_id
lowerCAmelCase_ : List[Any] = tokenizer(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokenizer(lowerCAmelCase__ )
self.assertEqual(out_s.input_ids[0] ,lowerCAmelCase__ )
self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids ) )
lowerCAmelCase_ : List[str] = tokenizer.decode(out_s.input_ids )
lowerCAmelCase_ : Optional[Any] = tokenizer.batch_decode(out_sa.input_ids )
self.assertEqual(decode_s.split()[0] ,lowerCAmelCase__ )
self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa ) )
@slow
def UpperCAmelCase_ ( self : Any ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer.from_pretrained("Salesforce/codegen-350M-mono" )
lowerCAmelCase_ : str = "\nif len_a > len_b:\n result = a\nelse:\n result = b\n\n\n\n#"
lowerCAmelCase_ : int = "\nif len_a > len_b: result = a\nelse: result = b"
lowerCAmelCase_ : Dict = tokenizer.encode(lowerCAmelCase__ )
lowerCAmelCase_ : str = ["^#", re.escape("<|endoftext|>" ), "^'''", "^\"\"\"", "\n\n\n"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.decode(lowerCAmelCase__ ,truncate_before_pattern=lowerCAmelCase__ )
self.assertEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
pass
| 683 | 0 |
import numpy as np
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = int(np.ceil((x_end - xa) / h))
lowerCAmelCase_ : int = np.zeros((n + 1,))
lowerCAmelCase_ : Optional[int] = ya
lowerCAmelCase_ : Optional[Any] = xa
for k in range(snake_case__):
lowerCAmelCase_ : int = f(snake_case__ , y[k])
lowerCAmelCase_ : Any = f(x + 0.5 * h , y[k] + 0.5 * h * ka)
lowerCAmelCase_ : Dict = f(x + 0.5 * h , y[k] + 0.5 * h * ka)
lowerCAmelCase_ : Tuple = f(x + h , y[k] + h * ka)
lowerCAmelCase_ : Optional[int] = y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
x += h
return y
if __name__ == "__main__":
import doctest
doctest.testmod()
| 714 |
from __future__ import annotations
from random import random
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[int] ,lowerCAmelCase__ : int | None = None ) -> int:
'''simple docstring'''
lowerCAmelCase_ : Dict = value
lowerCAmelCase_ : Any = random()
lowerCAmelCase_ : Node | None = None
lowerCAmelCase_ : Node | None = None
def __repr__( self : Any ) -> str:
'''simple docstring'''
from pprint import pformat
if self.left is None and self.right is None:
return f'''\'{self.value}: {self.prior:.5}\''''
else:
return pformat(
{f'''{self.value}: {self.prior:.5}''': (self.left, self.right)} ,indent=1 )
def __str__( self : str ) -> str:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = str(self.value ) + " "
lowerCAmelCase_ : List[Any] = str(self.left or "" )
lowerCAmelCase_ : Union[str, Any] = str(self.right or "" )
return value + left + right
def UpperCamelCase ( snake_case__ , snake_case__):
if root is None: # None tree is split into 2 Nones
return None, None
elif root.value is None:
return None, None
else:
if value < root.value:
lowerCAmelCase_ , lowerCAmelCase_ : Any = split(root.left , snake_case__)
return left, root
else:
lowerCAmelCase_ , lowerCAmelCase_ : Optional[Any] = split(root.right , snake_case__)
return root, right
def UpperCamelCase ( snake_case__ , snake_case__):
if (not left) or (not right): # If one node is None, return the other
return left or right
elif left.prior < right.prior:
lowerCAmelCase_ : Dict = merge(left.right , snake_case__)
return left
else:
lowerCAmelCase_ : List[str] = merge(snake_case__ , right.left)
return right
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = Node(snake_case__)
lowerCAmelCase_ , lowerCAmelCase_ : Tuple = split(snake_case__ , snake_case__)
return merge(merge(snake_case__ , snake_case__) , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ , lowerCAmelCase_ : List[str] = split(snake_case__ , value - 1)
lowerCAmelCase_ , lowerCAmelCase_ : Union[str, Any] = split(snake_case__ , snake_case__)
return merge(snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__):
if not root: # None
return
else:
inorder(root.left)
print(root.value , end=",")
inorder(root.right)
def UpperCamelCase ( snake_case__ , snake_case__):
for arg in args.split():
if arg[0] == "+":
lowerCAmelCase_ : List[str] = insert(snake_case__ , int(arg[1:]))
elif arg[0] == "-":
lowerCAmelCase_ : Optional[int] = erase(snake_case__ , int(arg[1:]))
else:
print("Unknown command")
return root
def UpperCamelCase ( ):
lowerCAmelCase_ : str = None
print(
"enter numbers to create a tree, + value to add value into treap, "
"- value to erase all nodes with value. 'q' to quit. ")
lowerCAmelCase_ : str = input()
while args != "q":
lowerCAmelCase_ : int = interact_treap(snake_case__ , snake_case__)
print(snake_case__)
lowerCAmelCase_ : str = input()
print("good by!")
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 683 | 0 |
import argparse
import json
import os
from tensorflow.core.protobuf.saved_model_pba import SavedModel
# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
_lowercase = '''.'''
# Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model)
_lowercase = [
'''Assert''',
'''AssignVariableOp''',
'''EmptyTensorList''',
'''MergeV2Checkpoints''',
'''ReadVariableOp''',
'''ResourceGather''',
'''RestoreV2''',
'''SaveV2''',
'''ShardedFilename''',
'''StatefulPartitionedCall''',
'''StaticRegexFullMatch''',
'''VarHandleOp''',
]
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = SavedModel()
lowerCAmelCase_ : List[Any] = []
with open(os.path.join(snake_case__ , "utils" , "tf_ops" , "onnx.json")) as f:
lowerCAmelCase_ : List[Any] = json.load(snake_case__)["opsets"]
for i in range(1 , opset + 1):
onnx_ops.extend(onnx_opsets[str(snake_case__)])
with open(snake_case__ , "rb") as f:
saved_model.ParseFromString(f.read())
lowerCAmelCase_ : Tuple = set()
# Iterate over every metagraph in case there is more than one (a saved model can contain multiple graphs)
for meta_graph in saved_model.meta_graphs:
# Add operations in the graph definition
model_op_names.update(node.op for node in meta_graph.graph_def.node)
# Go through the functions in the graph definition
for func in meta_graph.graph_def.library.function:
# Add operations in each function
model_op_names.update(node.op for node in func.node_def)
# Convert to list, sorted if you want
lowerCAmelCase_ : Optional[Any] = sorted(snake_case__)
lowerCAmelCase_ : List[str] = []
for op in model_op_names:
if op not in onnx_ops and op not in INTERNAL_OPS:
incompatible_ops.append(snake_case__)
if strict and len(snake_case__) > 0:
raise Exception(F'''Found the following incompatible ops for the opset {opset}:\n''' + incompatible_ops)
elif len(snake_case__) > 0:
print(F'''Found the following incompatible ops for the opset {opset}:''')
print(*snake_case__ , sep="\n")
else:
print(F'''The saved model {saved_model_path} can properly be converted with ONNX.''')
if __name__ == "__main__":
_lowercase = argparse.ArgumentParser()
parser.add_argument('''--saved_model_path''', help='''Path of the saved model to check (the .pb file).''')
parser.add_argument(
'''--opset''', default=12, type=int, help='''The ONNX opset against which the model has to be tested.'''
)
parser.add_argument(
'''--framework''', choices=['''onnx'''], default='''onnx''', help='''Frameworks against which to test the saved model.'''
)
parser.add_argument(
'''--strict''', action='''store_true''', help='''Whether make the checking strict (raise errors) or not (raise warnings)'''
)
_lowercase = parser.parse_args()
if args.framework == "onnx":
onnx_compliancy(args.saved_model_path, args.strict, args.opset)
| 715 |
import json
from typing import List, Optional, Tuple
from tokenizers import normalizers
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}
_lowercase = [
'''small''',
'''small-base''',
'''medium''',
'''medium-base''',
'''intermediate''',
'''intermediate-base''',
'''large''',
'''large-base''',
'''xlarge''',
'''xlarge-base''',
]
_lowercase = {
'''vocab_file''': {
'''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt''',
'''funnel-transformer/small-base''': '''https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt''',
'''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt''',
'''funnel-transformer/medium-base''': (
'''https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'''
),
'''funnel-transformer/intermediate''': (
'''https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'''
),
'''funnel-transformer/intermediate-base''': (
'''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'''
),
'''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt''',
'''funnel-transformer/large-base''': '''https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt''',
'''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt''',
'''funnel-transformer/xlarge-base''': (
'''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'''
),
},
'''tokenizer_file''': {
'''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json''',
'''funnel-transformer/small-base''': (
'''https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json''',
'''funnel-transformer/medium-base''': (
'''https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/intermediate''': (
'''https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'''
),
'''funnel-transformer/intermediate-base''': (
'''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json''',
'''funnel-transformer/large-base''': (
'''https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json''',
'''funnel-transformer/xlarge-base''': (
'''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'''
),
},
}
_lowercase = {f"funnel-transformer/{name}": 512 for name in _model_names}
_lowercase = {f"funnel-transformer/{name}": {'''do_lower_case''': True} for name in _model_names}
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_INIT_CONFIGURATION
UpperCamelCase_ = FunnelTokenizer
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = 2
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Any=None ,lowerCAmelCase__ : Optional[int]=None ,lowerCAmelCase__ : Optional[Any]=True ,lowerCAmelCase__ : List[str]="<unk>" ,lowerCAmelCase__ : int="<sep>" ,lowerCAmelCase__ : Union[str, Any]="<pad>" ,lowerCAmelCase__ : List[str]="<cls>" ,lowerCAmelCase__ : Optional[int]="<mask>" ,lowerCAmelCase__ : Union[str, Any]="<s>" ,lowerCAmelCase__ : List[str]="</s>" ,lowerCAmelCase__ : Optional[int]=True ,lowerCAmelCase__ : Tuple=True ,lowerCAmelCase__ : Any=None ,lowerCAmelCase__ : List[Any]="##" ,**lowerCAmelCase__ : int ,) -> List[Any]:
'''simple docstring'''
super().__init__(
lowerCAmelCase__ ,tokenizer_file=lowerCAmelCase__ ,do_lower_case=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,sep_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,cls_token=lowerCAmelCase__ ,mask_token=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,clean_text=lowerCAmelCase__ ,tokenize_chinese_chars=lowerCAmelCase__ ,strip_accents=lowerCAmelCase__ ,wordpieces_prefix=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : str = json.loads(self.backend_tokenizer.normalizer.__getstate__() )
if (
normalizer_state.get("lowercase" ,lowerCAmelCase__ ) != do_lower_case
or normalizer_state.get("strip_accents" ,lowerCAmelCase__ ) != strip_accents
or normalizer_state.get("handle_chinese_chars" ,lowerCAmelCase__ ) != tokenize_chinese_chars
):
lowerCAmelCase_ : Optional[int] = getattr(lowerCAmelCase__ ,normalizer_state.pop("type" ) )
lowerCAmelCase_ : List[Any] = do_lower_case
lowerCAmelCase_ : List[str] = strip_accents
lowerCAmelCase_ : Any = tokenize_chinese_chars
lowerCAmelCase_ : List[Any] = normalizer_class(**lowerCAmelCase__ )
lowerCAmelCase_ : int = do_lower_case
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : int ,lowerCAmelCase__ : str=None ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = [self.cls_token_id] + token_ids_a + [self.sep_token_id]
if token_ids_a:
output += token_ids_a + [self.sep_token_id]
return output
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : str = [self.sep_token_id]
lowerCAmelCase_ : Optional[Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0]
return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
lowerCAmelCase_ : str = self._tokenizer.model.save(lowerCAmelCase__ ,name=lowerCAmelCase__ )
return tuple(lowerCAmelCase__ )
| 683 | 0 |
import json
import os
from typing import Optional, Tuple
import regex as re
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {
'''vocab_file''': '''vocab.json''',
'''merges_file''': '''merges.txt''',
}
_lowercase = {
'''vocab_file''': {'''ctrl''': '''https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json'''},
'''merges_file''': {'''ctrl''': '''https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt'''},
}
_lowercase = {
'''ctrl''': 256,
}
_lowercase = {
'''Pregnancy''': 168629,
'''Christianity''': 7675,
'''Explain''': 106423,
'''Fitness''': 63440,
'''Saving''': 63163,
'''Ask''': 27171,
'''Ass''': 95985,
'''Joke''': 163509,
'''Questions''': 45622,
'''Thoughts''': 49605,
'''Retail''': 52342,
'''Feminism''': 164338,
'''Writing''': 11992,
'''Atheism''': 192263,
'''Netflix''': 48616,
'''Computing''': 39639,
'''Opinion''': 43213,
'''Alone''': 44967,
'''Funny''': 58917,
'''Gaming''': 40358,
'''Human''': 4088,
'''India''': 1331,
'''Joker''': 77138,
'''Diet''': 36206,
'''Legal''': 11859,
'''Norman''': 4939,
'''Tip''': 72689,
'''Weight''': 52343,
'''Movies''': 46273,
'''Running''': 23425,
'''Science''': 2090,
'''Horror''': 37793,
'''Confession''': 60572,
'''Finance''': 12250,
'''Politics''': 16360,
'''Scary''': 191985,
'''Support''': 12654,
'''Technologies''': 32516,
'''Teenage''': 66160,
'''Event''': 32769,
'''Learned''': 67460,
'''Notion''': 182770,
'''Wikipedia''': 37583,
'''Books''': 6665,
'''Extract''': 76050,
'''Confessions''': 102701,
'''Conspiracy''': 75932,
'''Links''': 63674,
'''Narcissus''': 150425,
'''Relationship''': 54766,
'''Relationships''': 134796,
'''Reviews''': 41671,
'''News''': 4256,
'''Translation''': 26820,
'''multilingual''': 128406,
}
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Tuple = set()
lowerCAmelCase_ : Optional[Any] = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
lowerCAmelCase_ : str = char
lowerCAmelCase_ : Union[str, Any] = set(snake_case__)
return pairs
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = CONTROL_CODES
def __init__( self : Optional[int] ,lowerCAmelCase__ : Any ,lowerCAmelCase__ : Any ,lowerCAmelCase__ : Any="<unk>" ,**lowerCAmelCase__ : int ) -> List[str]:
'''simple docstring'''
super().__init__(unk_token=lowerCAmelCase__ ,**lowerCAmelCase__ )
with open(lowerCAmelCase__ ,encoding="utf-8" ) as vocab_handle:
lowerCAmelCase_ : Dict = json.load(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = {v: k for k, v in self.encoder.items()}
with open(lowerCAmelCase__ ,encoding="utf-8" ) as merges_handle:
lowerCAmelCase_ : Optional[Any] = merges_handle.read().split("\n" )[1:-1]
lowerCAmelCase_ : Optional[int] = [tuple(merge.split() ) for merge in merges]
lowerCAmelCase_ : List[str] = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : int = {}
@property
def UpperCAmelCase_ ( self : Tuple ) -> List[str]:
'''simple docstring'''
return len(self.encoder )
def UpperCAmelCase_ ( self : List[Any] ) -> Any:
'''simple docstring'''
return dict(self.encoder ,**self.added_tokens_encoder )
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Tuple ) -> int:
'''simple docstring'''
if token in self.cache:
return self.cache[token]
lowerCAmelCase_ : Any = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tuple(list(word[:-1] ) + [word[-1] + "</w>"] )
lowerCAmelCase_ : List[Any] = get_pairs(lowerCAmelCase__ )
if not pairs:
return token
while True:
lowerCAmelCase_ : Optional[int] = min(lowerCAmelCase__ ,key=lambda lowerCAmelCase__ : self.bpe_ranks.get(lowerCAmelCase__ ,float("inf" ) ) )
if bigram not in self.bpe_ranks:
break
lowerCAmelCase_ : Optional[Any] = bigram
lowerCAmelCase_ : List[str] = []
lowerCAmelCase_ : Any = 0
while i < len(lowerCAmelCase__ ):
try:
lowerCAmelCase_ : Optional[Any] = word.index(lowerCAmelCase__ ,lowerCAmelCase__ )
except ValueError:
new_word.extend(word[i:] )
break
else:
new_word.extend(word[i:j] )
lowerCAmelCase_ : str = j
if word[i] == first and i < len(lowerCAmelCase__ ) - 1 and word[i + 1] == second:
new_word.append(first + second )
i += 2
else:
new_word.append(word[i] )
i += 1
lowerCAmelCase_ : List[Any] = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = new_word
if len(lowerCAmelCase__ ) == 1:
break
else:
lowerCAmelCase_ : int = get_pairs(lowerCAmelCase__ )
lowerCAmelCase_ : Any = "@@ ".join(lowerCAmelCase__ )
lowerCAmelCase_ : Any = word[:-4]
lowerCAmelCase_ : Optional[Any] = word
return word
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Tuple ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = []
lowerCAmelCase_ : Optional[Any] = re.findall(R"\S+\n?" ,lowerCAmelCase__ )
for token in words:
split_tokens.extend(list(self.bpe(lowerCAmelCase__ ).split(" " ) ) )
return split_tokens
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Optional[Any] ) -> Union[str, Any]:
'''simple docstring'''
return self.encoder.get(lowerCAmelCase__ ,self.encoder.get(self.unk_token ) )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ) -> Any:
'''simple docstring'''
return self.decoder.get(lowerCAmelCase__ ,self.unk_token )
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : str ) -> int:
'''simple docstring'''
lowerCAmelCase_ : List[str] = " ".join(lowerCAmelCase__ ).replace("@@ " ,"" ).strip()
return out_string
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
if not os.path.isdir(lowerCAmelCase__ ):
logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
return
lowerCAmelCase_ : Optional[int] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as f:
f.write(json.dumps(self.encoder ,indent=2 ,sort_keys=lowerCAmelCase__ ,ensure_ascii=lowerCAmelCase__ ) + "\n" )
lowerCAmelCase_ : Optional[int] = 0
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
writer.write("#version: 0.2\n" )
for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,key=lambda lowerCAmelCase__ : kv[1] ):
if index != token_index:
logger.warning(
f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
" Please check that the tokenizer is not corrupted!" )
lowerCAmelCase_ : int = token_index
writer.write(" ".join(lowerCAmelCase__ ) + "\n" )
index += 1
return vocab_file, merge_file
# def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True):
# filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens))
# tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens)
# tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far)
# return ''.join(tokens_generated_so_far)
| 716 |
# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run
import doctest
import sys
import warnings
from os.path import abspath, dirname, join
import _pytest
from transformers.testing_utils import HfDoctestModule, HfDocTestParser
# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
_lowercase = abspath(join(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 UpperCamelCase ( snake_case__):
config.addinivalue_line(
"markers" , "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested")
config.addinivalue_line(
"markers" , "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested")
config.addinivalue_line("markers" , "is_pipeline_test: mark test to run only when pipelines are tested")
config.addinivalue_line("markers" , "is_staging_test: mark test to run only in the staging environment")
config.addinivalue_line("markers" , "accelerate_tests: mark test that require accelerate")
config.addinivalue_line("markers" , "tool_tests: mark the tool tests that are run on their specific schedule")
def UpperCamelCase ( snake_case__):
from transformers.testing_utils import pytest_addoption_shared
pytest_addoption_shared(snake_case__)
def UpperCamelCase ( snake_case__):
from transformers.testing_utils import pytest_terminal_summary_main
lowerCAmelCase_ : int = terminalreporter.config.getoption("--make-reports")
if make_reports:
pytest_terminal_summary_main(snake_case__ , id=snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__):
# If no tests are collected, pytest exists with code 5, which makes the CI fail.
if exitstatus == 5:
lowerCAmelCase_ : List[Any] = 0
# Doctest custom flag to ignore output.
_lowercase = doctest.register_optionflag('''IGNORE_RESULT''')
_lowercase = doctest.OutputChecker
class __snake_case ( snake_case__ ):
"""simple docstring"""
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Tuple ) -> Any:
'''simple docstring'''
if IGNORE_RESULT & optionflags:
return True
return OutputChecker.check_output(self ,lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
_lowercase = CustomOutputChecker
_lowercase = HfDoctestModule
_lowercase = HfDocTestParser
| 683 | 0 |
import gc
import random
import unittest
import numpy as np
import torch
from PIL import Image
from diffusers import (
DDIMScheduler,
KandinskyVaaControlnetImgaImgPipeline,
KandinskyVaaPriorEmbaEmbPipeline,
UNetaDConditionModel,
VQModel,
)
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 ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
enable_full_determinism()
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = KandinskyVaaControlnetImgaImgPipeline
UpperCamelCase_ = ['image_embeds', 'negative_image_embeds', 'image', 'hint']
UpperCamelCase_ = ['image_embeds', 'negative_image_embeds', 'image', 'hint']
UpperCamelCase_ = [
'generator',
'height',
'width',
'strength',
'guidance_scale',
'num_inference_steps',
'return_dict',
'guidance_scale',
'num_images_per_prompt',
'output_type',
'return_dict',
]
UpperCamelCase_ = False
@property
def UpperCAmelCase_ ( self : Any ) -> Tuple:
'''simple docstring'''
return 32
@property
def UpperCAmelCase_ ( self : Union[str, Any] ) -> Union[str, Any]:
'''simple docstring'''
return 32
@property
def UpperCAmelCase_ ( self : Tuple ) -> Dict:
'''simple docstring'''
return self.time_input_dim
@property
def UpperCAmelCase_ ( self : Any ) -> Union[str, Any]:
'''simple docstring'''
return self.time_input_dim * 4
@property
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[str]:
'''simple docstring'''
return 1_00
@property
def UpperCAmelCase_ ( self : Tuple ) -> str:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : Any = {
"in_channels": 8,
# Out channels is double in channels because predicts mean and variance
"out_channels": 8,
"addition_embed_type": "image_hint",
"down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
"up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
"mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
"block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
"layers_per_block": 1,
"encoder_hid_dim": self.text_embedder_hidden_size,
"encoder_hid_dim_type": "image_proj",
"cross_attention_dim": self.cross_attention_dim,
"attention_head_dim": 4,
"resnet_time_scale_shift": "scale_shift",
"class_embed_type": None,
}
lowerCAmelCase_ : List[Any] = UNetaDConditionModel(**lowerCAmelCase__ )
return model
@property
def UpperCAmelCase_ ( self : Optional[Any] ) -> Any:
'''simple docstring'''
return {
"block_out_channels": [32, 32, 64, 64],
"down_block_types": [
"DownEncoderBlock2D",
"DownEncoderBlock2D",
"DownEncoderBlock2D",
"AttnDownEncoderBlock2D",
],
"in_channels": 3,
"latent_channels": 4,
"layers_per_block": 1,
"norm_num_groups": 8,
"norm_type": "spatial",
"num_vq_embeddings": 12,
"out_channels": 3,
"up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
"vq_embed_dim": 4,
}
@property
def UpperCAmelCase_ ( self : Dict ) -> Union[str, Any]:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : List[str] = VQModel(**self.dummy_movq_kwargs )
return model
def UpperCAmelCase_ ( self : Tuple ) -> str:
'''simple docstring'''
lowerCAmelCase_ : int = self.dummy_unet
lowerCAmelCase_ : Optional[Any] = self.dummy_movq
lowerCAmelCase_ : List[str] = {
"num_train_timesteps": 10_00,
"beta_schedule": "linear",
"beta_start": 0.00_085,
"beta_end": 0.012,
"clip_sample": False,
"set_alpha_to_one": False,
"steps_offset": 0,
"prediction_type": "epsilon",
"thresholding": False,
}
lowerCAmelCase_ : Optional[Any] = DDIMScheduler(**lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = {
"unet": unet,
"scheduler": scheduler,
"movq": movq,
}
return components
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Any=0 ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(lowerCAmelCase__ ) ).to(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = floats_tensor((1, self.text_embedder_hidden_size) ,rng=random.Random(seed + 1 ) ).to(
lowerCAmelCase__ )
# create init_image
lowerCAmelCase_ : List[str] = floats_tensor((1, 3, 64, 64) ,rng=random.Random(lowerCAmelCase__ ) ).to(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = image.cpu().permute(0 ,2 ,3 ,1 )[0]
lowerCAmelCase_ : Any = Image.fromarray(np.uinta(lowerCAmelCase__ ) ).convert("RGB" ).resize((2_56, 2_56) )
# create hint
lowerCAmelCase_ : Dict = floats_tensor((1, 3, 64, 64) ,rng=random.Random(lowerCAmelCase__ ) ).to(lowerCAmelCase__ )
if str(lowerCAmelCase__ ).startswith("mps" ):
lowerCAmelCase_ : str = torch.manual_seed(lowerCAmelCase__ )
else:
lowerCAmelCase_ : int = torch.Generator(device=lowerCAmelCase__ ).manual_seed(lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = {
"image": init_image,
"image_embeds": image_embeds,
"negative_image_embeds": negative_image_embeds,
"hint": hint,
"generator": generator,
"height": 64,
"width": 64,
"num_inference_steps": 10,
"guidance_scale": 7.0,
"strength": 0.2,
"output_type": "np",
}
return inputs
def UpperCAmelCase_ ( self : Optional[Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = "cpu"
lowerCAmelCase_ : Optional[int] = self.get_dummy_components()
lowerCAmelCase_ : List[Any] = self.pipeline_class(**lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = pipe(**self.get_dummy_inputs(lowerCAmelCase__ ) )
lowerCAmelCase_ : int = output.images
lowerCAmelCase_ : Optional[Any] = pipe(
**self.get_dummy_inputs(lowerCAmelCase__ ) ,return_dict=lowerCAmelCase__ ,)[0]
lowerCAmelCase_ : List[Any] = image[0, -3:, -3:, -1]
lowerCAmelCase_ : Dict = image_from_tuple[0, -3:, -3:, -1]
assert image.shape == (1, 64, 64, 3)
lowerCAmelCase_ : Optional[int] = np.array(
[0.54_985_034, 0.55_509_365, 0.52_561_504, 0.5_570_494, 0.5_593_818, 0.5_263_979, 0.50_285_643, 0.5_069_846, 0.51_196_736] )
assert (
np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
assert (
np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2
), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''
@slow
@require_torch_gpu
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : Dict ) -> Optional[Any]:
'''simple docstring'''
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def UpperCAmelCase_ ( self : Dict ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = load_numpy(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
"/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy" )
lowerCAmelCase_ : List[Any] = load_image(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png" )
lowerCAmelCase_ : Union[str, Any] = init_image.resize((5_12, 5_12) )
lowerCAmelCase_ : List[Any] = load_image(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
"/kandinskyv22/hint_image_cat.png" )
lowerCAmelCase_ : Optional[int] = torch.from_numpy(np.array(lowerCAmelCase__ ) ).float() / 255.0
lowerCAmelCase_ : Any = hint.permute(2 ,0 ,1 ).unsqueeze(0 )
lowerCAmelCase_ : int = "A robot, 4k photo"
lowerCAmelCase_ : str = KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
"kandinsky-community/kandinsky-2-2-prior" ,torch_dtype=torch.floataa )
pipe_prior.to(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
"kandinsky-community/kandinsky-2-2-controlnet-depth" ,torch_dtype=torch.floataa )
lowerCAmelCase_ : List[str] = pipeline.to(lowerCAmelCase__ )
pipeline.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = torch.Generator(device="cpu" ).manual_seed(0 )
lowerCAmelCase_ : Tuple = pipe_prior(
lowerCAmelCase__ ,image=lowerCAmelCase__ ,strength=0.85 ,generator=lowerCAmelCase__ ,negative_prompt="" ,).to_tuple()
lowerCAmelCase_ : List[Any] = pipeline(
image=lowerCAmelCase__ ,image_embeds=lowerCAmelCase__ ,negative_image_embeds=lowerCAmelCase__ ,hint=lowerCAmelCase__ ,generator=lowerCAmelCase__ ,num_inference_steps=1_00 ,height=5_12 ,width=5_12 ,strength=0.5 ,output_type="np" ,)
lowerCAmelCase_ : Tuple = output.images[0]
assert image.shape == (5_12, 5_12, 3)
assert_mean_pixel_difference(lowerCAmelCase__ ,lowerCAmelCase__ )
| 717 |
from __future__ import annotations
from collections.abc import Sequence
from typing import Literal
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = list(snake_case__)
lowerCAmelCase_ : Tuple = list(snake_case__)
lowerCAmelCase_ : List[str] = 0
for i in range(len(snake_case__)):
if lista[i] != lista[i]:
count += 1
lowerCAmelCase_ : Dict = "_"
if count > 1:
return False
else:
return "".join(snake_case__)
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Union[str, Any] = []
while True:
lowerCAmelCase_ : Tuple = ["$"] * len(snake_case__)
lowerCAmelCase_ : Tuple = []
for i in range(len(snake_case__)):
for j in range(i + 1 , len(snake_case__)):
lowerCAmelCase_ : Optional[int] = compare_string(binary[i] , binary[j])
if k is False:
lowerCAmelCase_ : str = "*"
lowerCAmelCase_ : Tuple = "*"
temp.append("X")
for i in range(len(snake_case__)):
if checka[i] == "$":
pi.append(binary[i])
if len(snake_case__) == 0:
return pi
lowerCAmelCase_ : List[Any] = list(set(snake_case__))
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = []
for minterm in minterms:
lowerCAmelCase_ : Dict = ""
for _ in range(snake_case__):
lowerCAmelCase_ : Dict = str(minterm % 2) + string
minterm //= 2
temp.append(snake_case__)
return temp
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = list(snake_case__)
lowerCAmelCase_ : Dict = list(snake_case__)
lowerCAmelCase_ : Dict = 0
for i in range(len(snake_case__)):
if lista[i] != lista[i]:
count_n += 1
return count_n == count
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = []
lowerCAmelCase_ : Dict = [0] * len(snake_case__)
for i in range(len(chart[0])):
lowerCAmelCase_ : List[Any] = 0
lowerCAmelCase_ : int = -1
for j in range(len(snake_case__)):
if chart[j][i] == 1:
count += 1
lowerCAmelCase_ : Optional[int] = j
if count == 1:
lowerCAmelCase_ : Union[str, Any] = 1
for i in range(len(snake_case__)):
if select[i] == 1:
for j in range(len(chart[0])):
if chart[i][j] == 1:
for k in range(len(snake_case__)):
lowerCAmelCase_ : Tuple = 0
temp.append(prime_implicants[i])
while True:
lowerCAmelCase_ : Optional[Any] = 0
lowerCAmelCase_ : Dict = -1
lowerCAmelCase_ : Tuple = 0
for i in range(len(snake_case__)):
lowerCAmelCase_ : Dict = chart[i].count(1)
if count_n > max_n:
lowerCAmelCase_ : Optional[int] = count_n
lowerCAmelCase_ : Optional[Any] = i
if max_n == 0:
return temp
temp.append(prime_implicants[rem])
for i in range(len(chart[0])):
if chart[rem][i] == 1:
for j in range(len(snake_case__)):
lowerCAmelCase_ : Any = 0
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : str = [[0 for x in range(len(snake_case__))] for x in range(len(snake_case__))]
for i in range(len(snake_case__)):
lowerCAmelCase_ : Optional[Any] = prime_implicants[i].count("_")
for j in range(len(snake_case__)):
if is_for_table(prime_implicants[i] , binary[j] , snake_case__):
lowerCAmelCase_ : Dict = 1
return chart
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = int(input("Enter the no. of variables\n"))
lowerCAmelCase_ : Tuple = [
float(snake_case__)
for x in input(
"Enter the decimal representation of Minterms 'Spaces Separated'\n").split()
]
lowerCAmelCase_ : Any = decimal_to_binary(snake_case__ , snake_case__)
lowerCAmelCase_ : Dict = check(snake_case__)
print("Prime Implicants are:")
print(snake_case__)
lowerCAmelCase_ : int = prime_implicant_chart(snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = selection(snake_case__ , snake_case__)
print("Essential Prime Implicants are:")
print(snake_case__)
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 683 | 0 |
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
_lowercase = {'''configuration_vit_msn''': ['''VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ViTMSNConfig''']}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''ViTMSNModel''',
'''ViTMSNForImageClassification''',
'''ViTMSNPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_vit_msn import (
VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
ViTMSNForImageClassification,
ViTMSNModel,
ViTMSNPreTrainedModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 718 |
import logging
import os
from typing import Dict, List, Optional, Union
import torch
import torch.nn as nn
from accelerate.utils.imports import (
is_abit_bnb_available,
is_abit_bnb_available,
is_bnb_available,
)
from ..big_modeling import dispatch_model, init_empty_weights
from .dataclasses import BnbQuantizationConfig
from .modeling import (
find_tied_parameters,
get_balanced_memory,
infer_auto_device_map,
load_checkpoint_in_model,
offload_weight,
set_module_tensor_to_device,
)
if is_bnb_available():
import bitsandbytes as bnb
from copy import deepcopy
_lowercase = logging.getLogger(__name__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = False , ):
lowerCAmelCase_ : List[Any] = bnb_quantization_config.load_in_abit
lowerCAmelCase_ : Optional[Any] = bnb_quantization_config.load_in_abit
if load_in_abit and not is_abit_bnb_available():
raise ImportError(
"You have a version of `bitsandbytes` that is not compatible with 8bit quantization,"
" make sure you have the latest version of `bitsandbytes` installed.")
if load_in_abit and not is_abit_bnb_available():
raise ValueError(
"You have a version of `bitsandbytes` that is not compatible with 4bit quantization,"
"make sure you have the latest version of `bitsandbytes` installed.")
lowerCAmelCase_ : List[str] = []
# custom device map
if isinstance(snake_case__ , snake_case__) and len(device_map.keys()) > 1:
lowerCAmelCase_ : Union[str, Any] = [key for key, value in device_map.items() if value in ["disk", "cpu"]]
# We keep some modules such as the lm_head in their original dtype for numerical stability reasons
if bnb_quantization_config.skip_modules is None:
lowerCAmelCase_ : Union[str, Any] = get_keys_to_not_convert(snake_case__)
# add cpu modules to skip modules only for 4-bit modules
if load_in_abit:
bnb_quantization_config.skip_modules.extend(snake_case__)
lowerCAmelCase_ : Union[str, Any] = bnb_quantization_config.skip_modules
# We add the modules we want to keep in full precision
if bnb_quantization_config.keep_in_fpaa_modules is None:
lowerCAmelCase_ : Optional[int] = []
lowerCAmelCase_ : int = bnb_quantization_config.keep_in_fpaa_modules
modules_to_not_convert.extend(snake_case__)
# compatibility with peft
lowerCAmelCase_ : Optional[int] = load_in_abit
lowerCAmelCase_ : List[str] = load_in_abit
lowerCAmelCase_ : Optional[int] = get_parameter_device(snake_case__)
if model_device.type != "meta":
# quantization of an already loaded model
logger.warning(
"It is not recommended to quantize a loaded model. "
"The model should be instantiated under the `init_empty_weights` context manager.")
lowerCAmelCase_ : Union[str, Any] = replace_with_bnb_layers(snake_case__ , snake_case__ , modules_to_not_convert=snake_case__)
# convert param to the right dtype
lowerCAmelCase_ : Any = bnb_quantization_config.torch_dtype
for name, param in model.state_dict().items():
if any(module_to_keep_in_fpaa in name for module_to_keep_in_fpaa in keep_in_fpaa_modules):
param.to(torch.floataa)
if param.dtype != torch.floataa:
lowerCAmelCase_ : Optional[int] = name.replace(".weight" , "").replace(".bias" , "")
lowerCAmelCase_ : Optional[int] = getattr(snake_case__ , snake_case__ , snake_case__)
if param is not None:
param.to(torch.floataa)
elif torch.is_floating_point(snake_case__):
param.to(snake_case__)
if model_device.type == "cuda":
# move everything to cpu in the first place because we can't do quantization if the weights are already on cuda
model.cuda(torch.cuda.current_device())
torch.cuda.empty_cache()
elif torch.cuda.is_available():
model.to(torch.cuda.current_device())
else:
raise RuntimeError("No GPU found. A GPU is needed for quantization.")
logger.info(
F'''The model device type is {model_device.type}. However, cuda is needed for quantization.'''
"We move the model to cuda.")
return model
elif weights_location is None:
raise RuntimeError(
F'''`weights_location` needs to be the folder path containing the weights of the model, but we found {weights_location} ''')
else:
with init_empty_weights():
lowerCAmelCase_ : str = replace_with_bnb_layers(
snake_case__ , snake_case__ , modules_to_not_convert=snake_case__)
lowerCAmelCase_ : Optional[int] = get_quantized_model_device_map(
snake_case__ , snake_case__ , snake_case__ , max_memory=snake_case__ , no_split_module_classes=snake_case__ , )
if offload_state_dict is None and device_map is not None and "disk" in device_map.values():
lowerCAmelCase_ : Optional[Any] = True
lowerCAmelCase_ : Optional[int] = any(x in list(device_map.values()) for x in ["cpu", "disk"])
load_checkpoint_in_model(
snake_case__ , snake_case__ , snake_case__ , dtype=bnb_quantization_config.torch_dtype , offload_folder=snake_case__ , offload_state_dict=snake_case__ , keep_in_fpaa_modules=bnb_quantization_config.keep_in_fpaa_modules , offload_abit_bnb=load_in_abit and offload , )
return dispatch_model(snake_case__ , device_map=snake_case__ , offload_dir=snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None , snake_case__=None):
if device_map is None:
if torch.cuda.is_available():
lowerCAmelCase_ : Any = {"": torch.cuda.current_device()}
else:
raise RuntimeError("No GPU found. A GPU is needed for quantization.")
logger.info("The device_map was not initialized." "Setting device_map to `{'':torch.cuda.current_device()}`.")
if isinstance(snake_case__ , snake_case__):
if device_map not in ["auto", "balanced", "balanced_low_0", "sequential"]:
raise ValueError(
"If passing a string for `device_map`, please choose 'auto', 'balanced', 'balanced_low_0' or "
"'sequential'.")
lowerCAmelCase_ : Dict = {}
special_dtypes.update(
{
name: bnb_quantization_config.torch_dtype
for name, _ in model.named_parameters()
if any(m in name for m in bnb_quantization_config.skip_modules)
})
special_dtypes.update(
{
name: torch.floataa
for name, _ in model.named_parameters()
if any(m in name for m in bnb_quantization_config.keep_in_fpaa_modules)
})
lowerCAmelCase_ : List[str] = {}
lowerCAmelCase_ : Union[str, Any] = special_dtypes
lowerCAmelCase_ : Union[str, Any] = no_split_module_classes
lowerCAmelCase_ : Any = bnb_quantization_config.target_dtype
# get max_memory for each device.
if device_map != "sequential":
lowerCAmelCase_ : Tuple = get_balanced_memory(
snake_case__ , low_zero=(device_map == "balanced_low_0") , max_memory=snake_case__ , **snake_case__ , )
lowerCAmelCase_ : Tuple = max_memory
lowerCAmelCase_ : Optional[Any] = infer_auto_device_map(snake_case__ , **snake_case__)
if isinstance(snake_case__ , snake_case__):
# check if don't have any quantized module on the cpu
lowerCAmelCase_ : Union[str, Any] = bnb_quantization_config.skip_modules + bnb_quantization_config.keep_in_fpaa_modules
lowerCAmelCase_ : List[Any] = {
key: device_map[key] for key in device_map.keys() if key not in modules_not_to_convert
}
for device in ["cpu", "disk"]:
if device in device_map_without_some_modules.values():
if bnb_quantization_config.load_in_abit:
raise ValueError(
"\n Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM to fit\n the quantized model. If you want to dispatch the model on the CPU or the disk while keeping\n these modules in `torch_dtype`, you need to pass a custom `device_map` to\n `load_and_quantize_model`. Check\n https://huggingface.co/docs/accelerate/main/en/usage_guides/quantization#offload-modules-to-cpu-and-disk\n for more details.\n ")
else:
logger.info(
"Some modules are are offloaded to the CPU or the disk. Note that these modules will be converted to 8-bit")
del device_map_without_some_modules
return device_map
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None):
if modules_to_not_convert is None:
lowerCAmelCase_ : List[str] = []
lowerCAmelCase_ , lowerCAmelCase_ : Tuple = _replace_with_bnb_layers(
snake_case__ , snake_case__ , snake_case__ , snake_case__)
if not has_been_replaced:
logger.warning(
"You are loading your model in 8bit or 4bit but no linear modules were found in your model."
" this can happen for some architectures such as gpt2 that uses Conv1D instead of Linear layers."
" Please double check your model architecture, or submit an issue on github if you think this is"
" a bug.")
return model
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None , ):
lowerCAmelCase_ : str = False
for name, module in model.named_children():
if current_key_name is None:
lowerCAmelCase_ : Optional[int] = []
current_key_name.append(snake_case__)
if isinstance(snake_case__ , nn.Linear) and name not in modules_to_not_convert:
# Check if the current key is not in the `modules_to_not_convert`
lowerCAmelCase_ : Optional[int] = ".".join(snake_case__)
lowerCAmelCase_ : List[str] = True
for key in modules_to_not_convert:
if (
(key in current_key_name_str) and (key + "." in current_key_name_str)
) or key == current_key_name_str:
lowerCAmelCase_ : List[Any] = False
break
if proceed:
# Load bnb module with empty weight and replace ``nn.Linear` module
if bnb_quantization_config.load_in_abit:
lowerCAmelCase_ : Tuple = bnb.nn.LinearabitLt(
module.in_features , module.out_features , module.bias is not None , has_fpaa_weights=snake_case__ , threshold=bnb_quantization_config.llm_inta_threshold , )
elif bnb_quantization_config.load_in_abit:
lowerCAmelCase_ : Dict = bnb.nn.Linearabit(
module.in_features , module.out_features , module.bias is not None , bnb_quantization_config.bnb_abit_compute_dtype , compress_statistics=bnb_quantization_config.bnb_abit_use_double_quant , quant_type=bnb_quantization_config.bnb_abit_quant_type , )
else:
raise ValueError("load_in_8bit and load_in_4bit can't be both False")
lowerCAmelCase_ : List[str] = module.weight.data
if module.bias is not None:
lowerCAmelCase_ : Any = module.bias.data
bnb_module.requires_grad_(snake_case__)
setattr(snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = True
if len(list(module.children())) > 0:
lowerCAmelCase_ , lowerCAmelCase_ : List[Any] = _replace_with_bnb_layers(
snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : Optional[int] = has_been_replaced | _has_been_replaced
# Remove the last key for recursion
current_key_name.pop(-1)
return model, has_been_replaced
def UpperCamelCase ( snake_case__):
# Create a copy of the model
with init_empty_weights():
lowerCAmelCase_ : List[Any] = deepcopy(snake_case__) # this has 0 cost since it is done inside `init_empty_weights` context manager`
lowerCAmelCase_ : Dict = find_tied_parameters(snake_case__)
# For compatibility with Accelerate < 0.18
if isinstance(snake_case__ , snake_case__):
lowerCAmelCase_ : List[str] = sum(list(tied_params.values()) , []) + list(tied_params.keys())
else:
lowerCAmelCase_ : Optional[Any] = sum(snake_case__ , [])
lowerCAmelCase_ : List[Any] = len(snake_case__) > 0
# Check if it is a base model
lowerCAmelCase_ : List[str] = False
if hasattr(snake_case__ , "base_model_prefix"):
lowerCAmelCase_ : Tuple = not hasattr(snake_case__ , model.base_model_prefix)
# Ignore this for base models (BertModel, GPT2Model, etc.)
if (not has_tied_params) and is_base_model:
return []
# otherwise they have an attached head
lowerCAmelCase_ : Union[str, Any] = list(model.named_children())
lowerCAmelCase_ : Optional[int] = [list_modules[-1][0]]
# add last module together with tied weights
lowerCAmelCase_ : Any = set(snake_case__) - set(snake_case__)
lowerCAmelCase_ : Tuple = list(set(snake_case__)) + list(snake_case__)
# remove ".weight" from the keys
lowerCAmelCase_ : List[str] = [".weight", ".bias"]
lowerCAmelCase_ : Tuple = []
for name in list_untouched:
for name_to_remove in names_to_remove:
if name_to_remove in name:
lowerCAmelCase_ : str = name.replace(snake_case__ , "")
filtered_module_names.append(snake_case__)
return filtered_module_names
def UpperCamelCase ( snake_case__):
for m in model.modules():
if isinstance(snake_case__ , bnb.nn.Linearabit):
return True
return False
def UpperCamelCase ( snake_case__):
return next(parameter.parameters()).device
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
# if it is not quantized, we quantize and offload the quantized weights and the SCB stats
if fpaa_statistics is None:
set_module_tensor_to_device(snake_case__ , snake_case__ , 0 , dtype=snake_case__ , value=snake_case__)
lowerCAmelCase_ : str = param_name
lowerCAmelCase_ : Tuple = model
if "." in tensor_name:
lowerCAmelCase_ : Dict = tensor_name.split(".")
for split in splits[:-1]:
lowerCAmelCase_ : Any = getattr(snake_case__ , snake_case__)
if new_module is None:
raise ValueError(F'''{module} has no attribute {split}.''')
lowerCAmelCase_ : Union[str, Any] = new_module
lowerCAmelCase_ : Any = splits[-1]
# offload weights
lowerCAmelCase_ : List[Any] = False
offload_weight(module._parameters[tensor_name] , snake_case__ , snake_case__ , index=snake_case__)
if hasattr(module._parameters[tensor_name] , "SCB"):
offload_weight(
module._parameters[tensor_name].SCB , param_name.replace("weight" , "SCB") , snake_case__ , index=snake_case__ , )
else:
offload_weight(snake_case__ , snake_case__ , snake_case__ , index=snake_case__)
offload_weight(snake_case__ , param_name.replace("weight" , "SCB") , snake_case__ , index=snake_case__)
set_module_tensor_to_device(snake_case__ , snake_case__ , "meta" , dtype=snake_case__ , value=torch.empty(*param.size()))
| 683 | 0 |
import copy
from typing import Any, Dict, List, Optional, Union
import numpy as np
import torch
from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = ['input_features', 'is_longer']
def __init__( self : Optional[int] ,lowerCAmelCase__ : List[Any]=64 ,lowerCAmelCase__ : Any=4_80_00 ,lowerCAmelCase__ : Optional[Any]=4_80 ,lowerCAmelCase__ : List[str]=10 ,lowerCAmelCase__ : List[Any]=10_24 ,lowerCAmelCase__ : Union[str, Any]=0.0 ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : float = 0 ,lowerCAmelCase__ : float = 1_40_00 ,lowerCAmelCase__ : int = None ,lowerCAmelCase__ : str = "fusion" ,lowerCAmelCase__ : str = "repeatpad" ,**lowerCAmelCase__ : Union[str, Any] ,) -> Union[str, Any]:
'''simple docstring'''
super().__init__(
feature_size=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,padding_value=lowerCAmelCase__ ,return_attention_mask=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : Optional[Any] = top_db
lowerCAmelCase_ : str = truncation
lowerCAmelCase_ : Tuple = padding
lowerCAmelCase_ : str = fft_window_size
lowerCAmelCase_ : Dict = (fft_window_size >> 1) + 1
lowerCAmelCase_ : Dict = hop_length
lowerCAmelCase_ : Any = max_length_s
lowerCAmelCase_ : int = max_length_s * sampling_rate
lowerCAmelCase_ : Optional[int] = sampling_rate
lowerCAmelCase_ : int = frequency_min
lowerCAmelCase_ : Optional[Any] = frequency_max
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm=lowerCAmelCase__ ,mel_scale="htk" ,)
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm="slaney" ,mel_scale="slaney" ,)
def UpperCAmelCase_ ( self : Dict ) -> Dict[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : int = copy.deepcopy(self.__dict__ )
lowerCAmelCase_ : Optional[int] = self.__class__.__name__
if "mel_filters" in output:
del output["mel_filters"]
if "mel_filters_slaney" in output:
del output["mel_filters_slaney"]
return output
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Optional[np.array] = None ) -> np.ndarray:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = spectrogram(
lowerCAmelCase__ ,window_function(self.fft_window_size ,"hann" ) ,frame_length=self.fft_window_size ,hop_length=self.hop_length ,power=2.0 ,mel_filters=lowerCAmelCase__ ,log_mel="dB" ,)
return log_mel_spectrogram.T
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Tuple = np.array_split(list(range(0 ,total_frames - chunk_frames + 1 ) ) ,3 )
if len(ranges[1] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
if len(ranges[2] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
# randomly choose index for each part
lowerCAmelCase_ : str = np.random.choice(ranges[0] )
lowerCAmelCase_ : Optional[Any] = np.random.choice(ranges[1] )
lowerCAmelCase_ : Any = np.random.choice(ranges[2] )
lowerCAmelCase_ : str = mel[idx_front : idx_front + chunk_frames, :]
lowerCAmelCase_ : Dict = mel[idx_middle : idx_middle + chunk_frames, :]
lowerCAmelCase_ : Optional[Any] = mel[idx_back : idx_back + chunk_frames, :]
lowerCAmelCase_ : List[str] = torch.tensor(mel[None, None, :] )
lowerCAmelCase_ : List[Any] = torch.nn.functional.interpolate(
lowerCAmelCase__ ,size=[chunk_frames, 64] ,mode="bilinear" ,align_corners=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = mel_shrink[0][0].numpy()
lowerCAmelCase_ : str = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,axis=0 )
return mel_fusion
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : int ) -> np.array:
'''simple docstring'''
if waveform.shape[0] > max_length:
if truncation == "rand_trunc":
lowerCAmelCase_ : List[Any] = True
# random crop to max_length (for compatibility) -> this should be handled by self.pad
lowerCAmelCase_ : str = len(lowerCAmelCase__ ) - max_length
lowerCAmelCase_ : Any = np.random.randint(0 ,overflow + 1 )
lowerCAmelCase_ : Dict = waveform[idx : idx + max_length]
lowerCAmelCase_ : List[str] = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
elif truncation == "fusion":
lowerCAmelCase_ : Tuple = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : str = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed
lowerCAmelCase_ : List[str] = mel.shape[0]
if chunk_frames == total_frames:
# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
# In this case, we just use the whole audio.
lowerCAmelCase_ : Dict = np.stack([mel, mel, mel, mel] ,axis=0 )
lowerCAmelCase_ : int = False
else:
lowerCAmelCase_ : str = self._random_mel_fusion(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = True
else:
raise NotImplementedError(f'''data_truncating {truncation} not implemented''' )
else:
lowerCAmelCase_ : Dict = False
# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
if waveform.shape[0] < max_length:
if padding == "repeat":
lowerCAmelCase_ : List[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : int = np.stack(np.tile(lowerCAmelCase__ ,n_repeat + 1 ) )[:max_length]
if padding == "repeatpad":
lowerCAmelCase_ : Optional[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = np.stack(np.tile(lowerCAmelCase__ ,lowerCAmelCase__ ) )
lowerCAmelCase_ : List[Any] = np.pad(lowerCAmelCase__ ,(0, max_length - waveform.shape[0]) ,mode="constant" ,constant_values=0 )
if truncation == "fusion":
lowerCAmelCase_ : int = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : Tuple = np.stack([input_mel, input_mel, input_mel, input_mel] ,axis=0 )
else:
lowerCAmelCase_ : str = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
return input_mel, longer
def __call__( self : int ,lowerCAmelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCAmelCase__ : str = None ,lowerCAmelCase__ : Optional[str] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[Union[str, TensorType]] = None ,**lowerCAmelCase__ : List[Any] ,) -> BatchFeature:
'''simple docstring'''
lowerCAmelCase_ : List[str] = truncation if truncation is not None else self.truncation
lowerCAmelCase_ : List[Any] = padding if padding else self.padding
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
f''' was sampled with {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." )
lowerCAmelCase_ : Dict = 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}''' )
lowerCAmelCase_ : Dict = is_batched_numpy or (
isinstance(lowerCAmelCase__ ,(list, tuple) ) and (isinstance(raw_speech[0] ,(np.ndarray, tuple, list) ))
)
if is_batched:
lowerCAmelCase_ : List[str] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for speech in raw_speech]
elif not is_batched and not isinstance(lowerCAmelCase__ ,np.ndarray ):
lowerCAmelCase_ : Tuple = np.asarray(lowerCAmelCase__ ,dtype=np.floataa )
elif isinstance(lowerCAmelCase__ ,np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ):
lowerCAmelCase_ : Any = raw_speech.astype(np.floataa )
# always return batch
if not is_batched:
lowerCAmelCase_ : Any = [np.asarray(lowerCAmelCase__ )]
# convert to mel spectrogram, truncate and pad if needed.
lowerCAmelCase_ : Optional[Any] = [
self._get_input_mel(lowerCAmelCase__ ,max_length if max_length else self.nb_max_samples ,lowerCAmelCase__ ,lowerCAmelCase__ )
for waveform in raw_speech
]
lowerCAmelCase_ : str = []
lowerCAmelCase_ : str = []
for mel, longer in padded_inputs:
input_mel.append(lowerCAmelCase__ )
is_longer.append(lowerCAmelCase__ )
if truncation == "fusion" and sum(lowerCAmelCase__ ) == 0:
# if no audio is longer than 10s, then randomly select one audio to be longer
lowerCAmelCase_ : Any = np.random.randint(0 ,len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Dict = True
if isinstance(input_mel[0] ,lowerCAmelCase__ ):
lowerCAmelCase_ : Optional[int] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for feature in input_mel]
# is_longer is a list of bool
lowerCAmelCase_ : List[Any] = [[longer] for longer in is_longer]
lowerCAmelCase_ : Optional[Any] = {"input_features": input_mel, "is_longer": is_longer}
lowerCAmelCase_ : Dict = BatchFeature(lowerCAmelCase__ )
if return_tensors is not None:
lowerCAmelCase_ : List[str] = input_features.convert_to_tensors(lowerCAmelCase__ )
return input_features
| 719 |
import copy
from typing import Any, Dict, List, Optional, Union
import numpy as np
import torch
from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = ['input_features', 'is_longer']
def __init__( self : Optional[int] ,lowerCAmelCase__ : List[Any]=64 ,lowerCAmelCase__ : Any=4_80_00 ,lowerCAmelCase__ : Optional[Any]=4_80 ,lowerCAmelCase__ : List[str]=10 ,lowerCAmelCase__ : List[Any]=10_24 ,lowerCAmelCase__ : Union[str, Any]=0.0 ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : float = 0 ,lowerCAmelCase__ : float = 1_40_00 ,lowerCAmelCase__ : int = None ,lowerCAmelCase__ : str = "fusion" ,lowerCAmelCase__ : str = "repeatpad" ,**lowerCAmelCase__ : Union[str, Any] ,) -> Union[str, Any]:
'''simple docstring'''
super().__init__(
feature_size=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,padding_value=lowerCAmelCase__ ,return_attention_mask=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : Optional[Any] = top_db
lowerCAmelCase_ : str = truncation
lowerCAmelCase_ : Tuple = padding
lowerCAmelCase_ : str = fft_window_size
lowerCAmelCase_ : Dict = (fft_window_size >> 1) + 1
lowerCAmelCase_ : Dict = hop_length
lowerCAmelCase_ : Any = max_length_s
lowerCAmelCase_ : int = max_length_s * sampling_rate
lowerCAmelCase_ : Optional[int] = sampling_rate
lowerCAmelCase_ : int = frequency_min
lowerCAmelCase_ : Optional[Any] = frequency_max
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm=lowerCAmelCase__ ,mel_scale="htk" ,)
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm="slaney" ,mel_scale="slaney" ,)
def UpperCAmelCase_ ( self : Dict ) -> Dict[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : int = copy.deepcopy(self.__dict__ )
lowerCAmelCase_ : Optional[int] = self.__class__.__name__
if "mel_filters" in output:
del output["mel_filters"]
if "mel_filters_slaney" in output:
del output["mel_filters_slaney"]
return output
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Optional[np.array] = None ) -> np.ndarray:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = spectrogram(
lowerCAmelCase__ ,window_function(self.fft_window_size ,"hann" ) ,frame_length=self.fft_window_size ,hop_length=self.hop_length ,power=2.0 ,mel_filters=lowerCAmelCase__ ,log_mel="dB" ,)
return log_mel_spectrogram.T
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Tuple = np.array_split(list(range(0 ,total_frames - chunk_frames + 1 ) ) ,3 )
if len(ranges[1] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
if len(ranges[2] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
# randomly choose index for each part
lowerCAmelCase_ : str = np.random.choice(ranges[0] )
lowerCAmelCase_ : Optional[Any] = np.random.choice(ranges[1] )
lowerCAmelCase_ : Any = np.random.choice(ranges[2] )
lowerCAmelCase_ : str = mel[idx_front : idx_front + chunk_frames, :]
lowerCAmelCase_ : Dict = mel[idx_middle : idx_middle + chunk_frames, :]
lowerCAmelCase_ : Optional[Any] = mel[idx_back : idx_back + chunk_frames, :]
lowerCAmelCase_ : List[str] = torch.tensor(mel[None, None, :] )
lowerCAmelCase_ : List[Any] = torch.nn.functional.interpolate(
lowerCAmelCase__ ,size=[chunk_frames, 64] ,mode="bilinear" ,align_corners=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = mel_shrink[0][0].numpy()
lowerCAmelCase_ : str = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,axis=0 )
return mel_fusion
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : int ) -> np.array:
'''simple docstring'''
if waveform.shape[0] > max_length:
if truncation == "rand_trunc":
lowerCAmelCase_ : List[Any] = True
# random crop to max_length (for compatibility) -> this should be handled by self.pad
lowerCAmelCase_ : str = len(lowerCAmelCase__ ) - max_length
lowerCAmelCase_ : Any = np.random.randint(0 ,overflow + 1 )
lowerCAmelCase_ : Dict = waveform[idx : idx + max_length]
lowerCAmelCase_ : List[str] = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
elif truncation == "fusion":
lowerCAmelCase_ : Tuple = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : str = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed
lowerCAmelCase_ : List[str] = mel.shape[0]
if chunk_frames == total_frames:
# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
# In this case, we just use the whole audio.
lowerCAmelCase_ : Dict = np.stack([mel, mel, mel, mel] ,axis=0 )
lowerCAmelCase_ : int = False
else:
lowerCAmelCase_ : str = self._random_mel_fusion(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = True
else:
raise NotImplementedError(f'''data_truncating {truncation} not implemented''' )
else:
lowerCAmelCase_ : Dict = False
# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
if waveform.shape[0] < max_length:
if padding == "repeat":
lowerCAmelCase_ : List[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : int = np.stack(np.tile(lowerCAmelCase__ ,n_repeat + 1 ) )[:max_length]
if padding == "repeatpad":
lowerCAmelCase_ : Optional[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = np.stack(np.tile(lowerCAmelCase__ ,lowerCAmelCase__ ) )
lowerCAmelCase_ : List[Any] = np.pad(lowerCAmelCase__ ,(0, max_length - waveform.shape[0]) ,mode="constant" ,constant_values=0 )
if truncation == "fusion":
lowerCAmelCase_ : int = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : Tuple = np.stack([input_mel, input_mel, input_mel, input_mel] ,axis=0 )
else:
lowerCAmelCase_ : str = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
return input_mel, longer
def __call__( self : int ,lowerCAmelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCAmelCase__ : str = None ,lowerCAmelCase__ : Optional[str] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[Union[str, TensorType]] = None ,**lowerCAmelCase__ : List[Any] ,) -> BatchFeature:
'''simple docstring'''
lowerCAmelCase_ : List[str] = truncation if truncation is not None else self.truncation
lowerCAmelCase_ : List[Any] = padding if padding else self.padding
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
f''' was sampled with {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." )
lowerCAmelCase_ : Dict = 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}''' )
lowerCAmelCase_ : Dict = is_batched_numpy or (
isinstance(lowerCAmelCase__ ,(list, tuple) ) and (isinstance(raw_speech[0] ,(np.ndarray, tuple, list) ))
)
if is_batched:
lowerCAmelCase_ : List[str] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for speech in raw_speech]
elif not is_batched and not isinstance(lowerCAmelCase__ ,np.ndarray ):
lowerCAmelCase_ : Tuple = np.asarray(lowerCAmelCase__ ,dtype=np.floataa )
elif isinstance(lowerCAmelCase__ ,np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ):
lowerCAmelCase_ : Any = raw_speech.astype(np.floataa )
# always return batch
if not is_batched:
lowerCAmelCase_ : Any = [np.asarray(lowerCAmelCase__ )]
# convert to mel spectrogram, truncate and pad if needed.
lowerCAmelCase_ : Optional[Any] = [
self._get_input_mel(lowerCAmelCase__ ,max_length if max_length else self.nb_max_samples ,lowerCAmelCase__ ,lowerCAmelCase__ )
for waveform in raw_speech
]
lowerCAmelCase_ : str = []
lowerCAmelCase_ : str = []
for mel, longer in padded_inputs:
input_mel.append(lowerCAmelCase__ )
is_longer.append(lowerCAmelCase__ )
if truncation == "fusion" and sum(lowerCAmelCase__ ) == 0:
# if no audio is longer than 10s, then randomly select one audio to be longer
lowerCAmelCase_ : Any = np.random.randint(0 ,len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Dict = True
if isinstance(input_mel[0] ,lowerCAmelCase__ ):
lowerCAmelCase_ : Optional[int] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for feature in input_mel]
# is_longer is a list of bool
lowerCAmelCase_ : List[Any] = [[longer] for longer in is_longer]
lowerCAmelCase_ : Optional[Any] = {"input_features": input_mel, "is_longer": is_longer}
lowerCAmelCase_ : Dict = BatchFeature(lowerCAmelCase__ )
if return_tensors is not None:
lowerCAmelCase_ : List[str] = input_features.convert_to_tensors(lowerCAmelCase__ )
return input_features
| 683 | 0 |
import gc
import unittest
import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer
from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = ShapEPipeline
UpperCamelCase_ = ['prompt']
UpperCamelCase_ = ['prompt']
UpperCamelCase_ = [
'num_images_per_prompt',
'num_inference_steps',
'generator',
'latents',
'guidance_scale',
'frame_size',
'output_type',
'return_dict',
]
UpperCamelCase_ = False
@property
def UpperCAmelCase_ ( self : Dict ) -> Tuple:
'''simple docstring'''
return 32
@property
def UpperCAmelCase_ ( self : Dict ) -> Union[str, Any]:
'''simple docstring'''
return 32
@property
def UpperCAmelCase_ ( self : str ) -> Optional[int]:
'''simple docstring'''
return self.time_input_dim * 4
@property
def UpperCAmelCase_ ( self : List[Any] ) -> Any:
'''simple docstring'''
return 8
@property
def UpperCAmelCase_ ( self : Optional[int] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )
return tokenizer
@property
def UpperCAmelCase_ ( self : int ) -> str:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : int = CLIPTextConfig(
bos_token_id=0 ,eos_token_id=2 ,hidden_size=self.text_embedder_hidden_size ,projection_dim=self.text_embedder_hidden_size ,intermediate_size=37 ,layer_norm_eps=1e-0_5 ,num_attention_heads=4 ,num_hidden_layers=5 ,pad_token_id=1 ,vocab_size=10_00 ,)
return CLIPTextModelWithProjection(lowerCAmelCase__ )
@property
def UpperCAmelCase_ ( self : List[Any] ) -> Dict:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : Union[str, Any] = {
"num_attention_heads": 2,
"attention_head_dim": 16,
"embedding_dim": self.time_input_dim,
"num_embeddings": 32,
"embedding_proj_dim": self.text_embedder_hidden_size,
"time_embed_dim": self.time_embed_dim,
"num_layers": 1,
"clip_embed_dim": self.time_input_dim * 2,
"additional_embeddings": 0,
"time_embed_act_fn": "gelu",
"norm_in_type": "layer",
"encoder_hid_proj_type": None,
"added_emb_type": None,
}
lowerCAmelCase_ : Optional[int] = PriorTransformer(**lowerCAmelCase__ )
return model
@property
def UpperCAmelCase_ ( self : str ) -> str:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : int = {
"param_shapes": (
(self.renderer_dim, 93),
(self.renderer_dim, 8),
(self.renderer_dim, 8),
(self.renderer_dim, 8),
),
"d_latent": self.time_input_dim,
"d_hidden": self.renderer_dim,
"n_output": 12,
"background": (
0.1,
0.1,
0.1,
),
}
lowerCAmelCase_ : Any = ShapERenderer(**lowerCAmelCase__ )
return model
def UpperCAmelCase_ ( self : Dict ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : int = self.dummy_prior
lowerCAmelCase_ : Optional[int] = self.dummy_text_encoder
lowerCAmelCase_ : Tuple = self.dummy_tokenizer
lowerCAmelCase_ : Any = self.dummy_renderer
lowerCAmelCase_ : List[Any] = HeunDiscreteScheduler(
beta_schedule="exp" ,num_train_timesteps=10_24 ,prediction_type="sample" ,use_karras_sigmas=lowerCAmelCase__ ,clip_sample=lowerCAmelCase__ ,clip_sample_range=1.0 ,)
lowerCAmelCase_ : Union[str, Any] = {
"prior": prior,
"text_encoder": text_encoder,
"tokenizer": tokenizer,
"renderer": renderer,
"scheduler": scheduler,
}
return components
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Any ,lowerCAmelCase__ : str=0 ) -> Union[str, Any]:
'''simple docstring'''
if str(lowerCAmelCase__ ).startswith("mps" ):
lowerCAmelCase_ : int = torch.manual_seed(lowerCAmelCase__ )
else:
lowerCAmelCase_ : List[Any] = torch.Generator(device=lowerCAmelCase__ ).manual_seed(lowerCAmelCase__ )
lowerCAmelCase_ : str = {
"prompt": "horse",
"generator": generator,
"num_inference_steps": 1,
"frame_size": 32,
"output_type": "np",
}
return inputs
def UpperCAmelCase_ ( self : str ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = "cpu"
lowerCAmelCase_ : Optional[Any] = self.get_dummy_components()
lowerCAmelCase_ : str = self.pipeline_class(**lowerCAmelCase__ )
lowerCAmelCase_ : str = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : str = pipe(**self.get_dummy_inputs(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = output.images[0]
lowerCAmelCase_ : List[Any] = image[0, -3:, -3:, -1]
assert image.shape == (20, 32, 32, 3)
lowerCAmelCase_ : List[str] = np.array(
[
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
0.00_039_216,
] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
def UpperCAmelCase_ ( self : Any ) -> int:
'''simple docstring'''
self._test_inference_batch_consistent(batch_sizes=[1, 2] )
def UpperCAmelCase_ ( self : Dict ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : str = torch_device == "cpu"
lowerCAmelCase_ : List[str] = True
self._test_inference_batch_single_identical(
batch_size=2 ,test_max_difference=lowerCAmelCase__ ,relax_max_difference=lowerCAmelCase__ ,)
def UpperCAmelCase_ ( self : Optional[int] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = self.get_dummy_components()
lowerCAmelCase_ : Dict = self.pipeline_class(**lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = 1
lowerCAmelCase_ : Tuple = 2
lowerCAmelCase_ : str = self.get_dummy_inputs(lowerCAmelCase__ )
for key in inputs.keys():
if key in self.batch_params:
lowerCAmelCase_ : List[str] = batch_size * [inputs[key]]
lowerCAmelCase_ : List[str] = pipe(**lowerCAmelCase__ ,num_images_per_prompt=lowerCAmelCase__ )[0]
assert images.shape[0] == batch_size * num_images_per_prompt
@slow
@require_torch_gpu
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : List[Any] ) -> int:
'''simple docstring'''
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def UpperCAmelCase_ ( self : int ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Any = load_numpy(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
"/shap_e/test_shap_e_np_out.npy" )
lowerCAmelCase_ : Optional[int] = ShapEPipeline.from_pretrained("openai/shap-e" )
lowerCAmelCase_ : List[str] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = torch.Generator(device=lowerCAmelCase__ ).manual_seed(0 )
lowerCAmelCase_ : List[str] = pipe(
"a shark" ,generator=lowerCAmelCase__ ,guidance_scale=15.0 ,num_inference_steps=64 ,frame_size=64 ,output_type="np" ,).images[0]
assert images.shape == (20, 64, 64, 3)
assert_mean_pixel_difference(lowerCAmelCase__ ,lowerCAmelCase__ )
| 720 |
from multiprocessing import Lock, Pipe, Process
# lock used to ensure that two processes do not access a pipe at the same time
_lowercase = Lock()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
global process_lock
# we perform n swaps since after n swaps we know we are sorted
# we *could* stop early if we are sorted already, but it takes as long to
# find out we are sorted as it does to sort the list with this algorithm
for i in range(0 , 10):
if (i + position) % 2 == 0 and r_send is not None:
# send your value to your right neighbor
process_lock.acquire()
r_send[1].send(snake_case__)
process_lock.release()
# receive your right neighbor's value
process_lock.acquire()
lowerCAmelCase_ : Optional[Any] = rr_cv[0].recv()
process_lock.release()
# take the lower value since you are on the left
lowerCAmelCase_ : Any = min(snake_case__ , snake_case__)
elif (i + position) % 2 != 0 and l_send is not None:
# send your value to your left neighbor
process_lock.acquire()
l_send[1].send(snake_case__)
process_lock.release()
# receive your left neighbor's value
process_lock.acquire()
lowerCAmelCase_ : str = lr_cv[0].recv()
process_lock.release()
# take the higher value since you are on the right
lowerCAmelCase_ : Dict = max(snake_case__ , snake_case__)
# after all swaps are performed, send the values back to main
result_pipe[1].send(snake_case__)
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Union[str, Any] = []
lowerCAmelCase_ : int = []
# initialize the list of pipes where the values will be retrieved
for _ in arr:
result_pipe.append(Pipe())
# creates the processes
# the first and last process only have one neighbor so they are made outside
# of the loop
lowerCAmelCase_ : Tuple = Pipe()
lowerCAmelCase_ : Optional[int] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) , ))
lowerCAmelCase_ : int = temp_rs
lowerCAmelCase_ : List[Any] = temp_rr
for i in range(1 , len(snake_case__) - 1):
lowerCAmelCase_ : Dict = Pipe()
lowerCAmelCase_ : List[str] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]) , ))
lowerCAmelCase_ : Dict = temp_rs
lowerCAmelCase_ : Optional[Any] = temp_rr
process_array_.append(
Process(
target=snake_case__ , args=(
len(snake_case__) - 1,
arr[len(snake_case__) - 1],
temp_ls,
None,
temp_lr,
None,
result_pipe[len(snake_case__) - 1],
) , ))
# start the processes
for p in process_array_:
p.start()
# wait for the processes to end and write their values to the list
for p in range(0 , len(snake_case__)):
lowerCAmelCase_ : Union[str, Any] = result_pipe[p][0].recv()
process_array_[p].join()
return arr
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = list(range(10 , 0 , -1))
print("Initial List")
print(*snake_case__)
lowerCAmelCase_ : Tuple = odd_even_transposition(snake_case__)
print("Sorted List\n")
print(*snake_case__)
if __name__ == "__main__":
main()
| 683 | 0 |
import json
from typing import List, Optional, Tuple
from tokenizers import normalizers
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}
_lowercase = {
'''vocab_file''': {
'''squeezebert/squeezebert-uncased''': (
'''https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt'''
),
'''squeezebert/squeezebert-mnli''': '''https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt''',
'''squeezebert/squeezebert-mnli-headless''': (
'''https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt'''
),
},
'''tokenizer_file''': {
'''squeezebert/squeezebert-uncased''': (
'''https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json'''
),
'''squeezebert/squeezebert-mnli''': (
'''https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json'''
),
'''squeezebert/squeezebert-mnli-headless''': (
'''https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json'''
),
},
}
_lowercase = {
'''squeezebert/squeezebert-uncased''': 512,
'''squeezebert/squeezebert-mnli''': 512,
'''squeezebert/squeezebert-mnli-headless''': 512,
}
_lowercase = {
'''squeezebert/squeezebert-uncased''': {'''do_lower_case''': True},
'''squeezebert/squeezebert-mnli''': {'''do_lower_case''': True},
'''squeezebert/squeezebert-mnli-headless''': {'''do_lower_case''': True},
}
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_INIT_CONFIGURATION
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = SqueezeBertTokenizer
def __init__( self : Optional[int] ,lowerCAmelCase__ : int=None ,lowerCAmelCase__ : List[Any]=None ,lowerCAmelCase__ : Union[str, Any]=True ,lowerCAmelCase__ : List[str]="[UNK]" ,lowerCAmelCase__ : Union[str, Any]="[SEP]" ,lowerCAmelCase__ : Dict="[PAD]" ,lowerCAmelCase__ : Any="[CLS]" ,lowerCAmelCase__ : List[Any]="[MASK]" ,lowerCAmelCase__ : List[str]=True ,lowerCAmelCase__ : Any=None ,**lowerCAmelCase__ : Dict ,) -> Union[str, Any]:
'''simple docstring'''
super().__init__(
lowerCAmelCase__ ,tokenizer_file=lowerCAmelCase__ ,do_lower_case=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,sep_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,cls_token=lowerCAmelCase__ ,mask_token=lowerCAmelCase__ ,tokenize_chinese_chars=lowerCAmelCase__ ,strip_accents=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : List[str] = json.loads(self.backend_tokenizer.normalizer.__getstate__() )
if (
normalizer_state.get("lowercase" ,lowerCAmelCase__ ) != do_lower_case
or normalizer_state.get("strip_accents" ,lowerCAmelCase__ ) != strip_accents
or normalizer_state.get("handle_chinese_chars" ,lowerCAmelCase__ ) != tokenize_chinese_chars
):
lowerCAmelCase_ : Dict = getattr(lowerCAmelCase__ ,normalizer_state.pop("type" ) )
lowerCAmelCase_ : Union[str, Any] = do_lower_case
lowerCAmelCase_ : str = strip_accents
lowerCAmelCase_ : Optional[int] = tokenize_chinese_chars
lowerCAmelCase_ : Optional[Any] = normalizer_class(**lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = do_lower_case
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[Any]=None ) -> int:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = [self.cls_token_id] + token_ids_a + [self.sep_token_id]
if token_ids_a:
output += token_ids_a + [self.sep_token_id]
return output
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = [self.sep_token_id]
lowerCAmelCase_ : Union[str, Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = self._tokenizer.model.save(lowerCAmelCase__ ,name=lowerCAmelCase__ )
return tuple(lowerCAmelCase__ )
| 721 |
from typing import Any
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validation(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
# Creates data structures and fill initial step
lowerCAmelCase_ : dict = {}
lowerCAmelCase_ : dict = {}
for state in states_space:
lowerCAmelCase_ : List[Any] = observations_space[0]
lowerCAmelCase_ : int = (
initial_probabilities[state] * emission_probabilities[state][observation]
)
lowerCAmelCase_ : Dict = None
# Fills the data structure with the probabilities of
# different transitions and pointers to previous states
for o in range(1 , len(snake_case__)):
lowerCAmelCase_ : List[Any] = observations_space[o]
lowerCAmelCase_ : Optional[Any] = observations_space[o - 1]
for state in states_space:
# Calculates the argmax for probability function
lowerCAmelCase_ : List[Any] = ""
lowerCAmelCase_ : Tuple = -1
for k_state in states_space:
lowerCAmelCase_ : int = (
probabilities[(k_state, prior_observation)]
* transition_probabilities[k_state][state]
* emission_probabilities[state][observation]
)
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Optional[Any] = k_state
# Update probabilities and pointers dicts
lowerCAmelCase_ : Union[str, Any] = (
probabilities[(arg_max, prior_observation)]
* transition_probabilities[arg_max][state]
* emission_probabilities[state][observation]
)
lowerCAmelCase_ : Any = arg_max
# The final observation
lowerCAmelCase_ : List[Any] = observations_space[len(snake_case__) - 1]
# argmax for given final observation
lowerCAmelCase_ : List[str] = ""
lowerCAmelCase_ : List[str] = -1
for k_state in states_space:
lowerCAmelCase_ : List[str] = probabilities[(k_state, final_observation)]
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Tuple = k_state
lowerCAmelCase_ : str = arg_max
# Process pointers backwards
lowerCAmelCase_ : int = last_state
lowerCAmelCase_ : int = []
for o in range(len(snake_case__) - 1 , -1 , -1):
result.append(snake_case__)
lowerCAmelCase_ : Optional[Any] = pointers[previous, observations_space[o]]
result.reverse()
return result
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validate_not_empty(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
_validate_lists(snake_case__ , snake_case__)
_validate_dicts(
snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
if not all(
[
observations_space,
states_space,
initial_probabilities,
transition_probabilities,
emission_probabilities,
]):
raise ValueError("There's an empty parameter")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_list(snake_case__ , "observations_space")
_validate_list(snake_case__ , "states_space")
def UpperCamelCase ( snake_case__ , snake_case__):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list'''
raise ValueError(snake_case__)
else:
for x in _object:
if not isinstance(snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list of strings'''
raise ValueError(snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , ):
_validate_dict(snake_case__ , "initial_probabilities" , snake_case__)
_validate_nested_dict(snake_case__ , "transition_probabilities")
_validate_nested_dict(snake_case__ , "emission_probabilities")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_dict(_object , snake_case__ , snake_case__)
for x in _object.values():
_validate_dict(snake_case__ , snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ = False):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : List[str] = F'''{var_name} must be a dict'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object):
lowerCAmelCase_ : Dict = F'''{var_name} all keys must be strings'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object.values()):
lowerCAmelCase_ : Union[str, Any] = "nested dictionary " if nested else ""
lowerCAmelCase_ : Any = F'''{var_name} {nested_text}all values must be {value_type.__name__}'''
raise ValueError(snake_case__)
if __name__ == "__main__":
from doctest import testmod
testmod()
| 683 | 0 |
from __future__ import annotations
import typing
from collections import Counter
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : typing.Counter[int] = Counter()
for base in range(1 , max_perimeter + 1):
for perpendicular in range(snake_case__ , max_perimeter + 1):
lowerCAmelCase_ : Union[str, Any] = (base * base + perpendicular * perpendicular) ** 0.5
if hypotenuse == int(snake_case__):
lowerCAmelCase_ : List[str] = int(base + perpendicular + hypotenuse)
if perimeter > max_perimeter:
continue
triplets[perimeter] += 1
return triplets
def UpperCamelCase ( snake_case__ = 10_00):
lowerCAmelCase_ : Any = pythagorean_triple(snake_case__)
return triplets.most_common(1)[0][0]
if __name__ == "__main__":
print(f"Perimeter {solution()} has maximum solutions")
| 700 |
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch
from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool
if is_datasets_available():
from datasets import load_dataset
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'microsoft/speecht5_tts'
UpperCamelCase_ = (
'This is a tool that reads an English text out loud. It takes an input named `text` which should contain the '
'text to read (in English) and returns a waveform object containing the sound.'
)
UpperCamelCase_ = 'text_reader'
UpperCamelCase_ = SpeechTaProcessor
UpperCamelCase_ = SpeechTaForTextToSpeech
UpperCamelCase_ = SpeechTaHifiGan
UpperCamelCase_ = ['text']
UpperCamelCase_ = ['audio']
def UpperCAmelCase_ ( self : Dict ) -> Any:
'''simple docstring'''
if self.post_processor is None:
lowerCAmelCase_ : Any = "microsoft/speecht5_hifigan"
super().setup()
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Optional[int]=None ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Any = self.pre_processor(text=lowerCAmelCase__ ,return_tensors="pt" ,truncation=lowerCAmelCase__ )
if speaker_embeddings is None:
if not is_datasets_available():
raise ImportError("Datasets needs to be installed if not passing speaker embeddings." )
lowerCAmelCase_ : str = load_dataset("Matthijs/cmu-arctic-xvectors" ,split="validation" )
lowerCAmelCase_ : List[Any] = torch.tensor(embeddings_dataset[73_05]["xvector"] ).unsqueeze(0 )
return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Union[str, Any] ) -> Union[str, Any]:
'''simple docstring'''
with torch.no_grad():
return self.model.generate_speech(**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : str ) -> Any:
'''simple docstring'''
with torch.no_grad():
return self.post_processor(lowerCAmelCase__ ).cpu().detach()
| 683 | 0 |
import random
import unittest
import numpy as np
import torch
from diffusers import (
DPMSolverMultistepScheduler,
EulerAncestralDiscreteScheduler,
EulerDiscreteScheduler,
LMSDiscreteScheduler,
OnnxStableDiffusionUpscalePipeline,
PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
is_onnx_available,
load_image,
nightly,
require_onnxruntime,
require_torch_gpu,
)
from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin
if is_onnx_available():
import onnxruntime as ort
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = 'ssube/stable-diffusion-x4-upscaler-onnx'
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Any=0 ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : int = floats_tensor((1, 3, 1_28, 1_28) ,rng=random.Random(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = torch.manual_seed(lowerCAmelCase__ )
lowerCAmelCase_ : int = {
"prompt": "A painting of a squirrel eating a burger",
"image": image,
"generator": generator,
"num_inference_steps": 3,
"guidance_scale": 7.5,
"output_type": "numpy",
}
return inputs
def UpperCAmelCase_ ( self : List[Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint ,provider="CPUExecutionProvider" )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = self.get_dummy_inputs()
lowerCAmelCase_ : Any = pipe(**lowerCAmelCase__ ).images
lowerCAmelCase_ : Any = image[0, -3:, -3:, -1].flatten()
# started as 128, should now be 512
assert image.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : List[str] = np.array(
[0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223] )
assert np.abs(image_slice - expected_slice ).max() < 1e-1
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint ,provider="CPUExecutionProvider" )
lowerCAmelCase_ : Dict = PNDMScheduler.from_config(pipe.scheduler.config ,skip_prk_steps=lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Any = self.get_dummy_inputs()
lowerCAmelCase_ : Any = pipe(**lowerCAmelCase__ ).images
lowerCAmelCase_ : Optional[int] = image[0, -3:, -3:, -1]
assert image.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : str = np.array(
[0.6_898_892, 0.59_240_556, 0.52_499_527, 0.58_866_215, 0.52_258_235, 0.52_572_715, 0.62_414_473, 0.6_174_387, 0.6_214_964] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
def UpperCAmelCase_ ( self : Optional[Any] ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint ,provider="CPUExecutionProvider" )
lowerCAmelCase_ : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : str = self.get_dummy_inputs()
lowerCAmelCase_ : Any = pipe(**lowerCAmelCase__ ).images
lowerCAmelCase_ : Any = image[0, -3:, -3:, -1]
assert image.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : Any = np.array(
[0.7_659_278, 0.76_437_664, 0.75_579_107, 0.7_691_116, 0.77_666_986, 0.7_727_672, 0.7_758_664, 0.7_812_226, 0.76_942_515] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint ,provider="CPUExecutionProvider" )
lowerCAmelCase_ : List[Any] = EulerDiscreteScheduler.from_config(pipe.scheduler.config )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = self.get_dummy_inputs()
lowerCAmelCase_ : Any = pipe(**lowerCAmelCase__ ).images
lowerCAmelCase_ : Optional[int] = image[0, -3:, -3:, -1]
assert image.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : Union[str, Any] = np.array(
[0.6_974_782, 0.68_902_093, 0.70_135_885, 0.7_583_618, 0.7_804_545, 0.7_854_912, 0.78_667_426, 0.78_743_863, 0.78_070_223] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
def UpperCAmelCase_ ( self : Optional[Any] ) -> str:
'''simple docstring'''
lowerCAmelCase_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint ,provider="CPUExecutionProvider" )
lowerCAmelCase_ : Optional[Any] = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Any = self.get_dummy_inputs()
lowerCAmelCase_ : List[str] = pipe(**lowerCAmelCase__ ).images
lowerCAmelCase_ : List[str] = image[0, -3:, -3:, -1]
assert image.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : int = np.array(
[0.77_424_496, 0.773_601, 0.7_645_288, 0.7_769_598, 0.7_772_739, 0.7_738_688, 0.78_187_233, 0.77_879_584, 0.767_043] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-1
@nightly
@require_onnxruntime
@require_torch_gpu
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
@property
def UpperCAmelCase_ ( self : List[str] ) -> Union[str, Any]:
'''simple docstring'''
return (
"CUDAExecutionProvider",
{
"gpu_mem_limit": "15000000000", # 15GB
"arena_extend_strategy": "kSameAsRequested",
},
)
@property
def UpperCAmelCase_ ( self : Dict ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = ort.SessionOptions()
lowerCAmelCase_ : Union[str, Any] = False
return options
def UpperCAmelCase_ ( self : List[str] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = load_image(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
"/img2img/sketch-mountains-input.jpg" )
lowerCAmelCase_ : Optional[Any] = init_image.resize((1_28, 1_28) )
# using the PNDM scheduler by default
lowerCAmelCase_ : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(
"ssube/stable-diffusion-x4-upscaler-onnx" ,provider=self.gpu_provider ,sess_options=self.gpu_options ,)
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = "A fantasy landscape, trending on artstation"
lowerCAmelCase_ : Optional[int] = torch.manual_seed(0 )
lowerCAmelCase_ : Optional[int] = pipe(
prompt=lowerCAmelCase__ ,image=lowerCAmelCase__ ,guidance_scale=7.5 ,num_inference_steps=10 ,generator=lowerCAmelCase__ ,output_type="np" ,)
lowerCAmelCase_ : Optional[Any] = output.images
lowerCAmelCase_ : Dict = images[0, 2_55:2_58, 3_83:3_86, -1]
assert images.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : Any = np.array([0.4_883, 0.4_947, 0.4_980, 0.4_975, 0.4_982, 0.4_980, 0.5_000, 0.5_006, 0.4_972] )
# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues
assert np.abs(image_slice.flatten() - expected_slice ).max() < 2e-2
def UpperCAmelCase_ ( self : Optional[Any] ) -> int:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = load_image(
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
"/img2img/sketch-mountains-input.jpg" )
lowerCAmelCase_ : Any = init_image.resize((1_28, 1_28) )
lowerCAmelCase_ : Dict = LMSDiscreteScheduler.from_pretrained(
"ssube/stable-diffusion-x4-upscaler-onnx" ,subfolder="scheduler" )
lowerCAmelCase_ : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(
"ssube/stable-diffusion-x4-upscaler-onnx" ,scheduler=lowerCAmelCase__ ,provider=self.gpu_provider ,sess_options=self.gpu_options ,)
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = "A fantasy landscape, trending on artstation"
lowerCAmelCase_ : Any = torch.manual_seed(0 )
lowerCAmelCase_ : Dict = pipe(
prompt=lowerCAmelCase__ ,image=lowerCAmelCase__ ,guidance_scale=7.5 ,num_inference_steps=20 ,generator=lowerCAmelCase__ ,output_type="np" ,)
lowerCAmelCase_ : str = output.images
lowerCAmelCase_ : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1]
assert images.shape == (1, 5_12, 5_12, 3)
lowerCAmelCase_ : List[Any] = np.array(
[0.50_173_753, 0.50_223_356, 0.502_039, 0.50_233_036, 0.5_023_725, 0.5_022_601, 0.5_018_758, 0.50_234_085, 0.50_241_566] )
# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues
assert np.abs(image_slice.flatten() - expected_slice ).max() < 2e-2
| 701 |
import argparse
import collections
import json
import os
import re
import string
import sys
import numpy as np
_lowercase = re.compile(r'''\b(a|an|the)\b''', re.UNICODE)
_lowercase = None
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = argparse.ArgumentParser("Official evaluation script for SQuAD version 2.0.")
parser.add_argument("data_file" , metavar="data.json" , help="Input data JSON file.")
parser.add_argument("pred_file" , metavar="pred.json" , help="Model predictions.")
parser.add_argument(
"--out-file" , "-o" , metavar="eval.json" , help="Write accuracy metrics to file (default is stdout).")
parser.add_argument(
"--na-prob-file" , "-n" , metavar="na_prob.json" , help="Model estimates of probability of no answer.")
parser.add_argument(
"--na-prob-thresh" , "-t" , type=snake_case__ , default=1.0 , help="Predict \"\" if no-answer probability exceeds this (default = 1.0)." , )
parser.add_argument(
"--out-image-dir" , "-p" , metavar="out_images" , default=snake_case__ , help="Save precision-recall curves to directory.")
parser.add_argument("--verbose" , "-v" , action="store_true")
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
return parser.parse_args()
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : str = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : Dict = bool(qa["answers"]["text"])
return qid_to_has_ans
def UpperCamelCase ( snake_case__):
def remove_articles(snake_case__):
return ARTICLES_REGEX.sub(" " , snake_case__)
def white_space_fix(snake_case__):
return " ".join(text.split())
def remove_punc(snake_case__):
lowerCAmelCase_ : Optional[int] = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(snake_case__):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(snake_case__))))
def UpperCamelCase ( snake_case__):
if not s:
return []
return normalize_answer(snake_case__).split()
def UpperCamelCase ( snake_case__ , snake_case__):
return int(normalize_answer(snake_case__) == normalize_answer(snake_case__))
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = get_tokens(snake_case__)
lowerCAmelCase_ : Union[str, Any] = get_tokens(snake_case__)
lowerCAmelCase_ : Any = collections.Counter(snake_case__) & collections.Counter(snake_case__)
lowerCAmelCase_ : Dict = sum(common.values())
if len(snake_case__) == 0 or len(snake_case__) == 0:
# If either is no-answer, then F1 is 1 if they agree, 0 otherwise
return int(gold_toks == pred_toks)
if num_same == 0:
return 0
lowerCAmelCase_ : List[Any] = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : int = 1.0 * num_same / len(snake_case__)
lowerCAmelCase_ : List[Any] = (2 * precision * recall) / (precision + recall)
return fa
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Tuple = {}
lowerCAmelCase_ : int = {}
for article in dataset:
for p in article["paragraphs"]:
for qa in p["qas"]:
lowerCAmelCase_ : int = qa["id"]
lowerCAmelCase_ : Any = [t for t in qa["answers"]["text"] if normalize_answer(snake_case__)]
if not gold_answers:
# For unanswerable questions, only correct answer is empty string
lowerCAmelCase_ : Any = [""]
if qid not in preds:
print(F'''Missing prediction for {qid}''')
continue
lowerCAmelCase_ : Tuple = preds[qid]
# Take max over all gold answers
lowerCAmelCase_ : Any = max(compute_exact(snake_case__ , snake_case__) for a in gold_answers)
lowerCAmelCase_ : Optional[Any] = max(compute_fa(snake_case__ , snake_case__) for a in gold_answers)
return exact_scores, fa_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = {}
for qid, s in scores.items():
lowerCAmelCase_ : List[Any] = na_probs[qid] > na_prob_thresh
if pred_na:
lowerCAmelCase_ : List[str] = float(not qid_to_has_ans[qid])
else:
lowerCAmelCase_ : Union[str, Any] = s
return new_scores
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None):
if not qid_list:
lowerCAmelCase_ : Any = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores.values()) / total),
("f1", 100.0 * sum(fa_scores.values()) / total),
("total", total),
])
else:
lowerCAmelCase_ : Tuple = len(snake_case__)
return collections.OrderedDict(
[
("exact", 100.0 * sum(exact_scores[k] for k in qid_list) / total),
("f1", 100.0 * sum(fa_scores[k] for k in qid_list) / total),
("total", total),
])
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
for k in new_eval:
lowerCAmelCase_ : Union[str, Any] = new_eval[k]
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
plt.step(snake_case__ , snake_case__ , color="b" , alpha=0.2 , where="post")
plt.fill_between(snake_case__ , snake_case__ , step="post" , alpha=0.2 , color="b")
plt.xlabel("Recall")
plt.ylabel("Precision")
plt.xlim([0.0, 1.05])
plt.ylim([0.0, 1.05])
plt.title(snake_case__)
plt.savefig(snake_case__)
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__=None , snake_case__=None):
lowerCAmelCase_ : List[Any] = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
lowerCAmelCase_ : Dict = 0.0
lowerCAmelCase_ : int = 1.0
lowerCAmelCase_ : List[str] = 0.0
lowerCAmelCase_ : Tuple = [1.0]
lowerCAmelCase_ : Tuple = [0.0]
lowerCAmelCase_ : Dict = 0.0
for i, qid in enumerate(snake_case__):
if qid_to_has_ans[qid]:
true_pos += scores[qid]
lowerCAmelCase_ : str = true_pos / float(i + 1)
lowerCAmelCase_ : Union[str, Any] = true_pos / float(snake_case__)
if i == len(snake_case__) - 1 or na_probs[qid] != na_probs[qid_list[i + 1]]:
# i.e., if we can put a threshold after this point
avg_prec += cur_p * (cur_r - recalls[-1])
precisions.append(snake_case__)
recalls.append(snake_case__)
if out_image:
plot_pr_curve(snake_case__ , snake_case__ , snake_case__ , snake_case__)
return {"ap": 100.0 * avg_prec}
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
if out_image_dir and not os.path.exists(snake_case__):
os.makedirs(snake_case__)
lowerCAmelCase_ : Any = sum(1 for v in qid_to_has_ans.values() if v)
if num_true_pos == 0:
return
lowerCAmelCase_ : Any = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_exact.png") , title="Precision-Recall curve for Exact Match score" , )
lowerCAmelCase_ : Dict = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_f1.png") , title="Precision-Recall curve for F1 score" , )
lowerCAmelCase_ : Dict = {k: float(snake_case__) for k, v in qid_to_has_ans.items()}
lowerCAmelCase_ : str = make_precision_recall_eval(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , out_image=os.path.join(snake_case__ , "pr_oracle.png") , title="Oracle Precision-Recall curve (binary task of HasAns vs. NoAns)" , )
merge_eval(snake_case__ , snake_case__ , "pr_exact")
merge_eval(snake_case__ , snake_case__ , "pr_f1")
merge_eval(snake_case__ , snake_case__ , "pr_oracle")
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
if not qid_list:
return
lowerCAmelCase_ : Optional[Any] = [na_probs[k] for k in qid_list]
lowerCAmelCase_ : Dict = np.ones_like(snake_case__) / float(len(snake_case__))
plt.hist(snake_case__ , weights=snake_case__ , bins=20 , range=(0.0, 1.0))
plt.xlabel("Model probability of no-answer")
plt.ylabel("Proportion of dataset")
plt.title(F'''Histogram of no-answer probability: {name}''')
plt.savefig(os.path.join(snake_case__ , F'''na_prob_hist_{name}.png'''))
plt.clf()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Dict = sum(1 for k in qid_to_has_ans if not qid_to_has_ans[k])
lowerCAmelCase_ : str = num_no_ans
lowerCAmelCase_ : List[str] = cur_score
lowerCAmelCase_ : List[Any] = 0.0
lowerCAmelCase_ : str = sorted(snake_case__ , key=lambda snake_case__: na_probs[k])
for i, qid in enumerate(snake_case__):
if qid not in scores:
continue
if qid_to_has_ans[qid]:
lowerCAmelCase_ : Union[str, Any] = scores[qid]
else:
if preds[qid]:
lowerCAmelCase_ : List[Any] = -1
else:
lowerCAmelCase_ : List[str] = 0
cur_score += diff
if cur_score > best_score:
lowerCAmelCase_ : Optional[Any] = cur_score
lowerCAmelCase_ : Optional[int] = na_probs[qid]
return 100.0 * best_score / len(snake_case__), best_thresh
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ , lowerCAmelCase_ : Optional[int] = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ , lowerCAmelCase_ : Dict = find_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = best_exact
lowerCAmelCase_ : List[str] = exact_thresh
lowerCAmelCase_ : Any = best_fa
lowerCAmelCase_ : List[str] = fa_thresh
def UpperCamelCase ( ):
with open(OPTS.data_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
lowerCAmelCase_ : List[Any] = dataset_json["data"]
with open(OPTS.pred_file) as f:
lowerCAmelCase_ : int = json.load(snake_case__)
if OPTS.na_prob_file:
with open(OPTS.na_prob_file) as f:
lowerCAmelCase_ : Optional[int] = json.load(snake_case__)
else:
lowerCAmelCase_ : List[Any] = {k: 0.0 for k in preds}
lowerCAmelCase_ : Tuple = make_qid_to_has_ans(snake_case__) # maps qid to True/False
lowerCAmelCase_ : Any = [k for k, v in qid_to_has_ans.items() if v]
lowerCAmelCase_ : List[str] = [k for k, v in qid_to_has_ans.items() if not v]
lowerCAmelCase_ , lowerCAmelCase_ : Dict = get_raw_scores(snake_case__ , snake_case__)
lowerCAmelCase_ : str = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Dict = apply_no_ans_threshold(snake_case__ , snake_case__ , snake_case__ , OPTS.na_prob_thresh)
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__)
if has_ans_qids:
lowerCAmelCase_ : str = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "HasAns")
if no_ans_qids:
lowerCAmelCase_ : Union[str, Any] = make_eval_dict(snake_case__ , snake_case__ , qid_list=snake_case__)
merge_eval(snake_case__ , snake_case__ , "NoAns")
if OPTS.na_prob_file:
find_all_best_thresh(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__)
if OPTS.na_prob_file and OPTS.out_image_dir:
run_precision_recall_analysis(snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , OPTS.out_image_dir)
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "hasAns")
histogram_na_prob(snake_case__ , snake_case__ , OPTS.out_image_dir , "noAns")
if OPTS.out_file:
with open(OPTS.out_file , "w") as f:
json.dump(snake_case__ , snake_case__)
else:
print(json.dumps(snake_case__ , indent=2))
if __name__ == "__main__":
_lowercase = parse_args()
if OPTS.out_image_dir:
import matplotlib
matplotlib.use('''Agg''')
import matplotlib.pyplot as plt
main()
| 683 | 0 |
import unittest
from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
is_pipeline_test,
nested_simplify,
require_tf,
require_torch,
require_vision,
slow,
)
from .test_pipelines_common import ANY
if is_vision_available():
from PIL import Image
else:
class __snake_case :
"""simple docstring"""
@staticmethod
def UpperCAmelCase_ ( *lowerCAmelCase__ : int ,**lowerCAmelCase__ : str ) -> Tuple:
'''simple docstring'''
pass
@is_pipeline_test
@require_torch
@require_vision
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Tuple ,lowerCAmelCase__ : Tuple ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Dict = pipeline("visual-question-answering" ,model="hf-internal-testing/tiny-vilt-random-vqa" )
lowerCAmelCase_ : str = [
{
"image": Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ),
"question": "How many cats are there?",
},
{
"image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
"question": "How many cats are there?",
},
]
return vqa_pipeline, examples
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ) -> int:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = vqa_pipeline(lowerCAmelCase__ ,top_k=1 )
self.assertEqual(
lowerCAmelCase__ ,[
[{"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}],
[{"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}],
] ,)
@require_torch
def UpperCAmelCase_ ( self : str ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = pipeline("visual-question-answering" ,model="hf-internal-testing/tiny-vilt-random-vqa" )
lowerCAmelCase_ : Any = "./tests/fixtures/tests_samples/COCO/000000039769.png"
lowerCAmelCase_ : Optional[Any] = "How many cats are there?"
lowerCAmelCase_ : Dict = vqa_pipeline(image=lowerCAmelCase__ ,question="How many cats are there?" ,top_k=2 )
self.assertEqual(
lowerCAmelCase__ ,[{"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}, {"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}] )
lowerCAmelCase_ : Optional[Any] = vqa_pipeline({"image": image, "question": question} ,top_k=2 )
self.assertEqual(
lowerCAmelCase__ ,[{"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}, {"score": ANY(lowerCAmelCase__ ), "answer": ANY(lowerCAmelCase__ )}] )
@slow
@require_torch
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : str = pipeline("visual-question-answering" ,model="dandelin/vilt-b32-finetuned-vqa" )
lowerCAmelCase_ : int = "./tests/fixtures/tests_samples/COCO/000000039769.png"
lowerCAmelCase_ : Dict = "How many cats are there?"
lowerCAmelCase_ : Optional[Any] = vqa_pipeline(image=lowerCAmelCase__ ,question=lowerCAmelCase__ ,top_k=2 )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ,decimals=4 ) ,[{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}] )
lowerCAmelCase_ : int = vqa_pipeline({"image": image, "question": question} ,top_k=2 )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ,decimals=4 ) ,[{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}] )
lowerCAmelCase_ : List[str] = vqa_pipeline(
[{"image": image, "question": question}, {"image": image, "question": question}] ,top_k=2 )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ,decimals=4 ) ,[[{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}]] * 2 ,)
@require_tf
@unittest.skip("Visual question answering not implemented in TF" )
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[int]:
'''simple docstring'''
pass
| 702 |
from math import sqrt
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[int] = 0
for i in range(1 , int(sqrt(snake_case__) + 1)):
if n % i == 0 and i != sqrt(snake_case__):
total += i + n // i
elif i == sqrt(snake_case__):
total += i
return total - n
def UpperCamelCase ( snake_case__ = 1_00_00):
lowerCAmelCase_ : int = sum(
i
for i in range(1 , snake_case__)
if sum_of_divisors(sum_of_divisors(snake_case__)) == i and sum_of_divisors(snake_case__) != i)
return total
if __name__ == "__main__":
print(solution(int(str(input()).strip())))
| 683 | 0 |
def UpperCamelCase ( snake_case__):
return 1 if digit in (0, 1) else (digit * factorial(digit - 1))
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Dict = 0
lowerCAmelCase_ : Any = number
while duplicate > 0:
lowerCAmelCase_ : str = divmod(snake_case__ , 10)
fact_sum += factorial(snake_case__)
return fact_sum == number
if __name__ == "__main__":
print('''Program to check whether a number is a Krisnamurthy Number or not.''')
_lowercase = int(input('''Enter number: ''').strip())
print(
f"{number} is {'' if krishnamurthy(number) else 'not '}a Krishnamurthy Number."
)
| 703 |
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_sentencepiece_available,
is_speech_available,
is_tf_available,
is_torch_available,
)
_lowercase = {
'''configuration_speech_to_text''': ['''SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Speech2TextConfig'''],
'''processing_speech_to_text''': ['''Speech2TextProcessor'''],
}
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = ['''Speech2TextTokenizer''']
try:
if not is_speech_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = ['''Speech2TextFeatureExtractor''']
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''TFSpeech2TextForConditionalGeneration''',
'''TFSpeech2TextModel''',
'''TFSpeech2TextPreTrainedModel''',
]
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''Speech2TextForConditionalGeneration''',
'''Speech2TextModel''',
'''Speech2TextPreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
from .processing_speech_to_text import SpeechaTextProcessor
try:
if not is_sentencepiece_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .tokenization_speech_to_text import SpeechaTextTokenizer
try:
if not is_speech_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_speech_to_text import (
TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
TFSpeechaTextForConditionalGeneration,
TFSpeechaTextModel,
TFSpeechaTextPreTrainedModel,
)
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_speech_to_text import (
SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
SpeechaTextForConditionalGeneration,
SpeechaTextModel,
SpeechaTextPreTrainedModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 683 | 0 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices
_lowercase = logging.get_logger(__name__)
_lowercase = {
'''microsoft/focalnet-tiny''': '''https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json''',
}
class __snake_case ( snake_case__ , snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'focalnet'
def __init__( self : int ,lowerCAmelCase__ : Dict=2_24 ,lowerCAmelCase__ : str=4 ,lowerCAmelCase__ : Optional[Any]=3 ,lowerCAmelCase__ : Optional[int]=96 ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : List[str]=[1_92, 3_84, 7_68, 7_68] ,lowerCAmelCase__ : Any=[2, 2, 6, 2] ,lowerCAmelCase__ : Tuple=[2, 2, 2, 2] ,lowerCAmelCase__ : List[Any]=[3, 3, 3, 3] ,lowerCAmelCase__ : str="gelu" ,lowerCAmelCase__ : int=4.0 ,lowerCAmelCase__ : Optional[Any]=0.0 ,lowerCAmelCase__ : Dict=0.1 ,lowerCAmelCase__ : Optional[Any]=False ,lowerCAmelCase__ : str=1e-4 ,lowerCAmelCase__ : Optional[int]=False ,lowerCAmelCase__ : Dict=False ,lowerCAmelCase__ : int=False ,lowerCAmelCase__ : Any=0.02 ,lowerCAmelCase__ : List[Any]=1e-5 ,lowerCAmelCase__ : Tuple=32 ,lowerCAmelCase__ : List[str]=None ,lowerCAmelCase__ : Optional[int]=None ,**lowerCAmelCase__ : Optional[int] ,) -> List[Any]:
'''simple docstring'''
super().__init__(**lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = image_size
lowerCAmelCase_ : Any = patch_size
lowerCAmelCase_ : Optional[int] = num_channels
lowerCAmelCase_ : Dict = embed_dim
lowerCAmelCase_ : str = use_conv_embed
lowerCAmelCase_ : Optional[int] = hidden_sizes
lowerCAmelCase_ : str = depths
lowerCAmelCase_ : Optional[int] = focal_levels
lowerCAmelCase_ : List[str] = focal_windows
lowerCAmelCase_ : Dict = hidden_act
lowerCAmelCase_ : Optional[int] = mlp_ratio
lowerCAmelCase_ : Optional[Any] = hidden_dropout_prob
lowerCAmelCase_ : Optional[Any] = drop_path_rate
lowerCAmelCase_ : Optional[int] = use_layerscale
lowerCAmelCase_ : Union[str, Any] = layerscale_value
lowerCAmelCase_ : Any = use_post_layernorm
lowerCAmelCase_ : List[str] = use_post_layernorm_in_modulation
lowerCAmelCase_ : List[Any] = normalize_modulator
lowerCAmelCase_ : Dict = initializer_range
lowerCAmelCase_ : Union[str, Any] = layer_norm_eps
lowerCAmelCase_ : int = encoder_stride
lowerCAmelCase_ : Optional[Any] = ["stem"] + [f'''stage{idx}''' for idx in range(1 ,len(self.depths ) + 1 )]
lowerCAmelCase_ : Any = get_aligned_output_features_output_indices(
out_features=lowerCAmelCase__ ,out_indices=lowerCAmelCase__ ,stage_names=self.stage_names )
| 704 |
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple
import regex as re
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}
_lowercase = {
'''vocab_file''': {
'''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json''',
'''allenai/longformer-large-4096''': (
'''https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json'''
),
'''allenai/longformer-large-4096-finetuned-triviaqa''': (
'''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json'''
),
'''allenai/longformer-base-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json'''
),
'''allenai/longformer-large-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json'''
),
},
'''merges_file''': {
'''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt''',
'''allenai/longformer-large-4096''': (
'''https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt'''
),
'''allenai/longformer-large-4096-finetuned-triviaqa''': (
'''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt'''
),
'''allenai/longformer-base-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt'''
),
'''allenai/longformer-large-4096-extra.pos.embd.only''': (
'''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt'''
),
},
}
_lowercase = {
'''allenai/longformer-base-4096''': 4096,
'''allenai/longformer-large-4096''': 4096,
'''allenai/longformer-large-4096-finetuned-triviaqa''': 4096,
'''allenai/longformer-base-4096-extra.pos.embd.only''': 4096,
'''allenai/longformer-large-4096-extra.pos.embd.only''': 4096,
}
@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def UpperCamelCase ( ):
lowerCAmelCase_ : str = (
list(range(ord("!") , ord("~") + 1)) + list(range(ord("¡") , ord("¬") + 1)) + list(range(ord("®") , ord("ÿ") + 1))
)
lowerCAmelCase_ : Tuple = bs[:]
lowerCAmelCase_ : Dict = 0
for b in range(2**8):
if b not in bs:
bs.append(snake_case__)
cs.append(2**8 + n)
n += 1
lowerCAmelCase_ : Union[str, Any] = [chr(snake_case__) for n in cs]
return dict(zip(snake_case__ , snake_case__))
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[Any] = set()
lowerCAmelCase_ : List[Any] = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
lowerCAmelCase_ : Union[str, Any] = char
return pairs
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = ['input_ids', 'attention_mask']
def __init__( self : str ,lowerCAmelCase__ : Dict ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Optional[Any]="replace" ,lowerCAmelCase__ : Dict="<s>" ,lowerCAmelCase__ : str="</s>" ,lowerCAmelCase__ : str="</s>" ,lowerCAmelCase__ : Optional[Any]="<s>" ,lowerCAmelCase__ : List[Any]="<unk>" ,lowerCAmelCase__ : Union[str, Any]="<pad>" ,lowerCAmelCase__ : int="<mask>" ,lowerCAmelCase__ : Any=False ,**lowerCAmelCase__ : int ,) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else bos_token
lowerCAmelCase_ : Tuple = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else eos_token
lowerCAmelCase_ : Dict = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else sep_token
lowerCAmelCase_ : int = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else cls_token
lowerCAmelCase_ : List[str] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else unk_token
lowerCAmelCase_ : List[str] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else pad_token
# Mask token behave like a normal word, i.e. include the space before it
lowerCAmelCase_ : Optional[Any] = AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else mask_token
super().__init__(
errors=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,sep_token=lowerCAmelCase__ ,cls_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,mask_token=lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
with open(lowerCAmelCase__ ,encoding="utf-8" ) as vocab_handle:
lowerCAmelCase_ : List[Any] = json.load(lowerCAmelCase__ )
lowerCAmelCase_ : Dict = {v: k for k, v in self.encoder.items()}
lowerCAmelCase_ : List[Any] = errors # how to handle errors in decoding
lowerCAmelCase_ : Optional[Any] = bytes_to_unicode()
lowerCAmelCase_ : int = {v: k for k, v in self.byte_encoder.items()}
with open(lowerCAmelCase__ ,encoding="utf-8" ) as merges_handle:
lowerCAmelCase_ : Union[str, Any] = merges_handle.read().split("\n" )[1:-1]
lowerCAmelCase_ : Dict = [tuple(merge.split() ) for merge in bpe_merges]
lowerCAmelCase_ : Dict = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : Any = {}
lowerCAmelCase_ : int = add_prefix_space
# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
lowerCAmelCase_ : Optional[Any] = re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" )
@property
def UpperCAmelCase_ ( self : Optional[int] ) -> Any:
'''simple docstring'''
return len(self.encoder )
def UpperCAmelCase_ ( self : Any ) -> Optional[int]:
'''simple docstring'''
return dict(self.encoder ,**self.added_tokens_encoder )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : List[str] ) -> List[Any]:
'''simple docstring'''
if token in self.cache:
return self.cache[token]
lowerCAmelCase_ : Union[str, Any] = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = get_pairs(lowerCAmelCase__ )
if not pairs:
return token
while True:
lowerCAmelCase_ : Dict = min(lowerCAmelCase__ ,key=lambda lowerCAmelCase__ : self.bpe_ranks.get(lowerCAmelCase__ ,float("inf" ) ) )
if bigram not in self.bpe_ranks:
break
lowerCAmelCase_ , lowerCAmelCase_ : Dict = bigram
lowerCAmelCase_ : Optional[Any] = []
lowerCAmelCase_ : Any = 0
while i < len(lowerCAmelCase__ ):
try:
lowerCAmelCase_ : Optional[int] = word.index(lowerCAmelCase__ ,lowerCAmelCase__ )
except ValueError:
new_word.extend(word[i:] )
break
else:
new_word.extend(word[i:j] )
lowerCAmelCase_ : Tuple = j
if word[i] == first and i < len(lowerCAmelCase__ ) - 1 and word[i + 1] == second:
new_word.append(first + second )
i += 2
else:
new_word.append(word[i] )
i += 1
lowerCAmelCase_ : Optional[Any] = tuple(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = new_word
if len(lowerCAmelCase__ ) == 1:
break
else:
lowerCAmelCase_ : Dict = get_pairs(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = " ".join(lowerCAmelCase__ )
lowerCAmelCase_ : Any = word
return word
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Dict = []
for token in re.findall(self.pat ,lowerCAmelCase__ ):
lowerCAmelCase_ : List[str] = "".join(
self.byte_encoder[b] for b in token.encode("utf-8" ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCAmelCase__ ).split(" " ) )
return bpe_tokens
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : int ) -> Tuple:
'''simple docstring'''
return self.encoder.get(lowerCAmelCase__ ,self.encoder.get(self.unk_token ) )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Optional[Any] ) -> Union[str, Any]:
'''simple docstring'''
return self.decoder.get(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Dict ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = "".join(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8" ,errors=self.errors )
return text
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
if not os.path.isdir(lowerCAmelCase__ ):
logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
return
lowerCAmelCase_ : Optional[Any] = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = os.path.join(
lowerCAmelCase__ ,(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as f:
f.write(json.dumps(self.encoder ,indent=2 ,sort_keys=lowerCAmelCase__ ,ensure_ascii=lowerCAmelCase__ ) + "\n" )
lowerCAmelCase_ : Tuple = 0
with open(lowerCAmelCase__ ,"w" ,encoding="utf-8" ) as writer:
writer.write("#version: 0.2\n" )
for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,key=lambda lowerCAmelCase__ : kv[1] ):
if index != token_index:
logger.warning(
f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
" Please check that the tokenizer is not corrupted!" )
lowerCAmelCase_ : Optional[Any] = token_index
writer.write(" ".join(lowerCAmelCase__ ) + "\n" )
index += 1
return vocab_file, merge_file
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
if token_ids_a is None:
return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
lowerCAmelCase_ : List[Any] = [self.cls_token_id]
lowerCAmelCase_ : List[str] = [self.sep_token_id]
return cls + token_ids_a + sep + sep + token_ids_a + sep
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ,lowerCAmelCase__ : bool = False ) -> List[int]:
'''simple docstring'''
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, 1] + ([0] * len(lowerCAmelCase__ )) + [1]
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = [self.sep_token_id]
lowerCAmelCase_ : Tuple = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : List[str] ,lowerCAmelCase__ : Optional[int]=False ,**lowerCAmelCase__ : Optional[int] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : int = kwargs.pop("add_prefix_space" ,self.add_prefix_space )
if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase__ ) > 0 and not text[0].isspace()):
lowerCAmelCase_ : Union[str, Any] = " " + text
return (text, kwargs)
| 683 | 0 |
'''simple docstring'''
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Dict = len(snake_case__)
lowerCAmelCase_ : str = len(matrix[0])
lowerCAmelCase_ : Dict = min(snake_case__ , snake_case__)
for row in range(snake_case__):
# Check if diagonal element is not zero
if matrix[row][row] != 0:
# Eliminate all the elements below the diagonal
for col in range(row + 1 , snake_case__):
lowerCAmelCase_ : Tuple = matrix[col][row] / matrix[row][row]
for i in range(snake_case__ , snake_case__):
matrix[col][i] -= multiplier * matrix[row][i]
else:
# Find a non-zero diagonal element to swap rows
lowerCAmelCase_ : Union[str, Any] = True
for i in range(row + 1 , snake_case__):
if matrix[i][row] != 0:
lowerCAmelCase_ : Union[str, Any] = matrix[i], matrix[row]
lowerCAmelCase_ : Union[str, Any] = False
break
if reduce:
rank -= 1
for i in range(snake_case__):
lowerCAmelCase_ : List[str] = matrix[i][rank]
# Reduce the row pointer by one to stay on the same row
row -= 1
return rank
if __name__ == "__main__":
import doctest
doctest.testmod()
| 705 |
from collections.abc import Iterable
from typing import Any
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : int | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Dict = value
lowerCAmelCase_ : Node | None = None # Added in order to delete a node easier
lowerCAmelCase_ : Node | None = None
lowerCAmelCase_ : Node | None = None
def __repr__( self : Union[str, Any] ) -> str:
'''simple docstring'''
from pprint import pformat
if self.left is None and self.right is None:
return str(self.value )
return pformat({f'''{self.value}''': (self.left, self.right)} ,indent=1 )
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Node | None = None ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = root
def __str__( self : Dict ) -> str:
'''simple docstring'''
return str(self.root )
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Node ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if new_children is not None: # reset its kids
lowerCAmelCase_ : Optional[int] = node.parent
if node.parent is not None: # reset its parent
if self.is_right(lowerCAmelCase__ ): # If it is the right children
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : List[Any] = new_children
else:
lowerCAmelCase_ : Any = new_children
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : Node ) -> bool:
'''simple docstring'''
if node.parent and node.parent.right:
return node == node.parent.right
return False
def UpperCAmelCase_ ( self : List[str] ) -> bool:
'''simple docstring'''
return self.root is None
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Union[str, Any] ) -> None:
'''simple docstring'''
lowerCAmelCase_ : str = Node(lowerCAmelCase__ ) # create a new Node
if self.empty(): # if Tree is empty
lowerCAmelCase_ : Optional[int] = new_node # set its root
else: # Tree is not empty
lowerCAmelCase_ : List[Any] = self.root # from root
if parent_node is None:
return
while True: # While we don't get to a leaf
if value < parent_node.value: # We go left
if parent_node.left is None:
lowerCAmelCase_ : Dict = new_node # We insert the new node in a leaf
break
else:
lowerCAmelCase_ : List[str] = parent_node.left
else:
if parent_node.right is None:
lowerCAmelCase_ : Dict = new_node
break
else:
lowerCAmelCase_ : str = parent_node.right
lowerCAmelCase_ : Optional[int] = parent_node
def UpperCAmelCase_ ( self : int ,*lowerCAmelCase__ : Tuple ) -> None:
'''simple docstring'''
for value in values:
self.__insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Optional[int] ) -> Node | None:
'''simple docstring'''
if self.empty():
raise IndexError("Warning: Tree is empty! please use another." )
else:
lowerCAmelCase_ : Dict = self.root
# use lazy evaluation here to avoid NoneType Attribute error
while node is not None and node.value is not value:
lowerCAmelCase_ : Union[str, Any] = node.left if value < node.value else node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
if self.root is None:
return None
lowerCAmelCase_ : Dict = self.root
if not self.empty():
while node.right is not None:
lowerCAmelCase_ : Union[str, Any] = node.right
return node
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : Node | None = None ) -> Node | None:
'''simple docstring'''
if node is None:
lowerCAmelCase_ : Dict = self.root
if self.root is None:
return None
if not self.empty():
lowerCAmelCase_ : Dict = self.root
while node.left is not None:
lowerCAmelCase_ : Union[str, Any] = node.left
return node
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : int ) -> None:
'''simple docstring'''
lowerCAmelCase_ : Dict = self.search(lowerCAmelCase__ ) # Look for the node with that label
if node is not None:
if node.left is None and node.right is None: # If it has no children
self.__reassign_nodes(lowerCAmelCase__ ,lowerCAmelCase__ )
elif node.left is None: # Has only right children
self.__reassign_nodes(lowerCAmelCase__ ,node.right )
elif node.right is None: # Has only left children
self.__reassign_nodes(lowerCAmelCase__ ,node.left )
else:
lowerCAmelCase_ : int = self.get_max(
node.left ) # Gets the max value of the left branch
self.remove(tmp_node.value ) # type: ignore
lowerCAmelCase_ : Any = (
tmp_node.value # type: ignore
) # Assigns the value to the node to delete and keep tree structure
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Node | None ) -> Iterable:
'''simple docstring'''
if node is not None:
yield node # Preorder Traversal
yield from self.preorder_traverse(node.left )
yield from self.preorder_traverse(node.right )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Dict=None ) -> Any:
'''simple docstring'''
if traversal_function is None:
return self.preorder_traverse(self.root )
else:
return traversal_function(self.root )
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : list ,lowerCAmelCase__ : Node | None ) -> None:
'''simple docstring'''
if node:
self.inorder(lowerCAmelCase__ ,node.left )
arr.append(node.value )
self.inorder(lowerCAmelCase__ ,node.right )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Node ) -> int:
'''simple docstring'''
lowerCAmelCase_ : list[int] = []
self.inorder(lowerCAmelCase__ ,lowerCAmelCase__ ) # append all values to list using inorder traversal
return arr[k - 1]
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Optional[Any] = []
if curr_node is not None:
lowerCAmelCase_ : Dict = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
return node_list
def UpperCamelCase ( ):
lowerCAmelCase_ : Tuple = (8, 3, 6, 1, 10, 14, 13, 4, 7)
lowerCAmelCase_ : Tuple = BinarySearchTree()
for i in testlist:
t.insert(snake_case__)
# Prints all the elements of the list in order traversal
print(snake_case__)
if t.search(6) is not None:
print("The value 6 exists")
else:
print("The value 6 doesn't exist")
if t.search(-1) is not None:
print("The value -1 exists")
else:
print("The value -1 doesn't exist")
if not t.empty():
print("Max Value: " , t.get_max().value) # type: ignore
print("Min Value: " , t.get_min().value) # type: ignore
for i in testlist:
t.remove(snake_case__)
print(snake_case__)
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)
| 683 | 0 |
'''simple docstring'''
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Any = False
while is_sorted is False: # Until all the indices are traversed keep looping
lowerCAmelCase_ : List[str] = True
for i in range(0 , len(snake_case__) - 1 , 2): # iterating over all even indices
if input_list[i] > input_list[i + 1]:
lowerCAmelCase_ : str = input_list[i + 1], input_list[i]
# swapping if elements not in order
lowerCAmelCase_ : Optional[int] = False
for i in range(1 , len(snake_case__) - 1 , 2): # iterating over all odd indices
if input_list[i] > input_list[i + 1]:
lowerCAmelCase_ : Optional[Any] = input_list[i + 1], input_list[i]
# swapping if elements not in order
lowerCAmelCase_ : Any = False
return input_list
if __name__ == "__main__":
print('''Enter list to be sorted''')
_lowercase = [int(x) for x in input().split()]
# inputing elements of the list in one line
_lowercase = odd_even_sort(input_list)
print('''The sorted list is''')
print(sorted_list)
| 706 |
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[int] ,lowerCAmelCase__ : str = "" ,lowerCAmelCase__ : bool = False ) -> None:
'''simple docstring'''
lowerCAmelCase_ : dict[str, RadixNode] = {}
# A node will be a leaf if the tree contains its word
lowerCAmelCase_ : int = is_leaf
lowerCAmelCase_ : Optional[Any] = prefix
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : str ) -> tuple[str, str, str]:
'''simple docstring'''
lowerCAmelCase_ : Any = 0
for q, w in zip(self.prefix ,lowerCAmelCase__ ):
if q != w:
break
x += 1
return self.prefix[:x], self.prefix[x:], word[x:]
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : list[str] ) -> None:
'''simple docstring'''
for word in words:
self.insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : str ) -> None:
'''simple docstring'''
if self.prefix == word:
lowerCAmelCase_ : Optional[Any] = True
# Case 2: The node has no edges that have a prefix to the word
# Solution: We create an edge from the current node to a new one
# containing the word
elif word[0] not in self.nodes:
lowerCAmelCase_ : List[Any] = RadixNode(prefix=lowerCAmelCase__ ,is_leaf=lowerCAmelCase__ )
else:
lowerCAmelCase_ : Tuple = self.nodes[word[0]]
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : List[str] = incoming_node.match(
lowerCAmelCase__ )
# Case 3: The node prefix is equal to the matching
# Solution: We insert remaining word on the next node
if remaining_prefix == "":
self.nodes[matching_string[0]].insert(lowerCAmelCase__ )
# Case 4: The word is greater equal to the matching
# Solution: Create a node in between both nodes, change
# prefixes and add the new node for the remaining word
else:
lowerCAmelCase_ : Optional[int] = remaining_prefix
lowerCAmelCase_ : Optional[int] = self.nodes[matching_string[0]]
lowerCAmelCase_ : List[Any] = RadixNode(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Dict = aux_node
if remaining_word == "":
lowerCAmelCase_ : List[str] = True
else:
self.nodes[matching_string[0]].insert(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : str ) -> bool:
'''simple docstring'''
lowerCAmelCase_ : Any = self.nodes.get(word[0] ,lowerCAmelCase__ )
if not incoming_node:
return False
else:
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : List[Any] = incoming_node.match(
lowerCAmelCase__ )
# If there is remaining prefix, the word can't be on the tree
if remaining_prefix != "":
return False
# This applies when the word and the prefix are equal
elif remaining_word == "":
return incoming_node.is_leaf
# We have word remaining so we check the next node
else:
return incoming_node.find(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : str ) -> bool:
'''simple docstring'''
lowerCAmelCase_ : int = self.nodes.get(word[0] ,lowerCAmelCase__ )
if not incoming_node:
return False
else:
lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ : Union[str, Any] = incoming_node.match(
lowerCAmelCase__ )
# If there is remaining prefix, the word can't be on the tree
if remaining_prefix != "":
return False
# We have word remaining so we check the next node
elif remaining_word != "":
return incoming_node.delete(lowerCAmelCase__ )
else:
# If it is not a leaf, we don't have to delete
if not incoming_node.is_leaf:
return False
else:
# We delete the nodes if no edges go from it
if len(incoming_node.nodes ) == 0:
del self.nodes[word[0]]
# We merge the current node with its only child
if len(self.nodes ) == 1 and not self.is_leaf:
lowerCAmelCase_ : str = list(self.nodes.values() )[0]
lowerCAmelCase_ : Tuple = merging_node.is_leaf
self.prefix += merging_node.prefix
lowerCAmelCase_ : Optional[int] = merging_node.nodes
# If there is more than 1 edge, we just mark it as non-leaf
elif len(incoming_node.nodes ) > 1:
lowerCAmelCase_ : Optional[Any] = False
# If there is 1 edge, we merge it with its child
else:
lowerCAmelCase_ : Tuple = list(incoming_node.nodes.values() )[0]
lowerCAmelCase_ : Union[str, Any] = merging_node.is_leaf
incoming_node.prefix += merging_node.prefix
lowerCAmelCase_ : str = merging_node.nodes
return True
def UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : int = 0 ) -> None:
'''simple docstring'''
if self.prefix != "":
print("-" * height ,self.prefix ," (leaf)" if self.is_leaf else "" )
for value in self.nodes.values():
value.print_tree(height + 1 )
def UpperCamelCase ( ):
lowerCAmelCase_ : Dict = "banana bananas bandana band apple all beast".split()
lowerCAmelCase_ : List[Any] = RadixNode()
root.insert_many(snake_case__)
assert all(root.find(snake_case__) for word in words)
assert not root.find("bandanas")
assert not root.find("apps")
root.delete("all")
assert not root.find("all")
root.delete("banana")
assert not root.find("banana")
assert root.find("bananas")
return True
def UpperCamelCase ( ):
assert test_trie()
def UpperCamelCase ( ):
lowerCAmelCase_ : List[str] = RadixNode()
lowerCAmelCase_ : Optional[Any] = "banana bananas bandanas bandana band apple all beast".split()
root.insert_many(snake_case__)
print("Words:" , snake_case__)
print("Tree:")
root.print_tree()
if __name__ == "__main__":
main()
| 683 | 0 |
import unittest
from transformers import BigBirdConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask
if is_flax_available():
import jax
from transformers.models.big_bird.modeling_flax_big_bird import (
FlaxBigBirdForCausalLM,
FlaxBigBirdForMaskedLM,
FlaxBigBirdForMultipleChoice,
FlaxBigBirdForPreTraining,
FlaxBigBirdForQuestionAnswering,
FlaxBigBirdForSequenceClassification,
FlaxBigBirdForTokenClassification,
FlaxBigBirdModel,
)
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def __init__( self : Any ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Tuple=2 ,lowerCAmelCase__ : Dict=56 ,lowerCAmelCase__ : Tuple=True ,lowerCAmelCase__ : List[str]=True ,lowerCAmelCase__ : str=True ,lowerCAmelCase__ : int=True ,lowerCAmelCase__ : str=99 ,lowerCAmelCase__ : List[Any]=32 ,lowerCAmelCase__ : Optional[int]=2 ,lowerCAmelCase__ : Union[str, Any]=2 ,lowerCAmelCase__ : Tuple=7 ,lowerCAmelCase__ : List[str]="gelu_new" ,lowerCAmelCase__ : Dict=0.1 ,lowerCAmelCase__ : Optional[int]=0.1 ,lowerCAmelCase__ : List[str]=5_12 ,lowerCAmelCase__ : Tuple=16 ,lowerCAmelCase__ : Union[str, Any]=2 ,lowerCAmelCase__ : Optional[Any]=0.02 ,lowerCAmelCase__ : int=4 ,lowerCAmelCase__ : int="block_sparse" ,lowerCAmelCase__ : Optional[int]=True ,lowerCAmelCase__ : int=False ,lowerCAmelCase__ : str=2 ,lowerCAmelCase__ : Dict=3 ,) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = parent
lowerCAmelCase_ : str = batch_size
lowerCAmelCase_ : Tuple = seq_length
lowerCAmelCase_ : Dict = is_training
lowerCAmelCase_ : List[Any] = use_attention_mask
lowerCAmelCase_ : Any = use_token_type_ids
lowerCAmelCase_ : Union[str, Any] = use_labels
lowerCAmelCase_ : List[str] = vocab_size
lowerCAmelCase_ : Dict = hidden_size
lowerCAmelCase_ : Any = num_hidden_layers
lowerCAmelCase_ : Any = num_attention_heads
lowerCAmelCase_ : Optional[int] = intermediate_size
lowerCAmelCase_ : Optional[int] = hidden_act
lowerCAmelCase_ : Union[str, Any] = hidden_dropout_prob
lowerCAmelCase_ : Union[str, Any] = attention_probs_dropout_prob
lowerCAmelCase_ : int = max_position_embeddings
lowerCAmelCase_ : Union[str, Any] = type_vocab_size
lowerCAmelCase_ : Dict = type_sequence_label_size
lowerCAmelCase_ : Tuple = initializer_range
lowerCAmelCase_ : Any = num_choices
lowerCAmelCase_ : Tuple = rescale_embeddings
lowerCAmelCase_ : str = attention_type
lowerCAmelCase_ : Optional[int] = use_bias
lowerCAmelCase_ : Any = block_size
lowerCAmelCase_ : int = num_random_blocks
def UpperCAmelCase_ ( self : int ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Any = ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size )
lowerCAmelCase_ : Optional[int] = None
if self.use_attention_mask:
lowerCAmelCase_ : Union[str, Any] = random_attention_mask([self.batch_size, self.seq_length] )
lowerCAmelCase_ : List[Any] = None
if self.use_token_type_ids:
lowerCAmelCase_ : Optional[int] = ids_tensor([self.batch_size, self.seq_length] ,self.type_vocab_size )
lowerCAmelCase_ : Tuple = BigBirdConfig(
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 ,attention_type=self.attention_type ,block_size=self.block_size ,num_random_blocks=self.num_random_blocks ,use_bias=self.use_bias ,rescale_embeddings=self.rescale_embeddings ,)
return config, input_ids, token_type_ids, attention_mask
def UpperCAmelCase_ ( self : str ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = self.prepare_config_and_inputs()
lowerCAmelCase_ : Dict = config_and_inputs
lowerCAmelCase_ : Optional[Any] = {
"input_ids": input_ids,
"token_type_ids": token_type_ids,
"attention_mask": attention_mask,
}
return config, inputs_dict
@require_flax
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = (
(
FlaxBigBirdForCausalLM,
FlaxBigBirdModel,
FlaxBigBirdForPreTraining,
FlaxBigBirdForMaskedLM,
FlaxBigBirdForMultipleChoice,
FlaxBigBirdForQuestionAnswering,
FlaxBigBirdForSequenceClassification,
FlaxBigBirdForTokenClassification,
)
if is_flax_available()
else ()
)
UpperCamelCase_ = False
UpperCamelCase_ = False
def UpperCAmelCase_ ( self : int ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = FlaxBigBirdModelTester(self )
@slow
# copied from `test_modeling_flax_common` because it takes much longer than other models
def UpperCAmelCase_ ( self : Optional[int] ) -> List[Any]:
'''simple docstring'''
super().test_from_pretrained_save_pretrained()
@slow
# copied from `test_modeling_flax_common` because it takes much longer than other models
def UpperCAmelCase_ ( self : List[str] ) -> List[Any]:
'''simple docstring'''
super().test_from_pretrained_with_no_automatic_init()
@slow
# copied from `test_modeling_flax_common` because it takes much longer than other models
def UpperCAmelCase_ ( self : List[Any] ) -> Any:
'''simple docstring'''
super().test_no_automatic_init()
@slow
# copied from `test_modeling_flax_common` because it takes much longer than other models
def UpperCAmelCase_ ( self : Tuple ) -> List[Any]:
'''simple docstring'''
super().test_hidden_states_output()
@slow
def UpperCAmelCase_ ( self : Optional[int] ) -> Tuple:
'''simple docstring'''
for model_class_name in self.all_model_classes:
lowerCAmelCase_ : int = model_class_name.from_pretrained("google/bigbird-roberta-base" )
self.assertIsNotNone(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : int ) -> Union[str, Any]:
'''simple docstring'''
if self.test_attn_probs:
super().test_attention_outputs()
@slow
# copied from `test_modeling_flax_common` because it takes much longer than other models
def UpperCAmelCase_ ( self : Optional[int] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Tuple = self.model_tester.prepare_config_and_inputs_for_common()
for model_class in self.all_model_classes:
with self.subTest(model_class.__name__ ):
lowerCAmelCase_ : str = self._prepare_for_class(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = model_class(lowerCAmelCase__ )
@jax.jit
def model_jitted(lowerCAmelCase__ : Dict ,lowerCAmelCase__ : Optional[int]=None ,**lowerCAmelCase__ : Optional[int] ):
return model(input_ids=lowerCAmelCase__ ,attention_mask=lowerCAmelCase__ ,**lowerCAmelCase__ )
with self.subTest("JIT Enabled" ):
lowerCAmelCase_ : Union[str, Any] = model_jitted(**lowerCAmelCase__ ).to_tuple()
with self.subTest("JIT Disabled" ):
with jax.disable_jit():
lowerCAmelCase_ : Union[str, Any] = model_jitted(**lowerCAmelCase__ ).to_tuple()
self.assertEqual(len(lowerCAmelCase__ ) ,len(lowerCAmelCase__ ) )
for jitted_output, output in zip(lowerCAmelCase__ ,lowerCAmelCase__ ):
self.assertEqual(jitted_output.shape ,output.shape )
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Any ,lowerCAmelCase__ : List[Any]=1e-5 ,lowerCAmelCase__ : int="outputs" ,lowerCAmelCase__ : Union[str, Any]=None ) -> Tuple:
'''simple docstring'''
if name.startswith("outputs.attentions" ):
return
else:
super().check_pt_flax_outputs(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
| 707 |
from __future__ import annotations
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , ):
if (electron_conc, hole_conc, intrinsic_conc).count(0) != 1:
raise ValueError("You cannot supply more or less than 2 values")
elif electron_conc < 0:
raise ValueError("Electron concentration cannot be negative in a semiconductor")
elif hole_conc < 0:
raise ValueError("Hole concentration cannot be negative in a semiconductor")
elif intrinsic_conc < 0:
raise ValueError(
"Intrinsic concentration cannot be negative in a semiconductor")
elif electron_conc == 0:
return (
"electron_conc",
intrinsic_conc**2 / hole_conc,
)
elif hole_conc == 0:
return (
"hole_conc",
intrinsic_conc**2 / electron_conc,
)
elif intrinsic_conc == 0:
return (
"intrinsic_conc",
(electron_conc * hole_conc) ** 0.5,
)
else:
return (-1, -1)
if __name__ == "__main__":
import doctest
doctest.testmod()
| 683 | 0 |
import gc
import unittest
import numpy as np
import torch
from diffusers import (
AudioDiffusionPipeline,
AutoencoderKL,
DDIMScheduler,
DDPMScheduler,
DiffusionPipeline,
Mel,
UNetaDConditionModel,
UNetaDModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
enable_full_determinism()
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : str ) -> List[str]:
'''simple docstring'''
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
@property
def UpperCAmelCase_ ( self : Tuple ) -> List[Any]:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : List[Any] = UNetaDModel(
sample_size=(32, 64) ,in_channels=1 ,out_channels=1 ,layers_per_block=2 ,block_out_channels=(1_28, 1_28) ,down_block_types=("AttnDownBlock2D", "DownBlock2D") ,up_block_types=("UpBlock2D", "AttnUpBlock2D") ,)
return model
@property
def UpperCAmelCase_ ( self : List[Any] ) -> Dict:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : List[str] = UNetaDConditionModel(
sample_size=(64, 32) ,in_channels=1 ,out_channels=1 ,layers_per_block=2 ,block_out_channels=(1_28, 1_28) ,down_block_types=("CrossAttnDownBlock2D", "DownBlock2D") ,up_block_types=("UpBlock2D", "CrossAttnUpBlock2D") ,cross_attention_dim=10 ,)
return model
@property
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[str]:
'''simple docstring'''
torch.manual_seed(0 )
lowerCAmelCase_ : str = AutoencoderKL(
sample_size=(1_28, 64) ,in_channels=1 ,out_channels=1 ,latent_channels=1 ,layers_per_block=2 ,block_out_channels=(1_28, 1_28) ,down_block_types=("DownEncoderBlock2D", "DownEncoderBlock2D") ,up_block_types=("UpDecoderBlock2D", "UpDecoderBlock2D") ,)
lowerCAmelCase_ : Optional[int] = UNetaDModel(
sample_size=(64, 32) ,in_channels=1 ,out_channels=1 ,layers_per_block=2 ,block_out_channels=(1_28, 1_28) ,down_block_types=("AttnDownBlock2D", "DownBlock2D") ,up_block_types=("UpBlock2D", "AttnUpBlock2D") ,)
return vqvae, unet
@slow
def UpperCAmelCase_ ( self : Any ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = "cpu" # ensure determinism for the device-dependent torch.Generator
lowerCAmelCase_ : Dict = Mel(
x_res=self.dummy_unet.config.sample_size[1] ,y_res=self.dummy_unet.config.sample_size[0] ,)
lowerCAmelCase_ : Union[str, Any] = DDPMScheduler()
lowerCAmelCase_ : List[str] = AudioDiffusionPipeline(vqvae=lowerCAmelCase__ ,unet=self.dummy_unet ,mel=lowerCAmelCase__ ,scheduler=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = torch.Generator(device=lowerCAmelCase__ ).manual_seed(42 )
lowerCAmelCase_ : str = pipe(generator=lowerCAmelCase__ ,steps=4 )
lowerCAmelCase_ : Optional[int] = output.audios[0]
lowerCAmelCase_ : Optional[int] = output.images[0]
lowerCAmelCase_ : str = torch.Generator(device=lowerCAmelCase__ ).manual_seed(42 )
lowerCAmelCase_ : Any = pipe(generator=lowerCAmelCase__ ,steps=4 ,return_dict=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = output[0][0]
assert audio.shape == (1, (self.dummy_unet.config.sample_size[1] - 1) * mel.hop_length)
assert (
image.height == self.dummy_unet.config.sample_size[0]
and image.width == self.dummy_unet.config.sample_size[1]
)
lowerCAmelCase_ : Optional[Any] = np.frombuffer(image.tobytes() ,dtype="uint8" )[:10]
lowerCAmelCase_ : Union[str, Any] = np.frombuffer(image_from_tuple.tobytes() ,dtype="uint8" )[:10]
lowerCAmelCase_ : List[str] = np.array([69, 2_55, 2_55, 2_55, 0, 0, 77, 1_81, 12, 1_27] )
assert np.abs(image_slice.flatten() - expected_slice ).max() == 0
assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() == 0
lowerCAmelCase_ : List[Any] = Mel(
x_res=self.dummy_vqvae_and_unet[0].config.sample_size[1] ,y_res=self.dummy_vqvae_and_unet[0].config.sample_size[0] ,)
lowerCAmelCase_ : List[str] = DDIMScheduler()
lowerCAmelCase_ : int = self.dummy_vqvae_and_unet
lowerCAmelCase_ : Optional[int] = AudioDiffusionPipeline(
vqvae=self.dummy_vqvae_and_unet[0] ,unet=dummy_vqvae_and_unet[1] ,mel=lowerCAmelCase__ ,scheduler=lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
np.random.seed(0 )
lowerCAmelCase_ : Any = np.random.uniform(-1 ,1 ,((dummy_vqvae_and_unet[0].config.sample_size[1] - 1) * mel.hop_length,) )
lowerCAmelCase_ : List[Any] = torch.Generator(device=lowerCAmelCase__ ).manual_seed(42 )
lowerCAmelCase_ : Union[str, Any] = pipe(raw_audio=lowerCAmelCase__ ,generator=lowerCAmelCase__ ,start_step=5 ,steps=10 )
lowerCAmelCase_ : Dict = output.images[0]
assert (
image.height == self.dummy_vqvae_and_unet[0].config.sample_size[0]
and image.width == self.dummy_vqvae_and_unet[0].config.sample_size[1]
)
lowerCAmelCase_ : str = np.frombuffer(image.tobytes() ,dtype="uint8" )[:10]
lowerCAmelCase_ : Any = np.array([1_20, 1_17, 1_10, 1_09, 1_38, 1_67, 1_38, 1_48, 1_32, 1_21] )
assert np.abs(image_slice.flatten() - expected_slice ).max() == 0
lowerCAmelCase_ : Union[str, Any] = self.dummy_unet_condition
lowerCAmelCase_ : Tuple = AudioDiffusionPipeline(
vqvae=self.dummy_vqvae_and_unet[0] ,unet=lowerCAmelCase__ ,mel=lowerCAmelCase__ ,scheduler=lowerCAmelCase__ )
lowerCAmelCase_ : str = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
np.random.seed(0 )
lowerCAmelCase_ : List[Any] = torch.rand((1, 1, 10) )
lowerCAmelCase_ : List[Any] = pipe(generator=lowerCAmelCase__ ,encoding=lowerCAmelCase__ )
lowerCAmelCase_ : str = output.images[0]
lowerCAmelCase_ : Union[str, Any] = np.frombuffer(image.tobytes() ,dtype="uint8" )[:10]
lowerCAmelCase_ : List[Any] = np.array([1_07, 1_03, 1_20, 1_27, 1_42, 1_22, 1_13, 1_22, 97, 1_11] )
assert np.abs(image_slice.flatten() - expected_slice ).max() == 0
@slow
@require_torch_gpu
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase_ ( self : List[str] ) -> List[str]:
'''simple docstring'''
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def UpperCAmelCase_ ( self : Dict ) -> str:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = torch_device
lowerCAmelCase_ : int = DiffusionPipeline.from_pretrained("teticio/audio-diffusion-ddim-256" )
lowerCAmelCase_ : Union[str, Any] = pipe.to(lowerCAmelCase__ )
pipe.set_progress_bar_config(disable=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = torch.Generator(device=lowerCAmelCase__ ).manual_seed(42 )
lowerCAmelCase_ : Any = pipe(generator=lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = output.audios[0]
lowerCAmelCase_ : Union[str, Any] = output.images[0]
assert audio.shape == (1, (pipe.unet.config.sample_size[1] - 1) * pipe.mel.hop_length)
assert image.height == pipe.unet.config.sample_size[0] and image.width == pipe.unet.config.sample_size[1]
lowerCAmelCase_ : int = np.frombuffer(image.tobytes() ,dtype="uint8" )[:10]
lowerCAmelCase_ : Tuple = np.array([1_51, 1_67, 1_54, 1_44, 1_22, 1_34, 1_21, 1_05, 70, 26] )
assert np.abs(image_slice.flatten() - expected_slice ).max() == 0
| 708 |
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
_lowercase = {
'''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
'''processing_git''': ['''GitProcessor'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''GitForCausalLM''',
'''GitModel''',
'''GitPreTrainedModel''',
'''GitVisionModel''',
]
if TYPE_CHECKING:
from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
from .processing_git import GitProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_git import (
GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
GitForCausalLM,
GitModel,
GitPreTrainedModel,
GitVisionModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
| 683 | 0 |
import json
import sys
def UpperCamelCase ( snake_case__ , snake_case__):
with open(snake_case__ , encoding="utf-8") as f:
lowerCAmelCase_ : str = json.load(snake_case__)
lowerCAmelCase_ : Optional[Any] = ["<details>", "<summary>Show updated benchmarks!</summary>", " "]
for benchmark_name in sorted(snake_case__):
lowerCAmelCase_ : Optional[Any] = results[benchmark_name]
lowerCAmelCase_ : Union[str, Any] = benchmark_name.split("/")[-1]
output_md.append(F'''### Benchmark: {benchmark_file_name}''')
lowerCAmelCase_ : str = "| metric |"
lowerCAmelCase_ : Optional[int] = "|--------|"
lowerCAmelCase_ : Tuple = "| new / old (diff) |"
for metric_name in sorted(snake_case__):
lowerCAmelCase_ : Tuple = benchmark_res[metric_name]
lowerCAmelCase_ : Optional[int] = metric_vals["new"]
lowerCAmelCase_ : Dict = metric_vals.get("old" , snake_case__)
lowerCAmelCase_ : Tuple = metric_vals.get("diff" , snake_case__)
lowerCAmelCase_ : List[Any] = F''' {new_val:f}''' if isinstance(snake_case__ , (int, float)) else "None"
if old_val is not None:
val_str += F''' / {old_val:f}''' if isinstance(snake_case__ , (int, float)) else "None"
if dif_val is not None:
val_str += F''' ({dif_val:f})''' if isinstance(snake_case__ , (int, float)) else "None"
title += " " + metric_name + " |"
lines += "---|"
value += val_str + " |"
output_md += [title, lines, value, " "]
output_md.append("</details>")
with open(snake_case__ , "w" , encoding="utf-8") as f:
f.writelines("\n".join(snake_case__))
if __name__ == "__main__":
_lowercase = sys.argv[1]
_lowercase = sys.argv[2]
format_json_to_md(input_json_file, output_md_file)
| 709 |
from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments
def UpperCamelCase ( ):
lowerCAmelCase_ : List[str] = HfArgumentParser(snake_case__)
lowerCAmelCase_ : List[Any] = parser.parse_args_into_dataclasses()[0]
lowerCAmelCase_ : Optional[int] = TensorFlowBenchmark(args=snake_case__)
try:
lowerCAmelCase_ : Tuple = parser.parse_args_into_dataclasses()[0]
except ValueError as e:
lowerCAmelCase_ : Union[str, Any] = "Arg --no_{0} is no longer used, please use --no-{0} instead."
lowerCAmelCase_ : Tuple = " ".join(str(snake_case__).split(" ")[:-1])
lowerCAmelCase_ : Union[str, Any] = ""
lowerCAmelCase_ : Optional[Any] = eval(str(snake_case__).split(" ")[-1])
lowerCAmelCase_ : Tuple = []
for arg in depreciated_args:
# arg[2:] removes '--'
if arg[2:] in TensorFlowBenchmark.deprecated_args:
# arg[5:] removes '--no_'
full_error_msg += arg_error_msg.format(arg[5:])
else:
wrong_args.append(snake_case__)
if len(snake_case__) > 0:
lowerCAmelCase_ : Optional[Any] = full_error_msg + begin_error_msg + str(snake_case__)
raise ValueError(snake_case__)
benchmark.run()
if __name__ == "__main__":
main()
| 683 | 0 |
'''simple docstring'''
from typing import Optional
import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
BaseModelOutputWithNoAttention,
BaseModelOutputWithPoolingAndNoAttention,
ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig
_lowercase = logging.get_logger(__name__)
# General docstring
_lowercase = '''RegNetConfig'''
# Base docstring
_lowercase = '''facebook/regnet-y-040'''
_lowercase = [1, 1088, 7, 7]
# Image classification docstring
_lowercase = '''facebook/regnet-y-040'''
_lowercase = '''tabby, tabby cat'''
_lowercase = [
'''facebook/regnet-y-040''',
# See all regnet models at https://huggingface.co/models?filter=regnet
]
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int = 3 ,lowerCAmelCase__ : int = 1 ,lowerCAmelCase__ : int = 1 ,lowerCAmelCase__ : Optional[str] = "relu" ,) -> str:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : Union[str, Any] = nn.Convad(
lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=lowerCAmelCase__ ,stride=lowerCAmelCase__ ,padding=kernel_size // 2 ,groups=lowerCAmelCase__ ,bias=lowerCAmelCase__ ,)
lowerCAmelCase_ : str = nn.BatchNormad(lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = ACTaFN[activation] if activation is not None else nn.Identity()
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Dict ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = self.convolution(lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = self.normalization(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = self.activation(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : Any ,lowerCAmelCase__ : RegNetConfig ) -> Dict:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : List[str] = RegNetConvLayer(
config.num_channels ,config.embedding_size ,kernel_size=3 ,stride=2 ,activation=config.hidden_act )
lowerCAmelCase_ : Optional[int] = config.num_channels
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : Optional[int] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Tuple = pixel_values.shape[1]
if num_channels != self.num_channels:
raise ValueError(
"Make sure that the channel dimension of the pixel values match with the one set in the configuration." )
lowerCAmelCase_ : Dict = self.embedder(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : Tuple ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int = 2 ) -> Union[str, Any]:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : Union[str, Any] = nn.Convad(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ,stride=lowerCAmelCase__ ,bias=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = nn.BatchNormad(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Tensor ) -> Tensor:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = self.convolution(lowerCAmelCase__ )
lowerCAmelCase_ : str = self.normalization(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : Union[str, Any] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ) -> Any:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : str = nn.AdaptiveAvgPoolad((1, 1) )
lowerCAmelCase_ : Optional[int] = nn.Sequential(
nn.Convad(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ) ,nn.ReLU() ,nn.Convad(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ) ,nn.Sigmoid() ,)
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Tuple ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = self.pooler(lowerCAmelCase__ )
lowerCAmelCase_ : Dict = self.attention(lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = hidden_state * attention
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : List[str] ,lowerCAmelCase__ : RegNetConfig ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int = 1 ) -> Optional[Any]:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : Any = in_channels != out_channels or stride != 1
lowerCAmelCase_ : str = max(1 ,out_channels // config.groups_width )
lowerCAmelCase_ : List[Any] = (
RegNetShortCut(lowerCAmelCase__ ,lowerCAmelCase__ ,stride=lowerCAmelCase__ ) if should_apply_shortcut else nn.Identity()
)
lowerCAmelCase_ : Tuple = nn.Sequential(
RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ,activation=config.hidden_act ) ,RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,stride=lowerCAmelCase__ ,groups=lowerCAmelCase__ ,activation=config.hidden_act ) ,RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ,activation=lowerCAmelCase__ ) ,)
lowerCAmelCase_ : Union[str, Any] = ACTaFN[config.hidden_act]
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : Optional[int] ) -> Union[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : str = hidden_state
lowerCAmelCase_ : str = self.layer(lowerCAmelCase__ )
lowerCAmelCase_ : str = self.shortcut(lowerCAmelCase__ )
hidden_state += residual
lowerCAmelCase_ : Optional[int] = self.activation(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : int ,lowerCAmelCase__ : RegNetConfig ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int = 1 ) -> Optional[int]:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : Optional[int] = in_channels != out_channels or stride != 1
lowerCAmelCase_ : Union[str, Any] = max(1 ,out_channels // config.groups_width )
lowerCAmelCase_ : Optional[int] = (
RegNetShortCut(lowerCAmelCase__ ,lowerCAmelCase__ ,stride=lowerCAmelCase__ ) if should_apply_shortcut else nn.Identity()
)
lowerCAmelCase_ : Union[str, Any] = nn.Sequential(
RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ,activation=config.hidden_act ) ,RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,stride=lowerCAmelCase__ ,groups=lowerCAmelCase__ ,activation=config.hidden_act ) ,RegNetSELayer(lowerCAmelCase__ ,reduced_channels=int(round(in_channels / 4 ) ) ) ,RegNetConvLayer(lowerCAmelCase__ ,lowerCAmelCase__ ,kernel_size=1 ,activation=lowerCAmelCase__ ) ,)
lowerCAmelCase_ : Dict = ACTaFN[config.hidden_act]
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : str = hidden_state
lowerCAmelCase_ : List[str] = self.layer(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = self.shortcut(lowerCAmelCase__ )
hidden_state += residual
lowerCAmelCase_ : List[str] = self.activation(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : List[Any] ,lowerCAmelCase__ : RegNetConfig ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int ,lowerCAmelCase__ : int = 2 ,lowerCAmelCase__ : int = 2 ,) -> int:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : List[Any] = RegNetXLayer if config.layer_type == "x" else RegNetYLayer
lowerCAmelCase_ : Union[str, Any] = nn.Sequential(
# downsampling is done in the first layer with stride of 2
layer(
lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ,stride=lowerCAmelCase__ ,) ,*[layer(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ) for _ in range(depth - 1 )] ,)
def UpperCAmelCase_ ( self : List[Any] ,lowerCAmelCase__ : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = self.layers(lowerCAmelCase__ )
return hidden_state
class __snake_case ( nn.Module ):
"""simple docstring"""
def __init__( self : List[str] ,lowerCAmelCase__ : RegNetConfig ) -> Dict:
'''simple docstring'''
super().__init__()
lowerCAmelCase_ : List[Any] = nn.ModuleList([] )
# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
self.stages.append(
RegNetStage(
lowerCAmelCase__ ,config.embedding_size ,config.hidden_sizes[0] ,stride=2 if config.downsample_in_first_stage else 1 ,depth=config.depths[0] ,) )
lowerCAmelCase_ : List[Any] = zip(config.hidden_sizes ,config.hidden_sizes[1:] )
for (in_channels, out_channels), depth in zip(lowerCAmelCase__ ,config.depths[1:] ):
self.stages.append(RegNetStage(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ ,depth=lowerCAmelCase__ ) )
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Tensor ,lowerCAmelCase__ : bool = False ,lowerCAmelCase__ : bool = True ) -> BaseModelOutputWithNoAttention:
'''simple docstring'''
lowerCAmelCase_ : Dict = () if output_hidden_states else None
for stage_module in self.stages:
if output_hidden_states:
lowerCAmelCase_ : Optional[Any] = hidden_states + (hidden_state,)
lowerCAmelCase_ : int = stage_module(lowerCAmelCase__ )
if output_hidden_states:
lowerCAmelCase_ : str = hidden_states + (hidden_state,)
if not return_dict:
return tuple(v for v in [hidden_state, hidden_states] if v is not None )
return BaseModelOutputWithNoAttention(last_hidden_state=lowerCAmelCase__ ,hidden_states=lowerCAmelCase__ )
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = RegNetConfig
UpperCamelCase_ = 'regnet'
UpperCamelCase_ = 'pixel_values'
UpperCamelCase_ = True
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : Dict ) -> str:
'''simple docstring'''
if isinstance(lowerCAmelCase__ ,nn.Convad ):
nn.init.kaiming_normal_(module.weight ,mode="fan_out" ,nonlinearity="relu" )
elif isinstance(lowerCAmelCase__ ,(nn.BatchNormad, nn.GroupNorm) ):
nn.init.constant_(module.weight ,1 )
nn.init.constant_(module.bias ,0 )
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Optional[Any] ,lowerCAmelCase__ : List[str]=False ) -> str:
'''simple docstring'''
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : str = value
_lowercase = r'''
This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
behavior.
Parameters:
config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the
configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
'''
_lowercase = r'''
Args:
pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
[`ConvNextImageProcessor.__call__`] for details.
output_hidden_states (`bool`, *optional*):
Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
more detail.
return_dict (`bool`, *optional*):
Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
'''
@add_start_docstrings(
'The bare RegNet model outputting raw features without any specific head on top.' , snake_case__ , )
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class __snake_case ( snake_case__ ):
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : List[str] ) -> int:
'''simple docstring'''
super().__init__(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = config
lowerCAmelCase_ : Union[str, Any] = RegNetEmbeddings(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = RegNetEncoder(lowerCAmelCase__ )
lowerCAmelCase_ : List[str] = nn.AdaptiveAvgPoolad((1, 1) )
# Initialize weights and apply final processing
self.post_init()
@add_start_docstrings_to_model_forward(lowerCAmelCase__ )
@add_code_sample_docstrings(
checkpoint=_CHECKPOINT_FOR_DOC ,output_type=lowerCAmelCase__ ,config_class=_CONFIG_FOR_DOC ,modality="vision" ,expected_output=_EXPECTED_OUTPUT_SHAPE ,)
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : Tensor ,lowerCAmelCase__ : Optional[bool] = None ,lowerCAmelCase__ : Optional[bool] = None ) -> BaseModelOutputWithPoolingAndNoAttention:
'''simple docstring'''
lowerCAmelCase_ : int = (
output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
)
lowerCAmelCase_ : int = return_dict if return_dict is not None else self.config.use_return_dict
lowerCAmelCase_ : Optional[int] = self.embedder(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = self.encoder(
lowerCAmelCase__ ,output_hidden_states=lowerCAmelCase__ ,return_dict=lowerCAmelCase__ )
lowerCAmelCase_ : str = encoder_outputs[0]
lowerCAmelCase_ : int = self.pooler(lowerCAmelCase__ )
if not return_dict:
return (last_hidden_state, pooled_output) + encoder_outputs[1:]
return BaseModelOutputWithPoolingAndNoAttention(
last_hidden_state=lowerCAmelCase__ ,pooler_output=lowerCAmelCase__ ,hidden_states=encoder_outputs.hidden_states ,)
@add_start_docstrings(
'\n RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n ImageNet.\n ' , snake_case__ , )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class __snake_case ( snake_case__ ):
"""simple docstring"""
def __init__( self : Any ,lowerCAmelCase__ : Union[str, Any] ) -> Optional[Any]:
'''simple docstring'''
super().__init__(lowerCAmelCase__ )
lowerCAmelCase_ : str = config.num_labels
lowerCAmelCase_ : Dict = RegNetModel(lowerCAmelCase__ )
# classification head
lowerCAmelCase_ : Optional[Any] = nn.Sequential(
nn.Flatten() ,nn.Linear(config.hidden_sizes[-1] ,config.num_labels ) if config.num_labels > 0 else nn.Identity() ,)
# initialize weights and apply final processing
self.post_init()
@add_start_docstrings_to_model_forward(lowerCAmelCase__ )
@add_code_sample_docstrings(
checkpoint=_IMAGE_CLASS_CHECKPOINT ,output_type=lowerCAmelCase__ ,config_class=_CONFIG_FOR_DOC ,expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT ,)
def UpperCAmelCase_ ( self : Optional[Any] ,lowerCAmelCase__ : Optional[torch.FloatTensor] = None ,lowerCAmelCase__ : Optional[torch.LongTensor] = None ,lowerCAmelCase__ : Optional[bool] = None ,lowerCAmelCase__ : Optional[bool] = None ,) -> ImageClassifierOutputWithNoAttention:
'''simple docstring'''
lowerCAmelCase_ : int = return_dict if return_dict is not None else self.config.use_return_dict
lowerCAmelCase_ : int = self.regnet(lowerCAmelCase__ ,output_hidden_states=lowerCAmelCase__ ,return_dict=lowerCAmelCase__ )
lowerCAmelCase_ : Union[str, Any] = outputs.pooler_output if return_dict else outputs[1]
lowerCAmelCase_ : Tuple = self.classifier(lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = None
if labels is not None:
if self.config.problem_type is None:
if self.num_labels == 1:
lowerCAmelCase_ : List[str] = "regression"
elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
lowerCAmelCase_ : Dict = "single_label_classification"
else:
lowerCAmelCase_ : str = "multi_label_classification"
if self.config.problem_type == "regression":
lowerCAmelCase_ : Dict = MSELoss()
if self.num_labels == 1:
lowerCAmelCase_ : str = loss_fct(logits.squeeze() ,labels.squeeze() )
else:
lowerCAmelCase_ : List[Any] = loss_fct(lowerCAmelCase__ ,lowerCAmelCase__ )
elif self.config.problem_type == "single_label_classification":
lowerCAmelCase_ : Tuple = CrossEntropyLoss()
lowerCAmelCase_ : List[Any] = loss_fct(logits.view(-1 ,self.num_labels ) ,labels.view(-1 ) )
elif self.config.problem_type == "multi_label_classification":
lowerCAmelCase_ : int = BCEWithLogitsLoss()
lowerCAmelCase_ : Optional[int] = loss_fct(lowerCAmelCase__ ,lowerCAmelCase__ )
if not return_dict:
lowerCAmelCase_ : Dict = (logits,) + outputs[2:]
return (loss,) + output if loss is not None else output
return ImageClassifierOutputWithNoAttention(loss=lowerCAmelCase__ ,logits=lowerCAmelCase__ ,hidden_states=outputs.hidden_states )
| 710 |
_lowercase = {
0: '''0''',
1: '''1''',
2: '''2''',
3: '''3''',
4: '''4''',
5: '''5''',
6: '''6''',
7: '''7''',
8: '''8''',
9: '''9''',
10: '''a''',
11: '''b''',
12: '''c''',
13: '''d''',
14: '''e''',
15: '''f''',
}
def UpperCamelCase ( snake_case__):
assert type(snake_case__) in (int, float) and decimal == int(snake_case__)
lowerCAmelCase_ : Optional[Any] = int(snake_case__)
lowerCAmelCase_ : Tuple = ""
lowerCAmelCase_ : str = False
if decimal < 0:
lowerCAmelCase_ : Tuple = True
decimal *= -1
while decimal > 0:
lowerCAmelCase_ , lowerCAmelCase_ : Any = divmod(snake_case__ , 16)
lowerCAmelCase_ : Dict = values[remainder] + hexadecimal
lowerCAmelCase_ : List[str] = "0x" + hexadecimal
if negative:
lowerCAmelCase_ : Optional[Any] = "-" + hexadecimal
return hexadecimal
if __name__ == "__main__":
import doctest
doctest.testmod()
| 683 | 0 |
import os
import unittest
from transformers import LxmertTokenizer, LxmertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers
from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = LxmertTokenizer
UpperCamelCase_ = LxmertTokenizerFast
UpperCamelCase_ = True
UpperCamelCase_ = True
def UpperCAmelCase_ ( self : List[str] ) -> Optional[Any]:
'''simple docstring'''
super().setUp()
lowerCAmelCase_ : Dict = [
"[UNK]",
"[CLS]",
"[SEP]",
"want",
"##want",
"##ed",
"wa",
"un",
"runn",
"##ing",
",",
"low",
"lowest",
]
lowerCAmelCase_ : List[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["vocab_file"] )
with open(self.vocab_file ,"w" ,encoding="utf-8" ) as vocab_writer:
vocab_writer.write("".join([x + "\n" for x in vocab_tokens] ) )
def UpperCAmelCase_ ( self : int ,lowerCAmelCase__ : str ) -> Optional[Any]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = "UNwant\u00E9d,running"
lowerCAmelCase_ : str = "unwanted, running"
return input_text, output_text
def UpperCAmelCase_ ( self : Union[str, Any] ) -> List[str]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = self.tokenizer_class(self.vocab_file )
lowerCAmelCase_ : Tuple = tokenizer.tokenize("UNwant\u00E9d,running" )
self.assertListEqual(lowerCAmelCase__ ,["un", "##want", "##ed", ",", "runn", "##ing"] )
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,[7, 4, 5, 10, 8, 9] )
def UpperCAmelCase_ ( self : Tuple ) -> str:
'''simple docstring'''
if not self.test_rust_tokenizer:
return
lowerCAmelCase_ : Tuple = self.get_tokenizer()
lowerCAmelCase_ : Union[str, Any] = self.get_rust_tokenizer()
lowerCAmelCase_ : List[str] = "I was born in 92000, and this is falsé."
lowerCAmelCase_ : Optional[Any] = tokenizer.tokenize(lowerCAmelCase__ )
lowerCAmelCase_ : str = rust_tokenizer.tokenize(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ )
lowerCAmelCase_ : Tuple = rust_tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = self.get_rust_tokenizer()
lowerCAmelCase_ : Any = tokenizer.encode(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = rust_tokenizer.encode(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
| 711 |
from pathlib import Path
from typing import List
from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
_lowercase = ['''text''', '''image''', '''audio''']
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : int = []
for input_type in input_types:
if input_type == "text":
inputs.append("Text input")
elif input_type == "image":
inputs.append(
Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO")) / "000000039769.png").resize((5_12, 5_12)))
elif input_type == "audio":
inputs.append(torch.ones(30_00))
elif isinstance(snake_case__ , snake_case__):
inputs.append(create_inputs(snake_case__))
else:
raise ValueError(F'''Invalid type requested: {input_type}''')
return inputs
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : List[Any] = []
for output in outputs:
if isinstance(snake_case__ , (str, AgentText)):
output_types.append("text")
elif isinstance(snake_case__ , (Image.Image, AgentImage)):
output_types.append("image")
elif isinstance(snake_case__ , (torch.Tensor, AgentAudio)):
output_types.append("audio")
else:
raise ValueError(F'''Invalid output: {output}''')
return output_types
@is_tool_test
class __snake_case :
"""simple docstring"""
def UpperCAmelCase_ ( self : int ) -> int:
'''simple docstring'''
self.assertTrue(hasattr(self.tool ,"inputs" ) )
self.assertTrue(hasattr(self.tool ,"outputs" ) )
lowerCAmelCase_ : List[Any] = self.tool.inputs
for _input in inputs:
if isinstance(_input ,lowerCAmelCase__ ):
for __input in _input:
self.assertTrue(__input in authorized_types )
else:
self.assertTrue(_input in authorized_types )
lowerCAmelCase_ : Any = self.tool.outputs
for _output in outputs:
self.assertTrue(_output in authorized_types )
def UpperCAmelCase_ ( self : List[Any] ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Any = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
# There is a single output
if len(self.tool.outputs ) == 1:
lowerCAmelCase_ : Optional[int] = [outputs]
self.assertListEqual(output_types(lowerCAmelCase__ ) ,self.tool.outputs )
def UpperCAmelCase_ ( self : int ) -> Any:
'''simple docstring'''
self.assertTrue(hasattr(self.tool ,"description" ) )
self.assertTrue(hasattr(self.tool ,"default_checkpoint" ) )
self.assertTrue(self.tool.description.startswith("This is a tool that" ) )
def UpperCAmelCase_ ( self : List[Any] ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
if not isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : str = [outputs]
self.assertEqual(len(lowerCAmelCase__ ) ,len(self.tool.outputs ) )
for output, output_type in zip(lowerCAmelCase__ ,self.tool.outputs ):
lowerCAmelCase_ : Tuple = AGENT_TYPE_MAPPING[output_type]
self.assertTrue(isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) )
def UpperCAmelCase_ ( self : Any ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : Tuple = create_inputs(self.tool.inputs )
lowerCAmelCase_ : List[Any] = []
for _input, input_type in zip(lowerCAmelCase__ ,self.tool.inputs ):
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] )
else:
_inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) )
# Should not raise an error
lowerCAmelCase_ : List[Any] = self.tool(*lowerCAmelCase__ )
if not isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : int = [outputs]
self.assertEqual(len(lowerCAmelCase__ ) ,len(self.tool.outputs ) )
| 683 | 0 |
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
_lowercase = {
'''configuration_swinv2''': ['''SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Swinv2Config'''],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
_lowercase = [
'''SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST''',
'''Swinv2ForImageClassification''',
'''Swinv2ForMaskedImageModeling''',
'''Swinv2Model''',
'''Swinv2PreTrainedModel''',
]
if TYPE_CHECKING:
from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_swinva import (
SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
SwinvaForImageClassification,
SwinvaForMaskedImageModeling,
SwinvaModel,
SwinvaPreTrainedModel,
)
else:
import sys
_lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__) | 712 |
import pytest
_lowercase = '''__dummy_dataset1__'''
_lowercase = '''
import json
import os
import datasets
REPO_URL = "https://huggingface.co/datasets/albertvillanova/tests-raw-jsonl/resolve/main/"
URLS = {"train": REPO_URL + "wikiann-bn-train.jsonl", "validation": REPO_URL + "wikiann-bn-validation.jsonl"}
class __DummyDataset1__(datasets.GeneratorBasedBuilder):
def _info(self):
features = datasets.Features(
{
"tokens": datasets.Sequence(datasets.Value("string")),
"ner_tags": datasets.Sequence(
datasets.features.ClassLabel(
names=[
"O",
"B-PER",
"I-PER",
"B-ORG",
"I-ORG",
"B-LOC",
"I-LOC",
]
)
),
"langs": datasets.Sequence(datasets.Value("string")),
"spans": datasets.Sequence(datasets.Value("string")),
}
)
return datasets.DatasetInfo(features=features)
def _split_generators(self, dl_manager):
dl_path = dl_manager.download(URLS)
return [
datasets.SplitGenerator(datasets.Split.TRAIN, gen_kwargs={"filepath": dl_path["train"]}),
datasets.SplitGenerator(datasets.Split.VALIDATION, gen_kwargs={"filepath": dl_path["validation"]}),
]
def _generate_examples(self, filepath):
with open(filepath, "r", encoding="utf-8") as f:
for i, line in enumerate(f):
yield i, json.loads(line)
'''
@pytest.fixture
def UpperCamelCase ( ):
return DATASET_LOADING_SCRIPT_NAME
@pytest.fixture
def UpperCamelCase ( ):
return DATASET_LOADING_SCRIPT_CODE
@pytest.fixture
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = dataset_loading_script_name
lowerCAmelCase_ : List[str] = tmp_path / "datasets" / script_name
script_dir.mkdir(parents=snake_case__)
lowerCAmelCase_ : List[Any] = script_dir / F'''{script_name}.py'''
with open(snake_case__ , "w") as f:
f.write(snake_case__)
return str(snake_case__)
| 683 | 0 |
from typing import Dict, Optional
import numpy as np
import datasets
_lowercase = '''
IoU is the area of overlap between the predicted segmentation and the ground truth divided by the area of union
between the predicted segmentation and the ground truth. For binary (two classes) or multi-class segmentation,
the mean IoU of the image is calculated by taking the IoU of each class and averaging them.
'''
_lowercase = '''
Args:
predictions (`List[ndarray]`):
List of predicted segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.
references (`List[ndarray]`):
List of ground truth segmentation maps, each of shape (height, width). Each segmentation map can be of a different size.
num_labels (`int`):
Number of classes (categories).
ignore_index (`int`):
Index that will be ignored during evaluation.
nan_to_num (`int`, *optional*):
If specified, NaN values will be replaced by the number defined by the user.
label_map (`dict`, *optional*):
If specified, dictionary mapping old label indices to new label indices.
reduce_labels (`bool`, *optional*, defaults to `False`):
Whether or not to reduce all label values of segmentation maps by 1. Usually used for datasets where 0 is used for background,
and background itself is not included in all classes of a dataset (e.g. ADE20k). The background label will be replaced by 255.
Returns:
`Dict[str, float | ndarray]` comprising various elements:
- *mean_iou* (`float`):
Mean Intersection-over-Union (IoU averaged over all categories).
- *mean_accuracy* (`float`):
Mean accuracy (averaged over all categories).
- *overall_accuracy* (`float`):
Overall accuracy on all images.
- *per_category_accuracy* (`ndarray` of shape `(num_labels,)`):
Per category accuracy.
- *per_category_iou* (`ndarray` of shape `(num_labels,)`):
Per category IoU.
Examples:
>>> import numpy as np
>>> mean_iou = datasets.load_metric("mean_iou")
>>> # suppose one has 3 different segmentation maps predicted
>>> predicted_1 = np.array([[1, 2], [3, 4], [5, 255]])
>>> actual_1 = np.array([[0, 3], [5, 4], [6, 255]])
>>> predicted_2 = np.array([[2, 7], [9, 2], [3, 6]])
>>> actual_2 = np.array([[1, 7], [9, 2], [3, 6]])
>>> predicted_3 = np.array([[2, 2, 3], [8, 2, 4], [3, 255, 2]])
>>> actual_3 = np.array([[1, 2, 2], [8, 2, 1], [3, 255, 1]])
>>> predicted = [predicted_1, predicted_2, predicted_3]
>>> ground_truth = [actual_1, actual_2, actual_3]
>>> results = mean_iou.compute(predictions=predicted, references=ground_truth, num_labels=10, ignore_index=255, reduce_labels=False)
>>> print(results) # doctest: +NORMALIZE_WHITESPACE
{\'mean_iou\': 0.47750000000000004, \'mean_accuracy\': 0.5916666666666666, \'overall_accuracy\': 0.5263157894736842, \'per_category_iou\': array([0. , 0. , 0.375, 0.4 , 0.5 , 0. , 0.5 , 1. , 1. , 1. ]), \'per_category_accuracy\': array([0. , 0. , 0.75 , 0.66666667, 1. , 0. , 0.5 , 1. , 1. , 1. ])}
'''
_lowercase = '''\
@software{MMSegmentation_Contributors_OpenMMLab_Semantic_Segmentation_2020,
author = {{MMSegmentation Contributors}},
license = {Apache-2.0},
month = {7},
title = {{OpenMMLab Semantic Segmentation Toolbox and Benchmark}},
url = {https://github.com/open-mmlab/mmsegmentation},
year = {2020}
}'''
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ = None , snake_case__ = False , ):
if label_map is not None:
for old_id, new_id in label_map.items():
lowerCAmelCase_ : Optional[int] = new_id
# turn into Numpy arrays
lowerCAmelCase_ : str = np.array(snake_case__)
lowerCAmelCase_ : Tuple = np.array(snake_case__)
if reduce_labels:
lowerCAmelCase_ : Tuple = 2_55
lowerCAmelCase_ : Dict = label - 1
lowerCAmelCase_ : Any = 2_55
lowerCAmelCase_ : Optional[Any] = label != ignore_index
lowerCAmelCase_ : Union[str, Any] = np.not_equal(snake_case__ , snake_case__)
lowerCAmelCase_ : Union[str, Any] = pred_label[mask]
lowerCAmelCase_ : Any = np.array(snake_case__)[mask]
lowerCAmelCase_ : Optional[int] = pred_label[pred_label == label]
lowerCAmelCase_ : List[str] = np.histogram(snake_case__ , bins=snake_case__ , range=(0, num_labels - 1))[0]
lowerCAmelCase_ : Tuple = np.histogram(snake_case__ , bins=snake_case__ , range=(0, num_labels - 1))[0]
lowerCAmelCase_ : Optional[Any] = np.histogram(snake_case__ , bins=snake_case__ , range=(0, num_labels - 1))[0]
lowerCAmelCase_ : List[Any] = area_pred_label + area_label - area_intersect
return area_intersect, area_union, area_pred_label, area_label
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ = None , snake_case__ = False , ):
lowerCAmelCase_ : List[Any] = np.zeros((num_labels,) , dtype=np.floataa)
lowerCAmelCase_ : Tuple = np.zeros((num_labels,) , dtype=np.floataa)
lowerCAmelCase_ : str = np.zeros((num_labels,) , dtype=np.floataa)
lowerCAmelCase_ : Any = np.zeros((num_labels,) , dtype=np.floataa)
for result, gt_seg_map in zip(snake_case__ , snake_case__):
lowerCAmelCase_ : int = intersect_and_union(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__)
total_area_intersect += area_intersect
total_area_union += area_union
total_area_pred_label += area_pred_label
total_area_label += area_label
return total_area_intersect, total_area_union, total_area_pred_label, total_area_label
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ = None , snake_case__ = None , snake_case__ = False , ):
lowerCAmelCase_ : Optional[int] = total_intersect_and_union(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__)
# compute metrics
lowerCAmelCase_ : Dict = {}
lowerCAmelCase_ : Any = total_area_intersect.sum() / total_area_label.sum()
lowerCAmelCase_ : Any = total_area_intersect / total_area_union
lowerCAmelCase_ : Optional[int] = total_area_intersect / total_area_label
lowerCAmelCase_ : List[str] = np.nanmean(snake_case__)
lowerCAmelCase_ : Union[str, Any] = np.nanmean(snake_case__)
lowerCAmelCase_ : Tuple = all_acc
lowerCAmelCase_ : List[str] = iou
lowerCAmelCase_ : List[Any] = acc
if nan_to_num is not None:
lowerCAmelCase_ : List[str] = {metric: np.nan_to_num(snake_case__ , nan=snake_case__) for metric, metric_value in metrics.items()}
return metrics
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __snake_case ( datasets.Metric ):
"""simple docstring"""
def UpperCAmelCase_ ( self : Dict ) -> Optional[Any]:
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features(
# 1st Seq - height dim, 2nd - width dim
{
"predictions": datasets.Sequence(datasets.Sequence(datasets.Value("uint16" ) ) ),
"references": datasets.Sequence(datasets.Sequence(datasets.Value("uint16" ) ) ),
} ) ,reference_urls=[
"https://github.com/open-mmlab/mmsegmentation/blob/71c201b1813267d78764f306a297ca717827c4bf/mmseg/core/evaluation/metrics.py"
] ,)
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : Tuple ,lowerCAmelCase__ : Dict ,lowerCAmelCase__ : int ,lowerCAmelCase__ : bool ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[Dict[int, int]] = None ,lowerCAmelCase__ : bool = False ,) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : str = mean_iou(
results=lowerCAmelCase__ ,gt_seg_maps=lowerCAmelCase__ ,num_labels=lowerCAmelCase__ ,ignore_index=lowerCAmelCase__ ,nan_to_num=lowerCAmelCase__ ,label_map=lowerCAmelCase__ ,reduce_labels=lowerCAmelCase__ ,)
return iou_result
| 713 |
import json
import os
import re
import unittest
from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow
from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class __snake_case ( snake_case__ , unittest.TestCase ):
"""simple docstring"""
UpperCamelCase_ = CodeGenTokenizer
UpperCamelCase_ = CodeGenTokenizerFast
UpperCamelCase_ = True
UpperCamelCase_ = {'add_prefix_space': True}
UpperCamelCase_ = False
def UpperCAmelCase_ ( self : str ) -> Tuple:
'''simple docstring'''
super().setUp()
# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
lowerCAmelCase_ : Optional[Any] = [
"l",
"o",
"w",
"e",
"r",
"s",
"t",
"i",
"d",
"n",
"\u0120",
"\u0120l",
"\u0120n",
"\u0120lo",
"\u0120low",
"er",
"\u0120lowest",
"\u0120newer",
"\u0120wider",
"<unk>",
"<|endoftext|>",
]
lowerCAmelCase_ : int = dict(zip(lowerCAmelCase__ ,range(len(lowerCAmelCase__ ) ) ) )
lowerCAmelCase_ : Dict = ["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
lowerCAmelCase_ : List[Any] = {"unk_token": "<unk>"}
lowerCAmelCase_ : List[Any] = os.path.join(self.tmpdirname ,VOCAB_FILES_NAMES["vocab_file"] )
lowerCAmelCase_ : Tuple = 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 UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : str ) -> int:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizer.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,**lowerCAmelCase__ : Optional[Any] ) -> Tuple:
'''simple docstring'''
kwargs.update(self.special_tokens_map )
return CodeGenTokenizerFast.from_pretrained(self.tmpdirname ,**lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : str ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = "lower newer"
lowerCAmelCase_ : Tuple = "lower newer"
return input_text, output_text
def UpperCAmelCase_ ( self : Optional[Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer(self.vocab_file ,self.merges_file ,**self.special_tokens_map )
lowerCAmelCase_ : Dict = "lower newer"
lowerCAmelCase_ : Dict = ["\u0120low", "er", "\u0120", "n", "e", "w", "er"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokens + [tokenizer.unk_token]
lowerCAmelCase_ : Union[str, Any] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : List[str] ) -> Optional[Any]:
'''simple docstring'''
if not self.test_rust_tokenizer:
return
lowerCAmelCase_ : Tuple = self.get_tokenizer()
lowerCAmelCase_ : Optional[int] = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = "lower newer"
# Testing tokenization
lowerCAmelCase_ : Tuple = tokenizer.tokenize(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.tokenize(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids without special tokens
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Any = rust_tokenizer.encode(lowerCAmelCase__ ,add_special_tokens=lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing conversion to ids with special tokens
lowerCAmelCase_ : int = self.get_rust_tokenizer(add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : str = tokenizer.encode(lowerCAmelCase__ ,add_prefix_space=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = rust_tokenizer.encode(lowerCAmelCase__ )
self.assertListEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
# Testing the unknown token
lowerCAmelCase_ : Union[str, Any] = tokens + [rust_tokenizer.unk_token]
lowerCAmelCase_ : List[str] = [14, 15, 10, 9, 3, 2, 15, 19]
self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(lowerCAmelCase__ ) ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[int] ,*lowerCAmelCase__ : List[str] ,**lowerCAmelCase__ : Optional[Any] ) -> List[str]:
'''simple docstring'''
pass
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : Any=15 ) -> str:
'''simple docstring'''
for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
lowerCAmelCase_ : Any = self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__ ,**lowerCAmelCase__ )
# Simple input
lowerCAmelCase_ : int = "This is a simple input"
lowerCAmelCase_ : Dict = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : str = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : Optional[int] = [
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
]
# Simple input tests
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Simple input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(lowerCAmelCase__ ,tokenizer_r.encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" )
# Pair input
self.assertRaises(
lowerCAmelCase__ ,tokenizer_r.batch_encode_plus ,lowerCAmelCase__ ,max_length=lowerCAmelCase__ ,padding="max_length" ,)
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Tuple = CodeGenTokenizer.from_pretrained(self.tmpdirname ,pad_token="<pad>" )
# Simple input
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : List[str] = ["This is a simple input looooooooong", "This is a simple input"]
lowerCAmelCase_ : Any = ("This is a simple input", "This is a pair")
lowerCAmelCase_ : List[str] = [
("This is a simple input loooooong", "This is a simple input"),
("This is a simple pair loooooong", "This is a simple pair"),
]
lowerCAmelCase_ : Dict = tokenizer.pad_token_id
lowerCAmelCase_ : Union[str, Any] = tokenizer(lowerCAmelCase__ ,padding="max_length" ,max_length=30 ,return_tensors="np" )
lowerCAmelCase_ : Tuple = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
lowerCAmelCase_ : Any = tokenizer(*lowerCAmelCase__ ,padding="max_length" ,max_length=60 ,return_tensors="np" )
lowerCAmelCase_ : Optional[int] = tokenizer(lowerCAmelCase__ ,padding=lowerCAmelCase__ ,truncate=lowerCAmelCase__ ,return_tensors="np" )
# s
# test single string max_length padding
self.assertEqual(out_s["input_ids"].shape[-1] ,30 )
self.assertTrue(pad_token_id in out_s["input_ids"] )
self.assertTrue(0 in out_s["attention_mask"] )
# s2
# test automatic padding
self.assertEqual(out_sa["input_ids"].shape[-1] ,33 )
# long slice doesn't have padding
self.assertFalse(pad_token_id in out_sa["input_ids"][0] )
self.assertFalse(0 in out_sa["attention_mask"][0] )
# short slice does have padding
self.assertTrue(pad_token_id in out_sa["input_ids"][1] )
self.assertTrue(0 in out_sa["attention_mask"][1] )
# p
# test single pair max_length padding
self.assertEqual(out_p["input_ids"].shape[-1] ,60 )
self.assertTrue(pad_token_id in out_p["input_ids"] )
self.assertTrue(0 in out_p["attention_mask"] )
# p2
# test automatic padding pair
self.assertEqual(out_pa["input_ids"].shape[-1] ,52 )
# long slice pair doesn't have padding
self.assertFalse(pad_token_id in out_pa["input_ids"][0] )
self.assertFalse(0 in out_pa["attention_mask"][0] )
# short slice pair does have padding
self.assertTrue(pad_token_id in out_pa["input_ids"][1] )
self.assertTrue(0 in out_pa["attention_mask"][1] )
def UpperCAmelCase_ ( self : Union[str, Any] ) -> Any:
'''simple docstring'''
lowerCAmelCase_ : Any = "$$$"
lowerCAmelCase_ : List[str] = CodeGenTokenizer.from_pretrained(self.tmpdirname ,bos_token=lowerCAmelCase__ ,add_bos_token=lowerCAmelCase__ )
lowerCAmelCase_ : Dict = "This is a simple input"
lowerCAmelCase_ : Union[str, Any] = ["This is a simple input 1", "This is a simple input 2"]
lowerCAmelCase_ : int = tokenizer.bos_token_id
lowerCAmelCase_ : List[Any] = tokenizer(lowerCAmelCase__ )
lowerCAmelCase_ : Optional[Any] = tokenizer(lowerCAmelCase__ )
self.assertEqual(out_s.input_ids[0] ,lowerCAmelCase__ )
self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids ) )
lowerCAmelCase_ : List[str] = tokenizer.decode(out_s.input_ids )
lowerCAmelCase_ : Optional[Any] = tokenizer.batch_decode(out_sa.input_ids )
self.assertEqual(decode_s.split()[0] ,lowerCAmelCase__ )
self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa ) )
@slow
def UpperCAmelCase_ ( self : Any ) -> Optional[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = CodeGenTokenizer.from_pretrained("Salesforce/codegen-350M-mono" )
lowerCAmelCase_ : str = "\nif len_a > len_b:\n result = a\nelse:\n result = b\n\n\n\n#"
lowerCAmelCase_ : int = "\nif len_a > len_b: result = a\nelse: result = b"
lowerCAmelCase_ : Dict = tokenizer.encode(lowerCAmelCase__ )
lowerCAmelCase_ : str = ["^#", re.escape("<|endoftext|>" ), "^'''", "^\"\"\"", "\n\n\n"]
lowerCAmelCase_ : Union[str, Any] = tokenizer.decode(lowerCAmelCase__ ,truncate_before_pattern=lowerCAmelCase__ )
self.assertEqual(lowerCAmelCase__ ,lowerCAmelCase__ )
def UpperCAmelCase_ ( self : Optional[Any] ) -> Optional[Any]:
'''simple docstring'''
pass
| 683 | 0 |
from __future__ import annotations
from functools import lru_cache
from math import ceil
_lowercase = 100
_lowercase = set(range(3, NUM_PRIMES, 2))
primes.add(2)
_lowercase = 42
for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
if prime not in primes:
continue
primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))
@lru_cache(maxsize=1_00)
def UpperCamelCase ( snake_case__):
if number_to_partition < 0:
return set()
elif number_to_partition == 0:
return {1}
lowerCAmelCase_ : set[int] = set()
lowerCAmelCase_ : int
lowerCAmelCase_ : int
for prime in primes:
if prime > number_to_partition:
continue
for sub in partition(number_to_partition - prime):
ret.add(sub * prime)
return ret
def UpperCamelCase ( snake_case__ = 50_00):
for number_to_partition in range(1 , snake_case__):
if len(partition(snake_case__)) > number_unique_partitions:
return number_to_partition
return None
if __name__ == "__main__":
print(f"{solution() = }")
| 714 |
from __future__ import annotations
from random import random
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[int] ,lowerCAmelCase__ : int | None = None ) -> int:
'''simple docstring'''
lowerCAmelCase_ : Dict = value
lowerCAmelCase_ : Any = random()
lowerCAmelCase_ : Node | None = None
lowerCAmelCase_ : Node | None = None
def __repr__( self : Any ) -> str:
'''simple docstring'''
from pprint import pformat
if self.left is None and self.right is None:
return f'''\'{self.value}: {self.prior:.5}\''''
else:
return pformat(
{f'''{self.value}: {self.prior:.5}''': (self.left, self.right)} ,indent=1 )
def __str__( self : str ) -> str:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = str(self.value ) + " "
lowerCAmelCase_ : List[Any] = str(self.left or "" )
lowerCAmelCase_ : Union[str, Any] = str(self.right or "" )
return value + left + right
def UpperCamelCase ( snake_case__ , snake_case__):
if root is None: # None tree is split into 2 Nones
return None, None
elif root.value is None:
return None, None
else:
if value < root.value:
lowerCAmelCase_ , lowerCAmelCase_ : Any = split(root.left , snake_case__)
return left, root
else:
lowerCAmelCase_ , lowerCAmelCase_ : Optional[Any] = split(root.right , snake_case__)
return root, right
def UpperCamelCase ( snake_case__ , snake_case__):
if (not left) or (not right): # If one node is None, return the other
return left or right
elif left.prior < right.prior:
lowerCAmelCase_ : Dict = merge(left.right , snake_case__)
return left
else:
lowerCAmelCase_ : List[str] = merge(snake_case__ , right.left)
return right
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = Node(snake_case__)
lowerCAmelCase_ , lowerCAmelCase_ : Tuple = split(snake_case__ , snake_case__)
return merge(merge(snake_case__ , snake_case__) , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ , lowerCAmelCase_ : List[str] = split(snake_case__ , value - 1)
lowerCAmelCase_ , lowerCAmelCase_ : Union[str, Any] = split(snake_case__ , snake_case__)
return merge(snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__):
if not root: # None
return
else:
inorder(root.left)
print(root.value , end=",")
inorder(root.right)
def UpperCamelCase ( snake_case__ , snake_case__):
for arg in args.split():
if arg[0] == "+":
lowerCAmelCase_ : List[str] = insert(snake_case__ , int(arg[1:]))
elif arg[0] == "-":
lowerCAmelCase_ : Optional[int] = erase(snake_case__ , int(arg[1:]))
else:
print("Unknown command")
return root
def UpperCamelCase ( ):
lowerCAmelCase_ : str = None
print(
"enter numbers to create a tree, + value to add value into treap, "
"- value to erase all nodes with value. 'q' to quit. ")
lowerCAmelCase_ : str = input()
while args != "q":
lowerCAmelCase_ : int = interact_treap(snake_case__ , snake_case__)
print(snake_case__)
lowerCAmelCase_ : str = input()
print("good by!")
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 683 | 0 |
import os
from shutil import copyfile
from typing import List, Optional, Tuple
from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging
if is_sentencepiece_available():
from .tokenization_albert import AlbertTokenizer
else:
_lowercase = None
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''}
_lowercase = {
'''vocab_file''': {
'''albert-base-v1''': '''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''',
'''albert-large-v1''': '''https://huggingface.co/albert-large-v1/resolve/main/spiece.model''',
'''albert-xlarge-v1''': '''https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model''',
'''albert-xxlarge-v1''': '''https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model''',
'''albert-base-v2''': '''https://huggingface.co/albert-base-v2/resolve/main/spiece.model''',
'''albert-large-v2''': '''https://huggingface.co/albert-large-v2/resolve/main/spiece.model''',
'''albert-xlarge-v2''': '''https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model''',
'''albert-xxlarge-v2''': '''https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model''',
},
'''tokenizer_file''': {
'''albert-base-v1''': '''https://huggingface.co/albert-base-v1/resolve/main/tokenizer.json''',
'''albert-large-v1''': '''https://huggingface.co/albert-large-v1/resolve/main/tokenizer.json''',
'''albert-xlarge-v1''': '''https://huggingface.co/albert-xlarge-v1/resolve/main/tokenizer.json''',
'''albert-xxlarge-v1''': '''https://huggingface.co/albert-xxlarge-v1/resolve/main/tokenizer.json''',
'''albert-base-v2''': '''https://huggingface.co/albert-base-v2/resolve/main/tokenizer.json''',
'''albert-large-v2''': '''https://huggingface.co/albert-large-v2/resolve/main/tokenizer.json''',
'''albert-xlarge-v2''': '''https://huggingface.co/albert-xlarge-v2/resolve/main/tokenizer.json''',
'''albert-xxlarge-v2''': '''https://huggingface.co/albert-xxlarge-v2/resolve/main/tokenizer.json''',
},
}
_lowercase = {
'''albert-base-v1''': 512,
'''albert-large-v1''': 512,
'''albert-xlarge-v1''': 512,
'''albert-xxlarge-v1''': 512,
'''albert-base-v2''': 512,
'''albert-large-v2''': 512,
'''albert-xlarge-v2''': 512,
'''albert-xxlarge-v2''': 512,
}
_lowercase = '''▁'''
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = AlbertTokenizer
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Any=None ,lowerCAmelCase__ : str=None ,lowerCAmelCase__ : Union[str, Any]=True ,lowerCAmelCase__ : Dict=True ,lowerCAmelCase__ : List[Any]=False ,lowerCAmelCase__ : Optional[int]="[CLS]" ,lowerCAmelCase__ : List[Any]="[SEP]" ,lowerCAmelCase__ : Dict="<unk>" ,lowerCAmelCase__ : int="[SEP]" ,lowerCAmelCase__ : Optional[Any]="<pad>" ,lowerCAmelCase__ : List[str]="[CLS]" ,lowerCAmelCase__ : Optional[Any]="[MASK]" ,**lowerCAmelCase__ : Optional[int] ,) -> int:
'''simple docstring'''
lowerCAmelCase_ : int = (
AddedToken(lowerCAmelCase__ ,lstrip=lowerCAmelCase__ ,rstrip=lowerCAmelCase__ ,normalized=lowerCAmelCase__ )
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ )
else mask_token
)
super().__init__(
lowerCAmelCase__ ,tokenizer_file=lowerCAmelCase__ ,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__ ,)
lowerCAmelCase_ : Dict = do_lower_case
lowerCAmelCase_ : List[str] = remove_space
lowerCAmelCase_ : Any = keep_accents
lowerCAmelCase_ : Optional[Any] = vocab_file
lowerCAmelCase_ : Optional[int] = False if not self.vocab_file else True
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : List[str] = [self.sep_token_id]
lowerCAmelCase_ : Dict = [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 UpperCAmelCase_ ( self : Dict ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = [self.sep_token_id]
lowerCAmelCase_ : Union[str, Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def UpperCAmelCase_ ( self : str ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
if not self.can_save_slow_tokenizer:
raise ValueError(
"Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
"tokenizer." )
if not os.path.isdir(lowerCAmelCase__ ):
logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
return
lowerCAmelCase_ : List[Any] = 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,)
| 715 |
import json
from typing import List, Optional, Tuple
from tokenizers import normalizers
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer
_lowercase = logging.get_logger(__name__)
_lowercase = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}
_lowercase = [
'''small''',
'''small-base''',
'''medium''',
'''medium-base''',
'''intermediate''',
'''intermediate-base''',
'''large''',
'''large-base''',
'''xlarge''',
'''xlarge-base''',
]
_lowercase = {
'''vocab_file''': {
'''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt''',
'''funnel-transformer/small-base''': '''https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt''',
'''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt''',
'''funnel-transformer/medium-base''': (
'''https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'''
),
'''funnel-transformer/intermediate''': (
'''https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'''
),
'''funnel-transformer/intermediate-base''': (
'''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'''
),
'''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt''',
'''funnel-transformer/large-base''': '''https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt''',
'''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt''',
'''funnel-transformer/xlarge-base''': (
'''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'''
),
},
'''tokenizer_file''': {
'''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json''',
'''funnel-transformer/small-base''': (
'''https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json''',
'''funnel-transformer/medium-base''': (
'''https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/intermediate''': (
'''https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'''
),
'''funnel-transformer/intermediate-base''': (
'''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json''',
'''funnel-transformer/large-base''': (
'''https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'''
),
'''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json''',
'''funnel-transformer/xlarge-base''': (
'''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'''
),
},
}
_lowercase = {f"funnel-transformer/{name}": 512 for name in _model_names}
_lowercase = {f"funnel-transformer/{name}": {'''do_lower_case''': True} for name in _model_names}
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = VOCAB_FILES_NAMES
UpperCamelCase_ = PRETRAINED_VOCAB_FILES_MAP
UpperCamelCase_ = PRETRAINED_INIT_CONFIGURATION
UpperCamelCase_ = FunnelTokenizer
UpperCamelCase_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
UpperCamelCase_ = 2
def __init__( self : Optional[Any] ,lowerCAmelCase__ : Any=None ,lowerCAmelCase__ : Optional[int]=None ,lowerCAmelCase__ : Optional[Any]=True ,lowerCAmelCase__ : List[str]="<unk>" ,lowerCAmelCase__ : int="<sep>" ,lowerCAmelCase__ : Union[str, Any]="<pad>" ,lowerCAmelCase__ : List[str]="<cls>" ,lowerCAmelCase__ : Optional[int]="<mask>" ,lowerCAmelCase__ : Union[str, Any]="<s>" ,lowerCAmelCase__ : List[str]="</s>" ,lowerCAmelCase__ : Optional[int]=True ,lowerCAmelCase__ : Tuple=True ,lowerCAmelCase__ : Any=None ,lowerCAmelCase__ : List[Any]="##" ,**lowerCAmelCase__ : int ,) -> List[Any]:
'''simple docstring'''
super().__init__(
lowerCAmelCase__ ,tokenizer_file=lowerCAmelCase__ ,do_lower_case=lowerCAmelCase__ ,unk_token=lowerCAmelCase__ ,sep_token=lowerCAmelCase__ ,pad_token=lowerCAmelCase__ ,cls_token=lowerCAmelCase__ ,mask_token=lowerCAmelCase__ ,bos_token=lowerCAmelCase__ ,eos_token=lowerCAmelCase__ ,clean_text=lowerCAmelCase__ ,tokenize_chinese_chars=lowerCAmelCase__ ,strip_accents=lowerCAmelCase__ ,wordpieces_prefix=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : str = json.loads(self.backend_tokenizer.normalizer.__getstate__() )
if (
normalizer_state.get("lowercase" ,lowerCAmelCase__ ) != do_lower_case
or normalizer_state.get("strip_accents" ,lowerCAmelCase__ ) != strip_accents
or normalizer_state.get("handle_chinese_chars" ,lowerCAmelCase__ ) != tokenize_chinese_chars
):
lowerCAmelCase_ : Optional[int] = getattr(lowerCAmelCase__ ,normalizer_state.pop("type" ) )
lowerCAmelCase_ : List[Any] = do_lower_case
lowerCAmelCase_ : List[str] = strip_accents
lowerCAmelCase_ : Any = tokenize_chinese_chars
lowerCAmelCase_ : List[Any] = normalizer_class(**lowerCAmelCase__ )
lowerCAmelCase_ : int = do_lower_case
def UpperCAmelCase_ ( self : Tuple ,lowerCAmelCase__ : int ,lowerCAmelCase__ : str=None ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Union[str, Any] = [self.cls_token_id] + token_ids_a + [self.sep_token_id]
if token_ids_a:
output += token_ids_a + [self.sep_token_id]
return output
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : List[int] ,lowerCAmelCase__ : Optional[List[int]] = None ) -> List[int]:
'''simple docstring'''
lowerCAmelCase_ : str = [self.sep_token_id]
lowerCAmelCase_ : Optional[Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0]
return len(cls ) * [self.cls_token_type_id] + len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : str ,lowerCAmelCase__ : Optional[str] = None ) -> Tuple[str]:
'''simple docstring'''
lowerCAmelCase_ : str = self._tokenizer.model.save(lowerCAmelCase__ ,name=lowerCAmelCase__ )
return tuple(lowerCAmelCase__ )
| 683 | 0 |
from __future__ import annotations
class __snake_case :
"""simple docstring"""
def __init__( self : Optional[Any] ,lowerCAmelCase__ : str ,lowerCAmelCase__ : str ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : List[Any] = text, pattern
lowerCAmelCase_ : int = len(lowerCAmelCase__ ), len(lowerCAmelCase__ )
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : str ) -> int:
'''simple docstring'''
for i in range(self.patLen - 1 ,-1 ,-1 ):
if char == self.pattern[i]:
return i
return -1
def UpperCAmelCase_ ( self : Union[str, Any] ,lowerCAmelCase__ : int ) -> int:
'''simple docstring'''
for i in range(self.patLen - 1 ,-1 ,-1 ):
if self.pattern[i] != self.text[current_pos + i]:
return current_pos + i
return -1
def UpperCAmelCase_ ( self : Optional[int] ) -> list[int]:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = []
for i in range(self.textLen - self.patLen + 1 ):
lowerCAmelCase_ : int = self.mismatch_in_text(lowerCAmelCase__ )
if mismatch_index == -1:
positions.append(lowerCAmelCase__ )
else:
lowerCAmelCase_ : Tuple = self.match_in_pattern(self.text[mismatch_index] )
lowerCAmelCase_ : Optional[Any] = (
mismatch_index - match_index
) # shifting index lgtm [py/multiple-definition]
return positions
_lowercase = '''ABAABA'''
_lowercase = '''AB'''
_lowercase = BoyerMooreSearch(text, pattern)
_lowercase = bms.bad_character_heuristic()
if len(positions) == 0:
print('''No match found''')
else:
print('''Pattern found in following positions: ''')
print(positions)
| 716 |
# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run
import doctest
import sys
import warnings
from os.path import abspath, dirname, join
import _pytest
from transformers.testing_utils import HfDoctestModule, HfDocTestParser
# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
_lowercase = abspath(join(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 UpperCamelCase ( snake_case__):
config.addinivalue_line(
"markers" , "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested")
config.addinivalue_line(
"markers" , "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested")
config.addinivalue_line("markers" , "is_pipeline_test: mark test to run only when pipelines are tested")
config.addinivalue_line("markers" , "is_staging_test: mark test to run only in the staging environment")
config.addinivalue_line("markers" , "accelerate_tests: mark test that require accelerate")
config.addinivalue_line("markers" , "tool_tests: mark the tool tests that are run on their specific schedule")
def UpperCamelCase ( snake_case__):
from transformers.testing_utils import pytest_addoption_shared
pytest_addoption_shared(snake_case__)
def UpperCamelCase ( snake_case__):
from transformers.testing_utils import pytest_terminal_summary_main
lowerCAmelCase_ : int = terminalreporter.config.getoption("--make-reports")
if make_reports:
pytest_terminal_summary_main(snake_case__ , id=snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__):
# If no tests are collected, pytest exists with code 5, which makes the CI fail.
if exitstatus == 5:
lowerCAmelCase_ : List[Any] = 0
# Doctest custom flag to ignore output.
_lowercase = doctest.register_optionflag('''IGNORE_RESULT''')
_lowercase = doctest.OutputChecker
class __snake_case ( snake_case__ ):
"""simple docstring"""
def UpperCAmelCase_ ( self : List[str] ,lowerCAmelCase__ : int ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : Tuple ) -> Any:
'''simple docstring'''
if IGNORE_RESULT & optionflags:
return True
return OutputChecker.check_output(self ,lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
_lowercase = CustomOutputChecker
_lowercase = HfDoctestModule
_lowercase = HfDocTestParser
| 683 | 0 |
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
_lowercase = trt.Logger(trt.Logger.WARNING)
_lowercase = absl_logging.get_absl_logger()
absl_logger.setLevel(logging.WARNING)
_lowercase = logging.getLogger(__name__)
_lowercase = 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''',
)
_lowercase = parser.parse_args()
if args.tokenizer_name:
_lowercase = 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)
_lowercase = args.per_device_eval_batch_size
_lowercase = (args.eval_batch_size, args.max_seq_length)
# TRT Engine properties
_lowercase = True
_lowercase = '''temp_engine/bert-fp32.engine'''
if args.fpaa:
_lowercase = '''temp_engine/bert-fp16.engine'''
if args.inta:
_lowercase = '''temp_engine/bert-int8.engine'''
# import ONNX file
if not os.path.exists('''temp_engine'''):
os.makedirs('''temp_engine''')
_lowercase = 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
_lowercase = [network.get_input(i) for i in range(network.num_inputs)]
_lowercase = [_input.name for _input in network_inputs] # ex: ["actual_input1"]
with builder.create_builder_config() as config:
_lowercase = 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)
_lowercase = 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)
_lowercase = 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 UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : List[Any] = np.asarray(inputs["input_ids"] , dtype=np.intaa)
lowerCAmelCase_ : Tuple = np.asarray(inputs["attention_mask"] , dtype=np.intaa)
lowerCAmelCase_ : Any = np.asarray(inputs["token_type_ids"] , dtype=np.intaa)
# Copy inputs
cuda.memcpy_htod_async(d_inputs[0] , input_ids.ravel() , snake_case__)
cuda.memcpy_htod_async(d_inputs[1] , attention_mask.ravel() , snake_case__)
cuda.memcpy_htod_async(d_inputs[2] , token_type_ids.ravel() , snake_case__)
# start time
lowerCAmelCase_ : str = time.time()
# Run inference
context.execute_async(
bindings=[int(snake_case__) for d_inp in d_inputs] + [int(snake_case__), int(snake_case__)] , stream_handle=stream.handle)
# Transfer predictions back from GPU
cuda.memcpy_dtoh_async(snake_case__ , snake_case__ , snake_case__)
cuda.memcpy_dtoh_async(snake_case__ , snake_case__ , snake_case__)
# Synchronize the stream and take time
stream.synchronize()
# end time
lowerCAmelCase_ : List[str] = time.time()
lowerCAmelCase_ : Optional[Any] = end_time - start_time
lowerCAmelCase_ : Dict = (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.
_lowercase = 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.
_lowercase = 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.
_lowercase = raw_datasets['''validation'''].column_names
_lowercase = '''question''' if '''question''' in column_names else column_names[0]
_lowercase = '''context''' if '''context''' in column_names else column_names[1]
_lowercase = '''answers''' if '''answers''' in column_names else column_names[2]
# Padding side determines if we do (question|context) or (context|question).
_lowercase = 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}."
)
_lowercase = min(args.max_seq_length, tokenizer.model_max_length)
def UpperCamelCase ( snake_case__):
# 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
lowerCAmelCase_ : str = [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.
lowerCAmelCase_ : Union[str, Any] = 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=snake_case__ , stride=args.doc_stride , return_overflowing_tokens=snake_case__ , return_offsets_mapping=snake_case__ , 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.
lowerCAmelCase_ : List[str] = 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.
lowerCAmelCase_ : Optional[int] = []
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).
lowerCAmelCase_ : Any = tokenized_examples.sequence_ids(snake_case__)
lowerCAmelCase_ : Any = 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.
lowerCAmelCase_ : Union[str, Any] = 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.
lowerCAmelCase_ : List[str] = [
(o if sequence_ids[k] == context_index else None)
for k, o in enumerate(tokenized_examples["offset_mapping"][i])
]
return tokenized_examples
_lowercase = raw_datasets['''validation''']
# Validation Feature Creation
_lowercase = 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''',
)
_lowercase = default_data_collator
_lowercase = eval_dataset.remove_columns(['''example_id''', '''offset_mapping'''])
_lowercase = DataLoader(
eval_dataset_for_model, collate_fn=data_collator, batch_size=args.per_device_eval_batch_size
)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__="eval"):
# Post-processing: we match the start logits and end logits to answers in the original context.
lowerCAmelCase_ : Union[str, Any] = postprocess_qa_predictions(
examples=snake_case__ , features=snake_case__ , predictions=snake_case__ , 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=snake_case__ , )
# Format the result to the format the metric expects.
if args.version_2_with_negative:
lowerCAmelCase_ : int = [
{"id": k, "prediction_text": v, "no_answer_probability": 0.0} for k, v in predictions.items()
]
else:
lowerCAmelCase_ : Tuple = [{"id": k, "prediction_text": v} for k, v in predictions.items()]
lowerCAmelCase_ : List[Any] = [{"id": ex["id"], "answers": ex[answer_column_name]} for ex in examples]
return EvalPrediction(predictions=snake_case__ , label_ids=snake_case__)
_lowercase = 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 UpperCamelCase ( snake_case__):
return trt.volume(engine.get_binding_shape(snake_case__)) * engine.get_binding_dtype(snake_case__).itemsize
# Allocate device memory for inputs and outputs.
_lowercase = [cuda.mem_alloc(binding_nbytes(binding)) for binding in engine if engine.binding_is_input(binding)]
# Allocate output buffer
_lowercase = cuda.pagelocked_empty(tuple(context.get_binding_shape(3)), dtype=np.floataa)
_lowercase = cuda.pagelocked_empty(tuple(context.get_binding_shape(4)), dtype=np.floataa)
_lowercase = cuda.mem_alloc(h_outputa.nbytes)
_lowercase = cuda.mem_alloc(h_outputa.nbytes)
# Create a stream in which to copy inputs/outputs and run inference.
_lowercase = 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}")
_lowercase = 0.0
_lowercase = 0
_lowercase = timeit.default_timer()
_lowercase = None
for step, batch in enumerate(eval_dataloader):
_lowercase , _lowercase = model_infer(batch, context, d_inputs, h_outputa, h_outputa, d_outputa, d_outputa, stream)
total_time += infer_time
niter += 1
_lowercase , _lowercase = outputs
_lowercase = torch.tensor(start_logits)
_lowercase = torch.tensor(end_logits)
# necessary to pad predictions and labels for being gathered
_lowercase = accelerator.pad_across_processes(start_logits, dim=1, pad_index=-100)
_lowercase = accelerator.pad_across_processes(end_logits, dim=1, pad_index=-100)
_lowercase = (accelerator.gather(start_logits).cpu().numpy(), accelerator.gather(end_logits).cpu().numpy())
_lowercase = logits if all_preds is None else nested_concat(all_preds, logits, padding_index=-100)
if all_preds is not None:
_lowercase = nested_truncate(all_preds, len(eval_dataset))
_lowercase = 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 * 1000 / niter))
logger.info('''Total Inference Time = {:.3f} ms'''.format(total_time * 1000))
logger.info('''Total Number of Inference = %d''', niter)
_lowercase = post_processing_function(eval_examples, eval_dataset, all_preds)
_lowercase = metric.compute(predictions=prediction.predictions, references=prediction.label_ids)
logger.info(f"Evaluation metrics: {eval_metric}")
| 717 |
from __future__ import annotations
from collections.abc import Sequence
from typing import Literal
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = list(snake_case__)
lowerCAmelCase_ : Tuple = list(snake_case__)
lowerCAmelCase_ : List[str] = 0
for i in range(len(snake_case__)):
if lista[i] != lista[i]:
count += 1
lowerCAmelCase_ : Dict = "_"
if count > 1:
return False
else:
return "".join(snake_case__)
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Union[str, Any] = []
while True:
lowerCAmelCase_ : Tuple = ["$"] * len(snake_case__)
lowerCAmelCase_ : Tuple = []
for i in range(len(snake_case__)):
for j in range(i + 1 , len(snake_case__)):
lowerCAmelCase_ : Optional[int] = compare_string(binary[i] , binary[j])
if k is False:
lowerCAmelCase_ : str = "*"
lowerCAmelCase_ : Tuple = "*"
temp.append("X")
for i in range(len(snake_case__)):
if checka[i] == "$":
pi.append(binary[i])
if len(snake_case__) == 0:
return pi
lowerCAmelCase_ : List[Any] = list(set(snake_case__))
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[int] = []
for minterm in minterms:
lowerCAmelCase_ : Dict = ""
for _ in range(snake_case__):
lowerCAmelCase_ : Dict = str(minterm % 2) + string
minterm //= 2
temp.append(snake_case__)
return temp
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = list(snake_case__)
lowerCAmelCase_ : Dict = list(snake_case__)
lowerCAmelCase_ : Dict = 0
for i in range(len(snake_case__)):
if lista[i] != lista[i]:
count_n += 1
return count_n == count
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = []
lowerCAmelCase_ : Dict = [0] * len(snake_case__)
for i in range(len(chart[0])):
lowerCAmelCase_ : List[Any] = 0
lowerCAmelCase_ : int = -1
for j in range(len(snake_case__)):
if chart[j][i] == 1:
count += 1
lowerCAmelCase_ : Optional[int] = j
if count == 1:
lowerCAmelCase_ : Union[str, Any] = 1
for i in range(len(snake_case__)):
if select[i] == 1:
for j in range(len(chart[0])):
if chart[i][j] == 1:
for k in range(len(snake_case__)):
lowerCAmelCase_ : Tuple = 0
temp.append(prime_implicants[i])
while True:
lowerCAmelCase_ : Optional[Any] = 0
lowerCAmelCase_ : Dict = -1
lowerCAmelCase_ : Tuple = 0
for i in range(len(snake_case__)):
lowerCAmelCase_ : Dict = chart[i].count(1)
if count_n > max_n:
lowerCAmelCase_ : Optional[int] = count_n
lowerCAmelCase_ : Optional[Any] = i
if max_n == 0:
return temp
temp.append(prime_implicants[rem])
for i in range(len(chart[0])):
if chart[rem][i] == 1:
for j in range(len(snake_case__)):
lowerCAmelCase_ : Any = 0
def UpperCamelCase ( snake_case__ , snake_case__):
lowerCAmelCase_ : str = [[0 for x in range(len(snake_case__))] for x in range(len(snake_case__))]
for i in range(len(snake_case__)):
lowerCAmelCase_ : Optional[Any] = prime_implicants[i].count("_")
for j in range(len(snake_case__)):
if is_for_table(prime_implicants[i] , binary[j] , snake_case__):
lowerCAmelCase_ : Dict = 1
return chart
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = int(input("Enter the no. of variables\n"))
lowerCAmelCase_ : Tuple = [
float(snake_case__)
for x in input(
"Enter the decimal representation of Minterms 'Spaces Separated'\n").split()
]
lowerCAmelCase_ : Any = decimal_to_binary(snake_case__ , snake_case__)
lowerCAmelCase_ : Dict = check(snake_case__)
print("Prime Implicants are:")
print(snake_case__)
lowerCAmelCase_ : int = prime_implicant_chart(snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = selection(snake_case__ , snake_case__)
print("Essential Prime Implicants are:")
print(snake_case__)
if __name__ == "__main__":
import doctest
doctest.testmod()
main()
| 683 | 0 |
import copy
from typing import Dict, Optional
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING
from ..detr import DetrConfig
from ..swin import SwinConfig
_lowercase = {
'''facebook/maskformer-swin-base-ade''': (
'''https://huggingface.co/facebook/maskformer-swin-base-ade/blob/main/config.json'''
)
# See all MaskFormer models at https://huggingface.co/models?filter=maskformer
}
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = 'maskformer'
UpperCamelCase_ = {'hidden_size': 'mask_feature_size'}
UpperCamelCase_ = ['resnet', 'swin']
UpperCamelCase_ = ['detr']
def __init__( self : Dict ,lowerCAmelCase__ : int = 2_56 ,lowerCAmelCase__ : int = 2_56 ,lowerCAmelCase__ : float = 0.1 ,lowerCAmelCase__ : bool = False ,lowerCAmelCase__ : Optional[Dict] = None ,lowerCAmelCase__ : Optional[Dict] = None ,lowerCAmelCase__ : float = 0.02 ,lowerCAmelCase__ : float = 1.0 ,lowerCAmelCase__ : float = 1.0 ,lowerCAmelCase__ : float = 1.0 ,lowerCAmelCase__ : float = 20.0 ,lowerCAmelCase__ : Optional[bool] = None ,**lowerCAmelCase__ : Union[str, Any] ,) -> str:
'''simple docstring'''
if backbone_config is None:
# fall back to https://huggingface.co/microsoft/swin-base-patch4-window12-384-in22k
lowerCAmelCase_ : int = SwinConfig(
image_size=3_84 ,in_channels=3 ,patch_size=4 ,embed_dim=1_28 ,depths=[2, 2, 18, 2] ,num_heads=[4, 8, 16, 32] ,window_size=12 ,drop_path_rate=0.3 ,out_features=["stage1", "stage2", "stage3", "stage4"] ,)
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : List[Any] = backbone_config.pop("model_type" )
lowerCAmelCase_ : List[Any] = CONFIG_MAPPING[backbone_model_type]
lowerCAmelCase_ : int = config_class.from_dict(lowerCAmelCase__ )
# verify that the backbone is supported
if backbone_config.model_type not in self.backbones_supported:
logger.warning_once(
f'''Backbone {backbone_config.model_type} is not a supported model and may not be compatible with MaskFormer. '''
f'''Supported model types: {",".join(self.backbones_supported )}''' )
if decoder_config is None:
# fall back to https://huggingface.co/facebook/detr-resnet-50
lowerCAmelCase_ : List[str] = DetrConfig()
else:
# verify that the decoder is supported
lowerCAmelCase_ : Tuple = (
decoder_config.pop("model_type" ) if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ) else decoder_config.model_type
)
if decoder_type not in self.decoders_supported:
raise ValueError(
f'''Transformer Decoder {decoder_type} not supported, please use one of'''
f''' {",".join(self.decoders_supported )}''' )
if isinstance(lowerCAmelCase__ ,lowerCAmelCase__ ):
lowerCAmelCase_ : Optional[Any] = CONFIG_MAPPING[decoder_type]
lowerCAmelCase_ : List[Any] = config_class.from_dict(lowerCAmelCase__ )
lowerCAmelCase_ : List[Any] = backbone_config
lowerCAmelCase_ : str = decoder_config
# main feature dimension for the model
lowerCAmelCase_ : Tuple = fpn_feature_size
lowerCAmelCase_ : List[Any] = mask_feature_size
# initializer
lowerCAmelCase_ : Optional[int] = init_std
lowerCAmelCase_ : Optional[Any] = init_xavier_std
# Hungarian matcher && loss
lowerCAmelCase_ : Optional[int] = cross_entropy_weight
lowerCAmelCase_ : Tuple = dice_weight
lowerCAmelCase_ : str = mask_weight
lowerCAmelCase_ : List[str] = use_auxiliary_loss
lowerCAmelCase_ : Optional[int] = no_object_weight
lowerCAmelCase_ : Tuple = output_auxiliary_logits
lowerCAmelCase_ : Union[str, Any] = self.decoder_config.encoder_attention_heads
lowerCAmelCase_ : List[Any] = self.decoder_config.num_hidden_layers
super().__init__(**lowerCAmelCase__ )
@classmethod
def UpperCAmelCase_ ( cls : Optional[int] ,lowerCAmelCase__ : PretrainedConfig ,lowerCAmelCase__ : PretrainedConfig ,**lowerCAmelCase__ : Optional[Any] ) -> Optional[int]:
'''simple docstring'''
return cls(
backbone_config=lowerCAmelCase__ ,decoder_config=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
def UpperCAmelCase_ ( self : Tuple ) -> Dict[str, any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = copy.deepcopy(self.__dict__ )
lowerCAmelCase_ : Any = self.backbone_config.to_dict()
lowerCAmelCase_ : Any = self.decoder_config.to_dict()
lowerCAmelCase_ : str = self.__class__.model_type
return output
| 718 |
import logging
import os
from typing import Dict, List, Optional, Union
import torch
import torch.nn as nn
from accelerate.utils.imports import (
is_abit_bnb_available,
is_abit_bnb_available,
is_bnb_available,
)
from ..big_modeling import dispatch_model, init_empty_weights
from .dataclasses import BnbQuantizationConfig
from .modeling import (
find_tied_parameters,
get_balanced_memory,
infer_auto_device_map,
load_checkpoint_in_model,
offload_weight,
set_module_tensor_to_device,
)
if is_bnb_available():
import bitsandbytes as bnb
from copy import deepcopy
_lowercase = logging.getLogger(__name__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = None , snake_case__ = False , ):
lowerCAmelCase_ : List[Any] = bnb_quantization_config.load_in_abit
lowerCAmelCase_ : Optional[Any] = bnb_quantization_config.load_in_abit
if load_in_abit and not is_abit_bnb_available():
raise ImportError(
"You have a version of `bitsandbytes` that is not compatible with 8bit quantization,"
" make sure you have the latest version of `bitsandbytes` installed.")
if load_in_abit and not is_abit_bnb_available():
raise ValueError(
"You have a version of `bitsandbytes` that is not compatible with 4bit quantization,"
"make sure you have the latest version of `bitsandbytes` installed.")
lowerCAmelCase_ : List[str] = []
# custom device map
if isinstance(snake_case__ , snake_case__) and len(device_map.keys()) > 1:
lowerCAmelCase_ : Union[str, Any] = [key for key, value in device_map.items() if value in ["disk", "cpu"]]
# We keep some modules such as the lm_head in their original dtype for numerical stability reasons
if bnb_quantization_config.skip_modules is None:
lowerCAmelCase_ : Union[str, Any] = get_keys_to_not_convert(snake_case__)
# add cpu modules to skip modules only for 4-bit modules
if load_in_abit:
bnb_quantization_config.skip_modules.extend(snake_case__)
lowerCAmelCase_ : Union[str, Any] = bnb_quantization_config.skip_modules
# We add the modules we want to keep in full precision
if bnb_quantization_config.keep_in_fpaa_modules is None:
lowerCAmelCase_ : Optional[int] = []
lowerCAmelCase_ : int = bnb_quantization_config.keep_in_fpaa_modules
modules_to_not_convert.extend(snake_case__)
# compatibility with peft
lowerCAmelCase_ : Optional[int] = load_in_abit
lowerCAmelCase_ : List[str] = load_in_abit
lowerCAmelCase_ : Optional[int] = get_parameter_device(snake_case__)
if model_device.type != "meta":
# quantization of an already loaded model
logger.warning(
"It is not recommended to quantize a loaded model. "
"The model should be instantiated under the `init_empty_weights` context manager.")
lowerCAmelCase_ : Union[str, Any] = replace_with_bnb_layers(snake_case__ , snake_case__ , modules_to_not_convert=snake_case__)
# convert param to the right dtype
lowerCAmelCase_ : Any = bnb_quantization_config.torch_dtype
for name, param in model.state_dict().items():
if any(module_to_keep_in_fpaa in name for module_to_keep_in_fpaa in keep_in_fpaa_modules):
param.to(torch.floataa)
if param.dtype != torch.floataa:
lowerCAmelCase_ : Optional[int] = name.replace(".weight" , "").replace(".bias" , "")
lowerCAmelCase_ : Optional[int] = getattr(snake_case__ , snake_case__ , snake_case__)
if param is not None:
param.to(torch.floataa)
elif torch.is_floating_point(snake_case__):
param.to(snake_case__)
if model_device.type == "cuda":
# move everything to cpu in the first place because we can't do quantization if the weights are already on cuda
model.cuda(torch.cuda.current_device())
torch.cuda.empty_cache()
elif torch.cuda.is_available():
model.to(torch.cuda.current_device())
else:
raise RuntimeError("No GPU found. A GPU is needed for quantization.")
logger.info(
F'''The model device type is {model_device.type}. However, cuda is needed for quantization.'''
"We move the model to cuda.")
return model
elif weights_location is None:
raise RuntimeError(
F'''`weights_location` needs to be the folder path containing the weights of the model, but we found {weights_location} ''')
else:
with init_empty_weights():
lowerCAmelCase_ : str = replace_with_bnb_layers(
snake_case__ , snake_case__ , modules_to_not_convert=snake_case__)
lowerCAmelCase_ : Optional[int] = get_quantized_model_device_map(
snake_case__ , snake_case__ , snake_case__ , max_memory=snake_case__ , no_split_module_classes=snake_case__ , )
if offload_state_dict is None and device_map is not None and "disk" in device_map.values():
lowerCAmelCase_ : Optional[Any] = True
lowerCAmelCase_ : Optional[int] = any(x in list(device_map.values()) for x in ["cpu", "disk"])
load_checkpoint_in_model(
snake_case__ , snake_case__ , snake_case__ , dtype=bnb_quantization_config.torch_dtype , offload_folder=snake_case__ , offload_state_dict=snake_case__ , keep_in_fpaa_modules=bnb_quantization_config.keep_in_fpaa_modules , offload_abit_bnb=load_in_abit and offload , )
return dispatch_model(snake_case__ , device_map=snake_case__ , offload_dir=snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None , snake_case__=None):
if device_map is None:
if torch.cuda.is_available():
lowerCAmelCase_ : Any = {"": torch.cuda.current_device()}
else:
raise RuntimeError("No GPU found. A GPU is needed for quantization.")
logger.info("The device_map was not initialized." "Setting device_map to `{'':torch.cuda.current_device()}`.")
if isinstance(snake_case__ , snake_case__):
if device_map not in ["auto", "balanced", "balanced_low_0", "sequential"]:
raise ValueError(
"If passing a string for `device_map`, please choose 'auto', 'balanced', 'balanced_low_0' or "
"'sequential'.")
lowerCAmelCase_ : Dict = {}
special_dtypes.update(
{
name: bnb_quantization_config.torch_dtype
for name, _ in model.named_parameters()
if any(m in name for m in bnb_quantization_config.skip_modules)
})
special_dtypes.update(
{
name: torch.floataa
for name, _ in model.named_parameters()
if any(m in name for m in bnb_quantization_config.keep_in_fpaa_modules)
})
lowerCAmelCase_ : List[str] = {}
lowerCAmelCase_ : Union[str, Any] = special_dtypes
lowerCAmelCase_ : Union[str, Any] = no_split_module_classes
lowerCAmelCase_ : Any = bnb_quantization_config.target_dtype
# get max_memory for each device.
if device_map != "sequential":
lowerCAmelCase_ : Tuple = get_balanced_memory(
snake_case__ , low_zero=(device_map == "balanced_low_0") , max_memory=snake_case__ , **snake_case__ , )
lowerCAmelCase_ : Tuple = max_memory
lowerCAmelCase_ : Optional[Any] = infer_auto_device_map(snake_case__ , **snake_case__)
if isinstance(snake_case__ , snake_case__):
# check if don't have any quantized module on the cpu
lowerCAmelCase_ : Union[str, Any] = bnb_quantization_config.skip_modules + bnb_quantization_config.keep_in_fpaa_modules
lowerCAmelCase_ : List[Any] = {
key: device_map[key] for key in device_map.keys() if key not in modules_not_to_convert
}
for device in ["cpu", "disk"]:
if device in device_map_without_some_modules.values():
if bnb_quantization_config.load_in_abit:
raise ValueError(
"\n Some modules are dispatched on the CPU or the disk. Make sure you have enough GPU RAM to fit\n the quantized model. If you want to dispatch the model on the CPU or the disk while keeping\n these modules in `torch_dtype`, you need to pass a custom `device_map` to\n `load_and_quantize_model`. Check\n https://huggingface.co/docs/accelerate/main/en/usage_guides/quantization#offload-modules-to-cpu-and-disk\n for more details.\n ")
else:
logger.info(
"Some modules are are offloaded to the CPU or the disk. Note that these modules will be converted to 8-bit")
del device_map_without_some_modules
return device_map
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None):
if modules_to_not_convert is None:
lowerCAmelCase_ : List[str] = []
lowerCAmelCase_ , lowerCAmelCase_ : Tuple = _replace_with_bnb_layers(
snake_case__ , snake_case__ , snake_case__ , snake_case__)
if not has_been_replaced:
logger.warning(
"You are loading your model in 8bit or 4bit but no linear modules were found in your model."
" this can happen for some architectures such as gpt2 that uses Conv1D instead of Linear layers."
" Please double check your model architecture, or submit an issue on github if you think this is"
" a bug.")
return model
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__=None , snake_case__=None , ):
lowerCAmelCase_ : str = False
for name, module in model.named_children():
if current_key_name is None:
lowerCAmelCase_ : Optional[int] = []
current_key_name.append(snake_case__)
if isinstance(snake_case__ , nn.Linear) and name not in modules_to_not_convert:
# Check if the current key is not in the `modules_to_not_convert`
lowerCAmelCase_ : Optional[int] = ".".join(snake_case__)
lowerCAmelCase_ : List[str] = True
for key in modules_to_not_convert:
if (
(key in current_key_name_str) and (key + "." in current_key_name_str)
) or key == current_key_name_str:
lowerCAmelCase_ : List[Any] = False
break
if proceed:
# Load bnb module with empty weight and replace ``nn.Linear` module
if bnb_quantization_config.load_in_abit:
lowerCAmelCase_ : Tuple = bnb.nn.LinearabitLt(
module.in_features , module.out_features , module.bias is not None , has_fpaa_weights=snake_case__ , threshold=bnb_quantization_config.llm_inta_threshold , )
elif bnb_quantization_config.load_in_abit:
lowerCAmelCase_ : Dict = bnb.nn.Linearabit(
module.in_features , module.out_features , module.bias is not None , bnb_quantization_config.bnb_abit_compute_dtype , compress_statistics=bnb_quantization_config.bnb_abit_use_double_quant , quant_type=bnb_quantization_config.bnb_abit_quant_type , )
else:
raise ValueError("load_in_8bit and load_in_4bit can't be both False")
lowerCAmelCase_ : List[str] = module.weight.data
if module.bias is not None:
lowerCAmelCase_ : Any = module.bias.data
bnb_module.requires_grad_(snake_case__)
setattr(snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : List[str] = True
if len(list(module.children())) > 0:
lowerCAmelCase_ , lowerCAmelCase_ : List[Any] = _replace_with_bnb_layers(
snake_case__ , snake_case__ , snake_case__ , snake_case__)
lowerCAmelCase_ : Optional[int] = has_been_replaced | _has_been_replaced
# Remove the last key for recursion
current_key_name.pop(-1)
return model, has_been_replaced
def UpperCamelCase ( snake_case__):
# Create a copy of the model
with init_empty_weights():
lowerCAmelCase_ : List[Any] = deepcopy(snake_case__) # this has 0 cost since it is done inside `init_empty_weights` context manager`
lowerCAmelCase_ : Dict = find_tied_parameters(snake_case__)
# For compatibility with Accelerate < 0.18
if isinstance(snake_case__ , snake_case__):
lowerCAmelCase_ : List[str] = sum(list(tied_params.values()) , []) + list(tied_params.keys())
else:
lowerCAmelCase_ : Optional[Any] = sum(snake_case__ , [])
lowerCAmelCase_ : List[Any] = len(snake_case__) > 0
# Check if it is a base model
lowerCAmelCase_ : List[str] = False
if hasattr(snake_case__ , "base_model_prefix"):
lowerCAmelCase_ : Tuple = not hasattr(snake_case__ , model.base_model_prefix)
# Ignore this for base models (BertModel, GPT2Model, etc.)
if (not has_tied_params) and is_base_model:
return []
# otherwise they have an attached head
lowerCAmelCase_ : Union[str, Any] = list(model.named_children())
lowerCAmelCase_ : Optional[int] = [list_modules[-1][0]]
# add last module together with tied weights
lowerCAmelCase_ : Any = set(snake_case__) - set(snake_case__)
lowerCAmelCase_ : Tuple = list(set(snake_case__)) + list(snake_case__)
# remove ".weight" from the keys
lowerCAmelCase_ : List[str] = [".weight", ".bias"]
lowerCAmelCase_ : Tuple = []
for name in list_untouched:
for name_to_remove in names_to_remove:
if name_to_remove in name:
lowerCAmelCase_ : str = name.replace(snake_case__ , "")
filtered_module_names.append(snake_case__)
return filtered_module_names
def UpperCamelCase ( snake_case__):
for m in model.modules():
if isinstance(snake_case__ , bnb.nn.Linearabit):
return True
return False
def UpperCamelCase ( snake_case__):
return next(parameter.parameters()).device
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
# if it is not quantized, we quantize and offload the quantized weights and the SCB stats
if fpaa_statistics is None:
set_module_tensor_to_device(snake_case__ , snake_case__ , 0 , dtype=snake_case__ , value=snake_case__)
lowerCAmelCase_ : str = param_name
lowerCAmelCase_ : Tuple = model
if "." in tensor_name:
lowerCAmelCase_ : Dict = tensor_name.split(".")
for split in splits[:-1]:
lowerCAmelCase_ : Any = getattr(snake_case__ , snake_case__)
if new_module is None:
raise ValueError(F'''{module} has no attribute {split}.''')
lowerCAmelCase_ : Union[str, Any] = new_module
lowerCAmelCase_ : Any = splits[-1]
# offload weights
lowerCAmelCase_ : List[Any] = False
offload_weight(module._parameters[tensor_name] , snake_case__ , snake_case__ , index=snake_case__)
if hasattr(module._parameters[tensor_name] , "SCB"):
offload_weight(
module._parameters[tensor_name].SCB , param_name.replace("weight" , "SCB") , snake_case__ , index=snake_case__ , )
else:
offload_weight(snake_case__ , snake_case__ , snake_case__ , index=snake_case__)
offload_weight(snake_case__ , param_name.replace("weight" , "SCB") , snake_case__ , index=snake_case__)
set_module_tensor_to_device(snake_case__ , snake_case__ , "meta" , dtype=snake_case__ , value=torch.empty(*param.size()))
| 683 | 0 |
import datasets
from .nmt_bleu import compute_bleu # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py
_lowercase = '''\
@INPROCEEDINGS{Papineni02bleu:a,
author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},
title = {BLEU: a Method for Automatic Evaluation of Machine Translation},
booktitle = {},
year = {2002},
pages = {311--318}
}
@inproceedings{lin-och-2004-orange,
title = "{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation",
author = "Lin, Chin-Yew and
Och, Franz Josef",
booktitle = "{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics",
month = "aug 23{--}aug 27",
year = "2004",
address = "Geneva, Switzerland",
publisher = "COLING",
url = "https://www.aclweb.org/anthology/C04-1072",
pages = "501--507",
}
'''
_lowercase = '''\
BLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.
Quality is considered to be the correspondence between a machine\'s output and that of a human: "the closer a machine translation is to a professional human translation,
the better it is" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and
remains one of the most popular automated and inexpensive metrics.
Scores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.
Those scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness
are not taken into account[citation needed].
BLEU\'s output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1
representing more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the
reference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional
reference translations will increase the BLEU score.
'''
_lowercase = '''
Computes BLEU score of translated segments against one or more references.
Args:
predictions: list of translations to score.
Each translation should be tokenized into a list of tokens.
references: list of lists of references for each translation.
Each reference should be tokenized into a list of tokens.
max_order: Maximum n-gram order to use when computing BLEU score.
smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
\'bleu\': bleu score,
\'precisions\': geometric mean of n-gram precisions,
\'brevity_penalty\': brevity penalty,
\'length_ratio\': ratio of lengths,
\'translation_length\': translation_length,
\'reference_length\': reference_length
Examples:
>>> predictions = [
... ["hello", "there", "general", "kenobi"], # tokenized prediction of the first sample
... ["foo", "bar", "foobar"] # tokenized prediction of the second sample
... ]
>>> references = [
... [["hello", "there", "general", "kenobi"], ["hello", "there", "!"]], # tokenized references for the first sample (2 references)
... [["foo", "bar", "foobar"]] # tokenized references for the second sample (1 reference)
... ]
>>> bleu = datasets.load_metric("bleu")
>>> results = bleu.compute(predictions=predictions, references=references)
>>> print(results["bleu"])
1.0
'''
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __snake_case ( datasets.Metric ):
"""simple docstring"""
def UpperCAmelCase_ ( self : Union[str, Any] ) -> int:
'''simple docstring'''
return datasets.MetricInfo(
description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features(
{
"predictions": datasets.Sequence(datasets.Value("string" ,id="token" ) ,id="sequence" ),
"references": datasets.Sequence(
datasets.Sequence(datasets.Value("string" ,id="token" ) ,id="sequence" ) ,id="references" ),
} ) ,codebase_urls=["https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py"] ,reference_urls=[
"https://en.wikipedia.org/wiki/BLEU",
"https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
] ,)
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : List[Any] ,lowerCAmelCase__ : Optional[Any] ,lowerCAmelCase__ : List[str]=4 ,lowerCAmelCase__ : List[str]=False ) -> List[Any]:
'''simple docstring'''
lowerCAmelCase_ : Optional[int] = compute_bleu(
reference_corpus=lowerCAmelCase__ ,translation_corpus=lowerCAmelCase__ ,max_order=lowerCAmelCase__ ,smooth=lowerCAmelCase__ )
(lowerCAmelCase_) : Union[str, Any] = score
return {
"bleu": bleu,
"precisions": precisions,
"brevity_penalty": bp,
"length_ratio": ratio,
"translation_length": translation_length,
"reference_length": reference_length,
}
| 719 |
import copy
from typing import Any, Dict, List, Optional, Union
import numpy as np
import torch
from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging
_lowercase = logging.get_logger(__name__)
class __snake_case ( snake_case__ ):
"""simple docstring"""
UpperCamelCase_ = ['input_features', 'is_longer']
def __init__( self : Optional[int] ,lowerCAmelCase__ : List[Any]=64 ,lowerCAmelCase__ : Any=4_80_00 ,lowerCAmelCase__ : Optional[Any]=4_80 ,lowerCAmelCase__ : List[str]=10 ,lowerCAmelCase__ : List[Any]=10_24 ,lowerCAmelCase__ : Union[str, Any]=0.0 ,lowerCAmelCase__ : Tuple=False ,lowerCAmelCase__ : float = 0 ,lowerCAmelCase__ : float = 1_40_00 ,lowerCAmelCase__ : int = None ,lowerCAmelCase__ : str = "fusion" ,lowerCAmelCase__ : str = "repeatpad" ,**lowerCAmelCase__ : Union[str, Any] ,) -> Union[str, Any]:
'''simple docstring'''
super().__init__(
feature_size=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,padding_value=lowerCAmelCase__ ,return_attention_mask=lowerCAmelCase__ ,**lowerCAmelCase__ ,)
lowerCAmelCase_ : Optional[Any] = top_db
lowerCAmelCase_ : str = truncation
lowerCAmelCase_ : Tuple = padding
lowerCAmelCase_ : str = fft_window_size
lowerCAmelCase_ : Dict = (fft_window_size >> 1) + 1
lowerCAmelCase_ : Dict = hop_length
lowerCAmelCase_ : Any = max_length_s
lowerCAmelCase_ : int = max_length_s * sampling_rate
lowerCAmelCase_ : Optional[int] = sampling_rate
lowerCAmelCase_ : int = frequency_min
lowerCAmelCase_ : Optional[Any] = frequency_max
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm=lowerCAmelCase__ ,mel_scale="htk" ,)
lowerCAmelCase_ : List[Any] = mel_filter_bank(
num_frequency_bins=self.nb_frequency_bins ,num_mel_filters=lowerCAmelCase__ ,min_frequency=lowerCAmelCase__ ,max_frequency=lowerCAmelCase__ ,sampling_rate=lowerCAmelCase__ ,norm="slaney" ,mel_scale="slaney" ,)
def UpperCAmelCase_ ( self : Dict ) -> Dict[str, Any]:
'''simple docstring'''
lowerCAmelCase_ : int = copy.deepcopy(self.__dict__ )
lowerCAmelCase_ : Optional[int] = self.__class__.__name__
if "mel_filters" in output:
del output["mel_filters"]
if "mel_filters_slaney" in output:
del output["mel_filters_slaney"]
return output
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Optional[np.array] = None ) -> np.ndarray:
'''simple docstring'''
lowerCAmelCase_ : Optional[Any] = spectrogram(
lowerCAmelCase__ ,window_function(self.fft_window_size ,"hann" ) ,frame_length=self.fft_window_size ,hop_length=self.hop_length ,power=2.0 ,mel_filters=lowerCAmelCase__ ,log_mel="dB" ,)
return log_mel_spectrogram.T
def UpperCAmelCase_ ( self : Optional[int] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Tuple ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Tuple = np.array_split(list(range(0 ,total_frames - chunk_frames + 1 ) ) ,3 )
if len(ranges[1] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
if len(ranges[2] ) == 0:
# if the audio is too short, we just use the first chunk
lowerCAmelCase_ : List[Any] = [0]
# randomly choose index for each part
lowerCAmelCase_ : str = np.random.choice(ranges[0] )
lowerCAmelCase_ : Optional[Any] = np.random.choice(ranges[1] )
lowerCAmelCase_ : Any = np.random.choice(ranges[2] )
lowerCAmelCase_ : str = mel[idx_front : idx_front + chunk_frames, :]
lowerCAmelCase_ : Dict = mel[idx_middle : idx_middle + chunk_frames, :]
lowerCAmelCase_ : Optional[Any] = mel[idx_back : idx_back + chunk_frames, :]
lowerCAmelCase_ : List[str] = torch.tensor(mel[None, None, :] )
lowerCAmelCase_ : List[Any] = torch.nn.functional.interpolate(
lowerCAmelCase__ ,size=[chunk_frames, 64] ,mode="bilinear" ,align_corners=lowerCAmelCase__ )
lowerCAmelCase_ : Optional[int] = mel_shrink[0][0].numpy()
lowerCAmelCase_ : str = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,axis=0 )
return mel_fusion
def UpperCAmelCase_ ( self : Any ,lowerCAmelCase__ : np.array ,lowerCAmelCase__ : Union[str, Any] ,lowerCAmelCase__ : Optional[int] ,lowerCAmelCase__ : int ) -> np.array:
'''simple docstring'''
if waveform.shape[0] > max_length:
if truncation == "rand_trunc":
lowerCAmelCase_ : List[Any] = True
# random crop to max_length (for compatibility) -> this should be handled by self.pad
lowerCAmelCase_ : str = len(lowerCAmelCase__ ) - max_length
lowerCAmelCase_ : Any = np.random.randint(0 ,overflow + 1 )
lowerCAmelCase_ : Dict = waveform[idx : idx + max_length]
lowerCAmelCase_ : List[str] = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
elif truncation == "fusion":
lowerCAmelCase_ : Tuple = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : str = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed
lowerCAmelCase_ : List[str] = mel.shape[0]
if chunk_frames == total_frames:
# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
# In this case, we just use the whole audio.
lowerCAmelCase_ : Dict = np.stack([mel, mel, mel, mel] ,axis=0 )
lowerCAmelCase_ : int = False
else:
lowerCAmelCase_ : str = self._random_mel_fusion(lowerCAmelCase__ ,lowerCAmelCase__ ,lowerCAmelCase__ )
lowerCAmelCase_ : Any = True
else:
raise NotImplementedError(f'''data_truncating {truncation} not implemented''' )
else:
lowerCAmelCase_ : Dict = False
# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
if waveform.shape[0] < max_length:
if padding == "repeat":
lowerCAmelCase_ : List[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : int = np.stack(np.tile(lowerCAmelCase__ ,n_repeat + 1 ) )[:max_length]
if padding == "repeatpad":
lowerCAmelCase_ : Optional[Any] = int(max_length / len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Tuple = np.stack(np.tile(lowerCAmelCase__ ,lowerCAmelCase__ ) )
lowerCAmelCase_ : List[Any] = np.pad(lowerCAmelCase__ ,(0, max_length - waveform.shape[0]) ,mode="constant" ,constant_values=0 )
if truncation == "fusion":
lowerCAmelCase_ : int = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters )
lowerCAmelCase_ : Tuple = np.stack([input_mel, input_mel, input_mel, input_mel] ,axis=0 )
else:
lowerCAmelCase_ : str = self._np_extract_fbank_features(lowerCAmelCase__ ,self.mel_filters_slaney )[None, :]
return input_mel, longer
def __call__( self : int ,lowerCAmelCase__ : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,lowerCAmelCase__ : str = None ,lowerCAmelCase__ : Optional[str] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[int] = None ,lowerCAmelCase__ : Optional[Union[str, TensorType]] = None ,**lowerCAmelCase__ : List[Any] ,) -> BatchFeature:
'''simple docstring'''
lowerCAmelCase_ : List[str] = truncation if truncation is not None else self.truncation
lowerCAmelCase_ : List[Any] = padding if padding else self.padding
if sampling_rate is not None:
if sampling_rate != self.sampling_rate:
raise ValueError(
f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
f''' was sampled with {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." )
lowerCAmelCase_ : Dict = 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}''' )
lowerCAmelCase_ : Dict = is_batched_numpy or (
isinstance(lowerCAmelCase__ ,(list, tuple) ) and (isinstance(raw_speech[0] ,(np.ndarray, tuple, list) ))
)
if is_batched:
lowerCAmelCase_ : List[str] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for speech in raw_speech]
elif not is_batched and not isinstance(lowerCAmelCase__ ,np.ndarray ):
lowerCAmelCase_ : Tuple = np.asarray(lowerCAmelCase__ ,dtype=np.floataa )
elif isinstance(lowerCAmelCase__ ,np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ):
lowerCAmelCase_ : Any = raw_speech.astype(np.floataa )
# always return batch
if not is_batched:
lowerCAmelCase_ : Any = [np.asarray(lowerCAmelCase__ )]
# convert to mel spectrogram, truncate and pad if needed.
lowerCAmelCase_ : Optional[Any] = [
self._get_input_mel(lowerCAmelCase__ ,max_length if max_length else self.nb_max_samples ,lowerCAmelCase__ ,lowerCAmelCase__ )
for waveform in raw_speech
]
lowerCAmelCase_ : str = []
lowerCAmelCase_ : str = []
for mel, longer in padded_inputs:
input_mel.append(lowerCAmelCase__ )
is_longer.append(lowerCAmelCase__ )
if truncation == "fusion" and sum(lowerCAmelCase__ ) == 0:
# if no audio is longer than 10s, then randomly select one audio to be longer
lowerCAmelCase_ : Any = np.random.randint(0 ,len(lowerCAmelCase__ ) )
lowerCAmelCase_ : Dict = True
if isinstance(input_mel[0] ,lowerCAmelCase__ ):
lowerCAmelCase_ : Optional[int] = [np.asarray(lowerCAmelCase__ ,dtype=np.floataa ) for feature in input_mel]
# is_longer is a list of bool
lowerCAmelCase_ : List[Any] = [[longer] for longer in is_longer]
lowerCAmelCase_ : Optional[Any] = {"input_features": input_mel, "is_longer": is_longer}
lowerCAmelCase_ : Dict = BatchFeature(lowerCAmelCase__ )
if return_tensors is not None:
lowerCAmelCase_ : List[str] = input_features.convert_to_tensors(lowerCAmelCase__ )
return input_features
| 683 | 0 |
import argparse
from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging
logging.set_verbosity_info()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__):
# Initialise PyTorch model
lowerCAmelCase_ : Optional[Any] = BigBirdConfig.from_json_file(snake_case__)
print(F'''Building PyTorch model from configuration: {config}''')
if is_trivia_qa:
lowerCAmelCase_ : List[str] = BigBirdForQuestionAnswering(snake_case__)
else:
lowerCAmelCase_ : str = BigBirdForPreTraining(snake_case__)
# Load weights from tf checkpoint
load_tf_weights_in_big_bird(snake_case__ , snake_case__ , is_trivia_qa=snake_case__)
# Save pytorch-model
print(F'''Save PyTorch model to {pytorch_dump_path}''')
model.save_pretrained(snake_case__)
if __name__ == "__main__":
_lowercase : Tuple = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
)
parser.add_argument(
'''--big_bird_config_file''',
default=None,
type=str,
required=True,
help=(
'''The config json file corresponding to the pre-trained BERT model. \n'''
'''This specifies the model architecture.'''
),
)
parser.add_argument(
'''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
)
parser.add_argument(
'''--is_trivia_qa''', action='''store_true''', help='''Whether to convert a model with a trivia_qa head.'''
)
_lowercase : Any = parser.parse_args()
convert_tf_checkpoint_to_pytorch(
args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
)
| 720 |
from multiprocessing import Lock, Pipe, Process
# lock used to ensure that two processes do not access a pipe at the same time
_lowercase = Lock()
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__):
global process_lock
# we perform n swaps since after n swaps we know we are sorted
# we *could* stop early if we are sorted already, but it takes as long to
# find out we are sorted as it does to sort the list with this algorithm
for i in range(0 , 10):
if (i + position) % 2 == 0 and r_send is not None:
# send your value to your right neighbor
process_lock.acquire()
r_send[1].send(snake_case__)
process_lock.release()
# receive your right neighbor's value
process_lock.acquire()
lowerCAmelCase_ : Optional[Any] = rr_cv[0].recv()
process_lock.release()
# take the lower value since you are on the left
lowerCAmelCase_ : Any = min(snake_case__ , snake_case__)
elif (i + position) % 2 != 0 and l_send is not None:
# send your value to your left neighbor
process_lock.acquire()
l_send[1].send(snake_case__)
process_lock.release()
# receive your left neighbor's value
process_lock.acquire()
lowerCAmelCase_ : str = lr_cv[0].recv()
process_lock.release()
# take the higher value since you are on the right
lowerCAmelCase_ : Dict = max(snake_case__ , snake_case__)
# after all swaps are performed, send the values back to main
result_pipe[1].send(snake_case__)
def UpperCamelCase ( snake_case__):
lowerCAmelCase_ : Union[str, Any] = []
lowerCAmelCase_ : int = []
# initialize the list of pipes where the values will be retrieved
for _ in arr:
result_pipe.append(Pipe())
# creates the processes
# the first and last process only have one neighbor so they are made outside
# of the loop
lowerCAmelCase_ : Tuple = Pipe()
lowerCAmelCase_ : Optional[int] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) , ))
lowerCAmelCase_ : int = temp_rs
lowerCAmelCase_ : List[Any] = temp_rr
for i in range(1 , len(snake_case__) - 1):
lowerCAmelCase_ : Dict = Pipe()
lowerCAmelCase_ : List[str] = Pipe()
process_array_.append(
Process(
target=snake_case__ , args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]) , ))
lowerCAmelCase_ : Dict = temp_rs
lowerCAmelCase_ : Optional[Any] = temp_rr
process_array_.append(
Process(
target=snake_case__ , args=(
len(snake_case__) - 1,
arr[len(snake_case__) - 1],
temp_ls,
None,
temp_lr,
None,
result_pipe[len(snake_case__) - 1],
) , ))
# start the processes
for p in process_array_:
p.start()
# wait for the processes to end and write their values to the list
for p in range(0 , len(snake_case__)):
lowerCAmelCase_ : Union[str, Any] = result_pipe[p][0].recv()
process_array_[p].join()
return arr
def UpperCamelCase ( ):
lowerCAmelCase_ : Optional[Any] = list(range(10 , 0 , -1))
print("Initial List")
print(*snake_case__)
lowerCAmelCase_ : Tuple = odd_even_transposition(snake_case__)
print("Sorted List\n")
print(*snake_case__)
if __name__ == "__main__":
main()
| 683 | 0 |
import unittest
from datasets import load_dataset
from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow
@is_pipeline_test
@require_torch
class __snake_case ( unittest.TestCase ):
"""simple docstring"""
@require_torch
def UpperCAmelCase_ ( self : Tuple ) -> Tuple:
'''simple docstring'''
lowerCAmelCase_ : str = pipeline(
task="zero-shot-audio-classification" ,model="hf-internal-testing/tiny-clap-htsat-unfused" )
lowerCAmelCase_ : List[Any] = load_dataset("ashraq/esc50" )
lowerCAmelCase_ : Tuple = dataset["train"]["audio"][-1]["array"]
lowerCAmelCase_ : str = audio_classifier(lowerCAmelCase__ ,candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"] )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ) ,[{"score": 0.501, "label": "Sound of a dog"}, {"score": 0.499, "label": "Sound of vaccum cleaner"}] ,)
@unittest.skip("No models are available in TF" )
def UpperCAmelCase_ ( self : int ) -> List[str]:
'''simple docstring'''
pass
@slow
@require_torch
def UpperCAmelCase_ ( self : str ) -> Dict:
'''simple docstring'''
lowerCAmelCase_ : Any = pipeline(
task="zero-shot-audio-classification" ,model="laion/clap-htsat-unfused" ,)
# This is an audio of a dog
lowerCAmelCase_ : Optional[int] = load_dataset("ashraq/esc50" )
lowerCAmelCase_ : Optional[int] = dataset["train"]["audio"][-1]["array"]
lowerCAmelCase_ : int = audio_classifier(lowerCAmelCase__ ,candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"] )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ) ,[
{"score": 0.999, "label": "Sound of a dog"},
{"score": 0.001, "label": "Sound of vaccum cleaner"},
] ,)
lowerCAmelCase_ : str = audio_classifier([audio] * 5 ,candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"] )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ) ,[
[
{"score": 0.999, "label": "Sound of a dog"},
{"score": 0.001, "label": "Sound of vaccum cleaner"},
],
]
* 5 ,)
lowerCAmelCase_ : List[str] = audio_classifier(
[audio] * 5 ,candidate_labels=["Sound of a dog", "Sound of vaccum cleaner"] ,batch_size=5 )
self.assertEqual(
nested_simplify(lowerCAmelCase__ ) ,[
[
{"score": 0.999, "label": "Sound of a dog"},
{"score": 0.001, "label": "Sound of vaccum cleaner"},
],
]
* 5 ,)
@unittest.skip("No models are available in TF" )
def UpperCAmelCase_ ( self : Optional[int] ) -> Optional[Any]:
'''simple docstring'''
pass
| 721 |
from typing import Any
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validation(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
# Creates data structures and fill initial step
lowerCAmelCase_ : dict = {}
lowerCAmelCase_ : dict = {}
for state in states_space:
lowerCAmelCase_ : List[Any] = observations_space[0]
lowerCAmelCase_ : int = (
initial_probabilities[state] * emission_probabilities[state][observation]
)
lowerCAmelCase_ : Dict = None
# Fills the data structure with the probabilities of
# different transitions and pointers to previous states
for o in range(1 , len(snake_case__)):
lowerCAmelCase_ : List[Any] = observations_space[o]
lowerCAmelCase_ : Optional[Any] = observations_space[o - 1]
for state in states_space:
# Calculates the argmax for probability function
lowerCAmelCase_ : List[Any] = ""
lowerCAmelCase_ : Tuple = -1
for k_state in states_space:
lowerCAmelCase_ : int = (
probabilities[(k_state, prior_observation)]
* transition_probabilities[k_state][state]
* emission_probabilities[state][observation]
)
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Optional[Any] = k_state
# Update probabilities and pointers dicts
lowerCAmelCase_ : Union[str, Any] = (
probabilities[(arg_max, prior_observation)]
* transition_probabilities[arg_max][state]
* emission_probabilities[state][observation]
)
lowerCAmelCase_ : Any = arg_max
# The final observation
lowerCAmelCase_ : List[Any] = observations_space[len(snake_case__) - 1]
# argmax for given final observation
lowerCAmelCase_ : List[str] = ""
lowerCAmelCase_ : List[str] = -1
for k_state in states_space:
lowerCAmelCase_ : List[str] = probabilities[(k_state, final_observation)]
if probability > max_probability:
lowerCAmelCase_ : List[str] = probability
lowerCAmelCase_ : Tuple = k_state
lowerCAmelCase_ : str = arg_max
# Process pointers backwards
lowerCAmelCase_ : int = last_state
lowerCAmelCase_ : int = []
for o in range(len(snake_case__) - 1 , -1 , -1):
result.append(snake_case__)
lowerCAmelCase_ : Optional[Any] = pointers[previous, observations_space[o]]
result.reverse()
return result
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
_validate_not_empty(
snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , )
_validate_lists(snake_case__ , snake_case__)
_validate_dicts(
snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ , snake_case__ , ):
if not all(
[
observations_space,
states_space,
initial_probabilities,
transition_probabilities,
emission_probabilities,
]):
raise ValueError("There's an empty parameter")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_list(snake_case__ , "observations_space")
_validate_list(snake_case__ , "states_space")
def UpperCamelCase ( snake_case__ , snake_case__):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list'''
raise ValueError(snake_case__)
else:
for x in _object:
if not isinstance(snake_case__ , snake_case__):
lowerCAmelCase_ : Optional[Any] = F'''{var_name} must be a list of strings'''
raise ValueError(snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , ):
_validate_dict(snake_case__ , "initial_probabilities" , snake_case__)
_validate_nested_dict(snake_case__ , "transition_probabilities")
_validate_nested_dict(snake_case__ , "emission_probabilities")
def UpperCamelCase ( snake_case__ , snake_case__):
_validate_dict(_object , snake_case__ , snake_case__)
for x in _object.values():
_validate_dict(snake_case__ , snake_case__ , snake_case__ , snake_case__)
def UpperCamelCase ( snake_case__ , snake_case__ , snake_case__ , snake_case__ = False):
if not isinstance(_object , snake_case__):
lowerCAmelCase_ : List[str] = F'''{var_name} must be a dict'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object):
lowerCAmelCase_ : Dict = F'''{var_name} all keys must be strings'''
raise ValueError(snake_case__)
if not all(isinstance(snake_case__ , snake_case__) for x in _object.values()):
lowerCAmelCase_ : Union[str, Any] = "nested dictionary " if nested else ""
lowerCAmelCase_ : Any = F'''{var_name} {nested_text}all values must be {value_type.__name__}'''
raise ValueError(snake_case__)
if __name__ == "__main__":
from doctest import testmod
testmod()
| 683 | 0 |
from typing import List, Optional, Tuple, Union
import torch
from ...schedulers import DDIMScheduler
from ...utils import randn_tensor
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def __init__( self , A , A ) -> Optional[int]:
super().__init__()
# make sure scheduler can always be converted to DDIM
snake_case : Dict = DDIMScheduler.from_config(scheduler.config )
self.register_modules(unet=A , scheduler=A )
@torch.no_grad()
def __call__( self , A = 1 , A = None , A = 0.0 , A = 5_0 , A = None , A = "pil" , A = True , ) -> Union[ImagePipelineOutput, Tuple]:
# Sample gaussian noise to begin loop
if isinstance(self.unet.config.sample_size , A ):
snake_case : Optional[int] = (
batch_size,
self.unet.config.in_channels,
self.unet.config.sample_size,
self.unet.config.sample_size,
)
else:
snake_case : Optional[int] = (batch_size, self.unet.config.in_channels, *self.unet.config.sample_size)
if isinstance(A , A ) and len(A ) != batch_size:
raise ValueError(
f"""You have passed a list of generators of length {len(A )}, but requested an effective batch"""
f""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" )
snake_case : Tuple = randn_tensor(A , generator=A , device=self.device , dtype=self.unet.dtype )
# set step values
self.scheduler.set_timesteps(A )
for t in self.progress_bar(self.scheduler.timesteps ):
# 1. predict noise model_output
snake_case : Any = self.unet(A , A ).sample
# 2. predict previous mean of image x_t-1 and add variance depending on eta
# eta corresponds to η in paper and should be between [0, 1]
# do x_t -> x_t-1
snake_case : Any = self.scheduler.step(
A , A , A , eta=A , use_clipped_model_output=A , generator=A ).prev_sample
snake_case : List[str] = (image / 2 + 0.5).clamp(0 , 1 )
snake_case : Any = image.cpu().permute(0 , 2 , 3 , 1 ).numpy()
if output_type == "pil":
snake_case : Optional[Any] = self.numpy_to_pil(A )
if not return_dict:
return (image,)
return ImagePipelineOutput(images=A )
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> list:
snake_case : str = len(lowercase )
snake_case : Tuple = []
for i in range(len(lowercase ) - pat_len + 1 ):
snake_case : str = True
for j in range(lowercase ):
if s[i + j] != pattern[j]:
snake_case : Dict = False
break
if match_found:
position.append(lowercase )
return position
if __name__ == "__main__":
assert naive_pattern_search('ABCDEFG', 'DE') == [3]
print(naive_pattern_search('ABAAABCDBBABCDDEBCABC', 'ABC'))
| 684 | 1 |
lowerCamelCase : int = [0, 2, 4, 6, 8]
lowerCamelCase : Optional[Any] = [1, 3, 5, 7, 9]
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ,lowercase ) -> int:
if remaining_length == 0:
if digits[0] == 0 or digits[-1] == 0:
return 0
for i in range(length // 2 - 1 ,-1 ,-1 ):
remainder += digits[i] + digits[length - i - 1]
if remainder % 2 == 0:
return 0
remainder //= 10
return 1
if remaining_length == 1:
if remainder % 2 == 0:
return 0
snake_case : int = 0
for digit in range(10 ):
snake_case : Optional[int] = digit
result += reversible_numbers(
0 ,(remainder + 2 * digit) // 10 ,lowercase ,lowercase )
return result
snake_case : List[Any] = 0
for digita in range(10 ):
snake_case : str = digita
if (remainder + digita) % 2 == 0:
snake_case : Any = ODD_DIGITS
else:
snake_case : Optional[Any] = EVEN_DIGITS
for digita in other_parity_digits:
snake_case : List[str] = digita
result += reversible_numbers(
remaining_length - 2 ,(remainder + digita + digita) // 10 ,lowercase ,lowercase ,)
return result
def SCREAMING_SNAKE_CASE__ ( lowercase = 9 ) -> int:
snake_case : Optional[int] = 0
for length in range(1 ,max_power + 1 ):
result += reversible_numbers(lowercase ,0 ,[0] * length ,lowercase )
return result
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 |
import numpy as np
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> np.array:
return (2 / (1 + np.exp(-2 * vector ))) - 1
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
from collections import OrderedDict
from typing import Mapping
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
lowerCamelCase : List[str] = logging.get_logger(__name__)
lowerCamelCase : Optional[Any] = {
'distilbert-base-uncased': 'https://huggingface.co/distilbert-base-uncased/resolve/main/config.json',
'distilbert-base-uncased-distilled-squad': (
'https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json'
),
'distilbert-base-cased': 'https://huggingface.co/distilbert-base-cased/resolve/main/config.json',
'distilbert-base-cased-distilled-squad': (
'https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json'
),
'distilbert-base-german-cased': 'https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json',
'distilbert-base-multilingual-cased': (
'https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json'
),
'distilbert-base-uncased-finetuned-sst-2-english': (
'https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json'
),
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """distilbert"""
_snake_case = {
"""hidden_size""": """dim""",
"""num_attention_heads""": """n_heads""",
"""num_hidden_layers""": """n_layers""",
}
def __init__( self , A=3_0_5_2_2 , A=5_1_2 , A=False , A=6 , A=1_2 , A=7_6_8 , A=4 * 7_6_8 , A=0.1 , A=0.1 , A="gelu" , A=0.02 , A=0.1 , A=0.2 , A=0 , **A , ) -> Dict:
snake_case : Optional[Any] = vocab_size
snake_case : int = max_position_embeddings
snake_case : Optional[Any] = sinusoidal_pos_embds
snake_case : Optional[int] = n_layers
snake_case : Dict = n_heads
snake_case : int = dim
snake_case : List[str] = hidden_dim
snake_case : Union[str, Any] = dropout
snake_case : List[str] = attention_dropout
snake_case : Union[str, Any] = activation
snake_case : List[str] = initializer_range
snake_case : List[Any] = qa_dropout
snake_case : Dict = seq_classif_dropout
super().__init__(**A , pad_token_id=A )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
@property
def UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]:
if self.task == "multiple-choice":
snake_case : Dict = {0: """batch""", 1: """choice""", 2: """sequence"""}
else:
snake_case : Optional[int] = {0: """batch""", 1: """sequence"""}
return OrderedDict(
[
("""input_ids""", dynamic_axis),
("""attention_mask""", dynamic_axis),
] )
| 684 |
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_torch_available,
)
lowerCamelCase : Tuple = {'configuration_vit_mae': ['VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMAEConfig']}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : int = [
'VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST',
'ViTMAEForPreTraining',
'ViTMAELayer',
'ViTMAEModel',
'ViTMAEPreTrainedModel',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Dict = [
'TFViTMAEForPreTraining',
'TFViTMAEModel',
'TFViTMAEPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_vit_mae import (
VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
ViTMAEForPreTraining,
ViTMAELayer,
ViTMAEModel,
ViTMAEPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel
else:
import sys
lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list:
if len(lowercase ) <= 1:
return [tuple(lowercase )]
snake_case : str = []
def generate(lowercase ,lowercase ):
if k == 1:
res.append(tuple(arr[:] ) )
return
generate(k - 1 ,lowercase )
for i in range(k - 1 ):
if k % 2 == 0: # k is even
snake_case , snake_case : List[Any] = arr[k - 1], arr[i]
else: # k is odd
snake_case , snake_case : List[Any] = arr[k - 1], arr[0]
generate(k - 1 ,lowercase )
generate(len(lowercase ) ,lowercase )
return res
if __name__ == "__main__":
lowerCamelCase : int = input('Enter numbers separated by a comma:\n').strip()
lowerCamelCase : int = [int(item) for item in user_input.split(',')]
print(heaps(arr))
| 684 |
lowerCamelCase : Union[str, Any] = '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'
lowerCamelCase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}]
lowerCamelCase : Union[str, Any] = {
'{processor_class}': 'FakeProcessorClass',
'{model_class}': 'FakeModelClass',
'{object_class}': 'FakeObjectClass',
}
| 684 | 1 |
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 : Optional[int] = logging.get_logger(__name__)
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""pixel_values"""]
def __init__( self , A = True , A = None , A = PIL.Image.BICUBIC , A = True , A = None , A = 1 / 2_5_5 , A = True , A = True , A = None , A = None , **A , ) -> None:
super().__init__(**A )
snake_case : int = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
snake_case : int = get_size_dict(A )
snake_case : Optional[Any] = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
snake_case : Dict = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = do_resize
snake_case : str = size
snake_case : Tuple = resample
snake_case : Any = do_center_crop
snake_case : Tuple = crop_size
snake_case : int = do_rescale
snake_case : Dict = rescale_factor
snake_case : Union[str, Any] = do_normalize
snake_case : Union[str, Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
snake_case : Optional[Any] = image_std if image_std is not None else IMAGENET_STANDARD_STD
def UpperCAmelCase ( self , A , A , A = PIL.Image.BICUBIC , A = None , **A , ) -> np.ndarray:
snake_case : Dict = get_size_dict(A )
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(
A , size=(size["""height"""], size["""width"""]) , resample=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> np.ndarray:
snake_case : Any = get_size_dict(A )
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(A , size=(size["""height"""], size["""width"""]) , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> Tuple:
return rescale(A , scale=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A , A = None , **A , ) -> np.ndarray:
return normalize(A , mean=A , std=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A = None , A = None , A=None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = ChannelDimension.FIRST , **A , ) -> PIL.Image.Image:
snake_case : str = do_resize if do_resize is not None else self.do_resize
snake_case : Dict = resample if resample is not None else self.resample
snake_case : Dict = do_center_crop if do_center_crop is not None else self.do_center_crop
snake_case : Tuple = do_rescale if do_rescale is not None else self.do_rescale
snake_case : Optional[Any] = rescale_factor if rescale_factor is not None else self.rescale_factor
snake_case : List[str] = do_normalize if do_normalize is not None else self.do_normalize
snake_case : int = image_mean if image_mean is not None else self.image_mean
snake_case : List[str] = image_std if image_std is not None else self.image_std
snake_case : Dict = size if size is not None else self.size
snake_case : Tuple = get_size_dict(A )
snake_case : Dict = crop_size if crop_size is not None else self.crop_size
snake_case : List[str] = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = make_list_of_images(A )
if not valid_images(A ):
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.
snake_case : Optional[Any] = [to_numpy_array(A ) for image in images]
if do_resize:
snake_case : Dict = [self.resize(image=A , size=A , resample=A ) for image in images]
if do_center_crop:
snake_case : List[str] = [self.center_crop(image=A , size=A ) for image in images]
if do_rescale:
snake_case : List[str] = [self.rescale(image=A , scale=A ) for image in images]
if do_normalize:
snake_case : str = [self.normalize(image=A , mean=A , std=A ) for image in images]
snake_case : Union[str, Any] = [to_channel_dimension_format(A , A ) for image in images]
snake_case : List[Any] = {"""pixel_values""": images}
return BatchFeature(data=A , tensor_type=A )
| 684 |
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {'vocab_file': 'spm_char.model'}
lowerCamelCase : List[str] = {
'vocab_file': {
'microsoft/speecht5_asr': 'https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model',
'microsoft/speecht5_tts': 'https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model',
'microsoft/speecht5_vc': 'https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model',
}
}
lowerCamelCase : List[Any] = {
'microsoft/speecht5_asr': 1_0_2_4,
'microsoft/speecht5_tts': 1_0_2_4,
'microsoft/speecht5_vc': 1_0_2_4,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A="<s>" , A="</s>" , A="<unk>" , A="<pad>" , A = None , **A , ) -> None:
snake_case : List[str] = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=A , eos_token=A , unk_token=A , pad_token=A , sp_model_kwargs=self.sp_model_kwargs , **A , )
snake_case : Tuple = vocab_file
snake_case : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(A )
@property
def UpperCAmelCase ( self ) -> List[Any]:
return self.sp_model.get_piece_size()
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = {self.convert_ids_to_tokens(A ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __getstate__( self ) -> List[str]:
snake_case : Optional[Any] = self.__dict__.copy()
snake_case : Optional[Any] = None
return state
def __setstate__( self , A ) -> Tuple:
snake_case : Any = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs""" ):
snake_case : List[Any] = {}
snake_case : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def UpperCAmelCase ( self , A ) -> List[str]:
return self.sp_model.encode(A , out_type=A )
def UpperCAmelCase ( self , A ) -> Tuple:
return self.sp_model.piece_to_id(A )
def UpperCAmelCase ( self , A ) -> int:
snake_case : Union[str, Any] = self.sp_model.IdToPiece(A )
return token
def UpperCAmelCase ( self , A ) -> Tuple:
snake_case : Optional[int] = []
snake_case : str = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(A ) + token
snake_case : Dict = []
else:
current_sub_tokens.append(A )
out_string += self.sp_model.decode(A )
return out_string.strip()
def UpperCAmelCase ( self , A , A=None ) -> List[int]:
if token_ids_a is None:
return token_ids_a + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_a + token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[int]:
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=A , token_ids_a=A , already_has_special_tokens=A )
snake_case : Any = [1]
if token_ids_a is None:
return ([0] * len(A )) + suffix_ones
return ([0] * len(A )) + ([0] * len(A )) + suffix_ones
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Optional[Any] = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(A ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , A )
elif not os.path.isfile(self.vocab_file ):
with open(A , """wb""" ) as fi:
snake_case : Union[str, Any] = self.sp_model.serialized_model_proto()
fi.write(A )
return (out_vocab_file,)
| 684 | 1 |
from typing import TYPE_CHECKING
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
lowerCamelCase : Dict = {
'configuration_clipseg': [
'CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP',
'CLIPSegConfig',
'CLIPSegTextConfig',
'CLIPSegVisionConfig',
],
'processing_clipseg': ['CLIPSegProcessor'],
}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Any = [
'CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST',
'CLIPSegModel',
'CLIPSegPreTrainedModel',
'CLIPSegTextModel',
'CLIPSegVisionModel',
'CLIPSegForImageSegmentation',
]
if TYPE_CHECKING:
from .configuration_clipseg import (
CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
CLIPSegConfig,
CLIPSegTextConfig,
CLIPSegVisionConfig,
)
from .processing_clipseg import CLIPSegProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_clipseg import (
CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
CLIPSegForImageSegmentation,
CLIPSegModel,
CLIPSegPreTrainedModel,
CLIPSegTextModel,
CLIPSegVisionModel,
)
else:
import sys
lowerCamelCase : Tuple = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {
'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json',
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """gpt_neox_japanese"""
def __init__( self , A=3_2_0_0_0 , A=2_5_6_0 , A=3_2 , A=3_2 , A=4 , A="gelu" , A=1.00 , A=1_0_0_0_0 , A=2_0_4_8 , A=0.02 , A=1e-5 , A=True , A=3_1_9_9_6 , A=3_1_9_9_9 , A=0.1 , A=0.0 , **A , ) -> str:
super().__init__(bos_token_id=A , eos_token_id=A , **A )
snake_case : Optional[Any] = vocab_size
snake_case : Optional[Any] = max_position_embeddings
snake_case : Union[str, Any] = hidden_size
snake_case : Union[str, Any] = num_hidden_layers
snake_case : Optional[int] = num_attention_heads
snake_case : Optional[int] = intermediate_multiple_size
snake_case : int = hidden_act
snake_case : str = rotary_pct
snake_case : Optional[Any] = rotary_emb_base
snake_case : Any = initializer_range
snake_case : Any = layer_norm_eps
snake_case : Optional[Any] = use_cache
snake_case : Tuple = attention_dropout
snake_case : Tuple = hidden_dropout
| 684 | 1 |
import argparse
import json
from pathlib import Path
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging
logging.set_verbosity_info()
lowerCamelCase : Tuple = logging.get_logger(__name__)
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase=False ,lowercase=False ) -> Tuple:
snake_case : Optional[Any] = """backbone.""" if is_semantic else """"""
snake_case : Tuple = []
for i in range(config.num_hidden_layers ):
# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
rename_keys.append((f"""{prefix}blocks.{i}.norm1.weight""", f"""beit.encoder.layer.{i}.layernorm_before.weight""") )
rename_keys.append((f"""{prefix}blocks.{i}.norm1.bias""", f"""beit.encoder.layer.{i}.layernorm_before.bias""") )
rename_keys.append(
(f"""{prefix}blocks.{i}.attn.proj.weight""", f"""beit.encoder.layer.{i}.attention.output.dense.weight""") )
rename_keys.append(
(f"""{prefix}blocks.{i}.attn.proj.bias""", f"""beit.encoder.layer.{i}.attention.output.dense.bias""") )
rename_keys.append((f"""{prefix}blocks.{i}.norm2.weight""", f"""beit.encoder.layer.{i}.layernorm_after.weight""") )
rename_keys.append((f"""{prefix}blocks.{i}.norm2.bias""", f"""beit.encoder.layer.{i}.layernorm_after.bias""") )
rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.weight""", f"""beit.encoder.layer.{i}.intermediate.dense.weight""") )
rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.bias""", f"""beit.encoder.layer.{i}.intermediate.dense.bias""") )
rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.weight""", f"""beit.encoder.layer.{i}.output.dense.weight""") )
rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.bias""", f"""beit.encoder.layer.{i}.output.dense.bias""") )
# projection layer + position embeddings
rename_keys.extend(
[
(f"""{prefix}cls_token""", """beit.embeddings.cls_token"""),
(f"""{prefix}patch_embed.proj.weight""", """beit.embeddings.patch_embeddings.projection.weight"""),
(f"""{prefix}patch_embed.proj.bias""", """beit.embeddings.patch_embeddings.projection.bias"""),
(f"""{prefix}pos_embed""", """beit.embeddings.position_embeddings"""),
] )
if has_lm_head:
# mask token + layernorm
rename_keys.extend(
[
("""mask_token""", """beit.embeddings.mask_token"""),
("""norm.weight""", """layernorm.weight"""),
("""norm.bias""", """layernorm.bias"""),
] )
else:
# layernorm + classification head
rename_keys.extend(
[
("""fc_norm.weight""", """beit.pooler.layernorm.weight"""),
("""fc_norm.bias""", """beit.pooler.layernorm.bias"""),
("""head.weight""", """classifier.weight"""),
("""head.bias""", """classifier.bias"""),
] )
return rename_keys
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase=False ,lowercase=False ) -> Optional[Any]:
for i in range(config.num_hidden_layers ):
snake_case : int = """backbone.""" if is_semantic else """"""
# queries, keys and values
snake_case : Union[str, Any] = state_dict.pop(f"""{prefix}blocks.{i}.attn.qkv.weight""" )
snake_case : List[str] = state_dict.pop(f"""{prefix}blocks.{i}.attn.q_bias""" )
snake_case : Dict = state_dict.pop(f"""{prefix}blocks.{i}.attn.v_bias""" )
snake_case : Union[str, Any] = in_proj_weight[
: config.hidden_size, :
]
snake_case : List[str] = q_bias
snake_case : List[str] = in_proj_weight[
config.hidden_size : config.hidden_size * 2, :
]
snake_case : Optional[Any] = in_proj_weight[
-config.hidden_size :, :
]
snake_case : str = v_bias
# gamma_1 and gamma_2
# we call them lambda because otherwise they are renamed when using .from_pretrained
snake_case : Tuple = state_dict.pop(f"""{prefix}blocks.{i}.gamma_1""" )
snake_case : Union[str, Any] = state_dict.pop(f"""{prefix}blocks.{i}.gamma_2""" )
snake_case : str = gamma_a
snake_case : int = gamma_a
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> str:
snake_case : str = dct.pop(lowercase )
snake_case : Any = val
def SCREAMING_SNAKE_CASE__ ( ) -> Optional[Any]:
snake_case : Tuple = """http://images.cocodataset.org/val2017/000000039769.jpg"""
snake_case : int = Image.open(requests.get(lowercase ,stream=lowercase ).raw )
return im
@torch.no_grad()
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase=False ) -> List[str]:
snake_case : List[str] = False if """rvlcdip""" in checkpoint_url else True
snake_case : Tuple = BeitConfig(use_absolute_position_embeddings=lowercase ,use_mask_token=lowercase )
# size of the architecture
if "large" in checkpoint_url or "dit-l" in checkpoint_url:
snake_case : List[str] = 1024
snake_case : Optional[int] = 4096
snake_case : List[str] = 24
snake_case : Dict = 16
# labels
if "rvlcdip" in checkpoint_url:
snake_case : int = 16
snake_case : Any = """huggingface/label-files"""
snake_case : List[str] = """rvlcdip-id2label.json"""
snake_case : Union[str, Any] = json.load(open(hf_hub_download(lowercase ,lowercase ,repo_type="""dataset""" ) ,"""r""" ) )
snake_case : List[str] = {int(lowercase ): v for k, v in idalabel.items()}
snake_case : Any = idalabel
snake_case : Union[str, Any] = {v: k for k, v in idalabel.items()}
# load state_dict of original model, remove and rename some keys
snake_case : List[Any] = torch.hub.load_state_dict_from_url(lowercase ,map_location="""cpu""" )["""model"""]
snake_case : Any = create_rename_keys(lowercase ,has_lm_head=lowercase )
for src, dest in rename_keys:
rename_key(lowercase ,lowercase ,lowercase )
read_in_q_k_v(lowercase ,lowercase ,has_lm_head=lowercase )
# load HuggingFace model
snake_case : List[str] = BeitForMaskedImageModeling(lowercase ) if has_lm_head else BeitForImageClassification(lowercase )
model.eval()
model.load_state_dict(lowercase )
# Check outputs on an image
snake_case : int = BeitImageProcessor(
size=config.image_size ,resample=PILImageResampling.BILINEAR ,do_center_crop=lowercase )
snake_case : Any = prepare_img()
snake_case : Tuple = image_processor(images=lowercase ,return_tensors="""pt""" )
snake_case : Optional[int] = encoding["""pixel_values"""]
snake_case : str = model(lowercase )
snake_case : List[Any] = outputs.logits
# verify logits
snake_case : Tuple = [1, 16] if """rvlcdip""" in checkpoint_url else [1, 196, 8192]
assert logits.shape == torch.Size(lowercase ), "Shape of logits not as expected"
Path(lowercase ).mkdir(exist_ok=lowercase )
print(f"""Saving model to {pytorch_dump_folder_path}""" )
model.save_pretrained(lowercase )
print(f"""Saving image processor to {pytorch_dump_folder_path}""" )
image_processor.save_pretrained(lowercase )
if push_to_hub:
if has_lm_head:
snake_case : Dict = """dit-base""" if """base""" in checkpoint_url else """dit-large"""
else:
snake_case : Union[str, Any] = """dit-base-finetuned-rvlcdip""" if """dit-b""" in checkpoint_url else """dit-large-finetuned-rvlcdip"""
image_processor.push_to_hub(
repo_path_or_name=Path(lowercase ,lowercase ) ,organization="""nielsr""" ,commit_message="""Add image processor""" ,use_temp_dir=lowercase ,)
model.push_to_hub(
repo_path_or_name=Path(lowercase ,lowercase ) ,organization="""nielsr""" ,commit_message="""Add model""" ,use_temp_dir=lowercase ,)
if __name__ == "__main__":
lowerCamelCase : Union[str, Any] = argparse.ArgumentParser()
parser.add_argument(
'--checkpoint_url',
default='https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth',
type=str,
help='URL to the original PyTorch checkpoint (.pth file).',
)
parser.add_argument(
'--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
)
parser.add_argument(
'--push_to_hub',
action='store_true',
)
lowerCamelCase : Tuple = parser.parse_args()
convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : Optional[Any] = hex_num.strip()
if not hex_num:
raise ValueError("""No value was passed to the function""" )
snake_case : Any = hex_num[0] == """-"""
if is_negative:
snake_case : int = hex_num[1:]
try:
snake_case : List[Any] = int(lowercase ,16 )
except ValueError:
raise ValueError("""Invalid value was passed to the function""" )
snake_case : Dict = """"""
while int_num > 0:
snake_case : Dict = str(int_num % 2 ) + bin_str
int_num >>= 1
return int(("""-""" + bin_str) if is_negative else bin_str )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
from __future__ import annotations
from bisect import bisect_left
from functools import total_ordering
from heapq import merge
@total_ordering
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def __lt__( self , A ) -> Dict:
return self[-1] < other[-1]
def __eq__( self , A ) -> str:
return self[-1] == other[-1]
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list:
snake_case : list[Stack] = []
# sort into stacks
for element in collection:
snake_case : int = Stack([element] )
snake_case : Optional[int] = bisect_left(lowercase ,lowercase )
if i != len(lowercase ):
stacks[i].append(lowercase )
else:
stacks.append(lowercase )
# use a heap-based merge to merge stack efficiently
snake_case : Optional[int] = merge(*(reversed(lowercase ) for stack in stacks) )
return collection
if __name__ == "__main__":
lowerCamelCase : Union[str, Any] = input('Enter numbers separated by a comma:\n').strip()
lowerCamelCase : Union[str, Any] = [int(item) for item in user_input.split(',')]
print(patience_sort(unsorted))
| 684 |
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 : Optional[int] = logging.get_logger(__name__)
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""pixel_values"""]
def __init__( self , A = True , A = None , A = PIL.Image.BICUBIC , A = True , A = None , A = 1 / 2_5_5 , A = True , A = True , A = None , A = None , **A , ) -> None:
super().__init__(**A )
snake_case : int = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
snake_case : int = get_size_dict(A )
snake_case : Optional[Any] = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
snake_case : Dict = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = do_resize
snake_case : str = size
snake_case : Tuple = resample
snake_case : Any = do_center_crop
snake_case : Tuple = crop_size
snake_case : int = do_rescale
snake_case : Dict = rescale_factor
snake_case : Union[str, Any] = do_normalize
snake_case : Union[str, Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
snake_case : Optional[Any] = image_std if image_std is not None else IMAGENET_STANDARD_STD
def UpperCAmelCase ( self , A , A , A = PIL.Image.BICUBIC , A = None , **A , ) -> np.ndarray:
snake_case : Dict = get_size_dict(A )
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(
A , size=(size["""height"""], size["""width"""]) , resample=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> np.ndarray:
snake_case : Any = get_size_dict(A )
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(A , size=(size["""height"""], size["""width"""]) , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> Tuple:
return rescale(A , scale=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A , A = None , **A , ) -> np.ndarray:
return normalize(A , mean=A , std=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A = None , A = None , A=None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = ChannelDimension.FIRST , **A , ) -> PIL.Image.Image:
snake_case : str = do_resize if do_resize is not None else self.do_resize
snake_case : Dict = resample if resample is not None else self.resample
snake_case : Dict = do_center_crop if do_center_crop is not None else self.do_center_crop
snake_case : Tuple = do_rescale if do_rescale is not None else self.do_rescale
snake_case : Optional[Any] = rescale_factor if rescale_factor is not None else self.rescale_factor
snake_case : List[str] = do_normalize if do_normalize is not None else self.do_normalize
snake_case : int = image_mean if image_mean is not None else self.image_mean
snake_case : List[str] = image_std if image_std is not None else self.image_std
snake_case : Dict = size if size is not None else self.size
snake_case : Tuple = get_size_dict(A )
snake_case : Dict = crop_size if crop_size is not None else self.crop_size
snake_case : List[str] = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = make_list_of_images(A )
if not valid_images(A ):
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.
snake_case : Optional[Any] = [to_numpy_array(A ) for image in images]
if do_resize:
snake_case : Dict = [self.resize(image=A , size=A , resample=A ) for image in images]
if do_center_crop:
snake_case : List[str] = [self.center_crop(image=A , size=A ) for image in images]
if do_rescale:
snake_case : List[str] = [self.rescale(image=A , scale=A ) for image in images]
if do_normalize:
snake_case : str = [self.normalize(image=A , mean=A , std=A ) for image in images]
snake_case : Union[str, Any] = [to_channel_dimension_format(A , A ) for image in images]
snake_case : List[Any] = {"""pixel_values""": images}
return BatchFeature(data=A , tensor_type=A )
| 684 | 1 |
import pytest
lowerCamelCase : Union[str, Any] = '__dummy_dataset1__'
lowerCamelCase : int = '\nimport json\nimport os\n\nimport datasets\n\n\nREPO_URL = "https://huggingface.co/datasets/albertvillanova/tests-raw-jsonl/resolve/main/"\nURLS = {"train": REPO_URL + "wikiann-bn-train.jsonl", "validation": REPO_URL + "wikiann-bn-validation.jsonl"}\n\n\nclass __DummyDataset1__(datasets.GeneratorBasedBuilder):\n\n def _info(self):\n features = datasets.Features(\n {\n "tokens": datasets.Sequence(datasets.Value("string")),\n "ner_tags": datasets.Sequence(\n datasets.features.ClassLabel(\n names=[\n "O",\n "B-PER",\n "I-PER",\n "B-ORG",\n "I-ORG",\n "B-LOC",\n "I-LOC",\n ]\n )\n ),\n "langs": datasets.Sequence(datasets.Value("string")),\n "spans": datasets.Sequence(datasets.Value("string")),\n }\n )\n return datasets.DatasetInfo(features=features)\n\n def _split_generators(self, dl_manager):\n dl_path = dl_manager.download(URLS)\n return [\n datasets.SplitGenerator(datasets.Split.TRAIN, gen_kwargs={"filepath": dl_path["train"]}),\n datasets.SplitGenerator(datasets.Split.VALIDATION, gen_kwargs={"filepath": dl_path["validation"]}),\n ]\n\n def _generate_examples(self, filepath):\n with open(filepath, "r", encoding="utf-8") as f:\n for i, line in enumerate(f):\n yield i, json.loads(line)\n'
@pytest.fixture
def SCREAMING_SNAKE_CASE__ ( ) -> str:
return DATASET_LOADING_SCRIPT_NAME
@pytest.fixture
def SCREAMING_SNAKE_CASE__ ( ) -> int:
return DATASET_LOADING_SCRIPT_CODE
@pytest.fixture
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> str:
snake_case : int = dataset_loading_script_name
snake_case : Any = tmp_path / """datasets""" / script_name
script_dir.mkdir(parents=lowercase )
snake_case : int = script_dir / f"""{script_name}.py"""
with open(lowercase ,"""w""" ) as f:
f.write(lowercase )
return str(lowercase )
| 684 |
import inspect
import unittest
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> List[Any]:
try:
import diffusers # noqa: F401
except ImportError:
assert False
def UpperCAmelCase ( self ) -> Tuple:
import diffusers
from diffusers.dependency_versions_table import deps
snake_case : List[str] = inspect.getmembers(A , inspect.isclass )
for cls_name, cls_module in all_classes:
if "dummy_" in cls_module.__module__:
for backend in cls_module._backends:
if backend == "k_diffusion":
snake_case : Tuple = """k-diffusion"""
elif backend == "invisible_watermark":
snake_case : Optional[int] = """invisible-watermark"""
assert backend in deps, f"""{backend} is not in the deps table!"""
| 684 | 1 |
import numpy as np
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> np.array:
return (2 / (1 + np.exp(-2 * vector ))) - 1
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 |
import contextlib
import importlib
import io
import unittest
import transformers
# Try to import everything from transformers to ensure every object can be loaded.
from transformers import * # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available
if is_torch_available():
from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification
if is_tf_available():
from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification
if is_flax_available():
from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification
lowerCamelCase : Union[str, Any] = DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co
lowerCamelCase : List[Any] = 'main'
# Default branch name
lowerCamelCase : Tuple = 'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
lowerCamelCase : List[Any] = 'aaaaaaa'
# This commit does not exist, so we should 404.
lowerCamelCase : List[Any] = 'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
lowerCamelCase : int = '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> Optional[int]:
print("""Welcome!""" )
yield
print("""Bye!""" )
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> List[str]:
print("""Bonjour!""" )
yield
print("""Au revoir!""" )
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> int:
# If the spec is missing, importlib would not be able to import the module dynamically.
assert transformers.__spec__ is not None
assert importlib.util.find_spec("""transformers""" ) is not None
class __lowercase (unittest.TestCase ):
"""simple docstring"""
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> Optional[Any]:
with ContextManagers([] ):
print("""Transformers are awesome!""" )
# The print statement adds a new line at the end of the output
self.assertEqual(mock_stdout.getvalue() , """Transformers are awesome!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Welcome!\nTransformers are awesome!\nBye!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_fr(), context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English and French welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n""" )
@require_torch
def UpperCAmelCase ( self ) -> Optional[Any]:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_tf
def UpperCAmelCase ( self ) -> str:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_flax
def UpperCAmelCase ( self ) -> Any:
# Flax models don't have labels
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , [] )
| 684 | 1 |
import copy
import json
import os
import tempfile
from transformers import is_torch_available
from .test_configuration_utils import config_common_kwargs
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def __init__( self , A , A=None , A=True , A=None , **A ) -> Optional[int]:
snake_case : Optional[Any] = parent
snake_case : Tuple = config_class
snake_case : Dict = has_text_modality
snake_case : Optional[Any] = kwargs
snake_case : List[Any] = common_properties
def UpperCAmelCase ( self ) -> Dict:
snake_case : Any = self.config_class(**self.inputs_dict )
snake_case : Optional[Any] = (
["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""]
if self.common_properties is None
else self.common_properties
)
# Add common fields for text models
if self.has_text_modality:
common_properties.extend(["""vocab_size"""] )
# Test that config has the common properties as getters
for prop in common_properties:
self.parent.assertTrue(hasattr(A , A ) , msg=f"""`{prop}` does not exist""" )
# Test that config has the common properties as setter
for idx, name in enumerate(A ):
try:
setattr(A , A , A )
self.parent.assertEqual(
getattr(A , A ) , A , msg=f"""`{name} value {idx} expected, but was {getattr(A , A )}""" )
except NotImplementedError:
# Some models might not be able to implement setters for common_properties
# In that case, a NotImplementedError is raised
pass
# Test if config class can be called with Config(prop_name=..)
for idx, name in enumerate(A ):
try:
snake_case : List[Any] = self.config_class(**{name: idx} )
self.parent.assertEqual(
getattr(A , A ) , A , msg=f"""`{name} value {idx} expected, but was {getattr(A , A )}""" )
except NotImplementedError:
# Some models might not be able to implement setters for common_properties
# In that case, a NotImplementedError is raised
pass
def UpperCAmelCase ( self ) -> Dict:
snake_case : List[str] = self.config_class(**self.inputs_dict )
snake_case : Optional[Any] = json.loads(config.to_json_string() )
for key, value in self.inputs_dict.items():
self.parent.assertEqual(obj[key] , A )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : Optional[int] = self.config_class(**self.inputs_dict )
with tempfile.TemporaryDirectory() as tmpdirname:
snake_case : Dict = os.path.join(A , """config.json""" )
config_first.to_json_file(A )
snake_case : Any = self.config_class.from_json_file(A )
self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() )
def UpperCAmelCase ( self ) -> Any:
snake_case : Optional[int] = self.config_class(**self.inputs_dict )
with tempfile.TemporaryDirectory() as tmpdirname:
config_first.save_pretrained(A )
snake_case : List[Any] = self.config_class.from_pretrained(A )
self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Optional[int] = self.config_class(**self.inputs_dict )
snake_case : Any = """test"""
with tempfile.TemporaryDirectory() as tmpdirname:
snake_case : List[str] = os.path.join(A , A )
config_first.save_pretrained(A )
snake_case : Union[str, Any] = self.config_class.from_pretrained(A , subfolder=A )
self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() )
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = self.config_class(**self.inputs_dict , num_labels=5 )
self.parent.assertEqual(len(config.idalabel ) , 5 )
self.parent.assertEqual(len(config.labelaid ) , 5 )
snake_case : Any = 3
self.parent.assertEqual(len(config.idalabel ) , 3 )
self.parent.assertEqual(len(config.labelaid ) , 3 )
def UpperCAmelCase ( self ) -> List[str]:
if self.config_class.is_composition:
return
snake_case : Optional[int] = self.config_class()
self.parent.assertIsNotNone(A )
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : List[Any] = copy.deepcopy(A )
snake_case : List[Any] = self.config_class(**A )
snake_case : Dict = []
for key, value in config_common_kwargs.items():
if key == "torch_dtype":
if not is_torch_available():
continue
else:
import torch
if config.torch_dtype != torch.floataa:
wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa) )
elif getattr(A , A ) != value:
wrong_values.append((key, getattr(A , A ), value) )
if len(A ) > 0:
snake_case : Union[str, Any] = """\n""".join([f"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values] )
raise ValueError(f"""The following keys were not properly set in the config:\n{errors}""" )
def UpperCAmelCase ( self ) -> List[str]:
self.create_and_test_config_common_properties()
self.create_and_test_config_to_json_string()
self.create_and_test_config_to_json_file()
self.create_and_test_config_from_and_save_pretrained()
self.create_and_test_config_from_and_save_pretrained_subfolder()
self.create_and_test_config_with_num_labels()
self.check_config_can_be_init_without_params()
self.check_config_arguments_init()
| 684 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Optional[Any] = logging.get_logger(__name__)
lowerCamelCase : Dict = {
'MIT/ast-finetuned-audioset-10-10-0.4593': (
'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
),
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """audio-spectrogram-transformer"""
def __init__( self , A=7_6_8 , A=1_2 , A=1_2 , A=3_0_7_2 , A="gelu" , A=0.0 , A=0.0 , A=0.02 , A=1e-1_2 , A=1_6 , A=True , A=1_0 , A=1_0 , A=1_0_2_4 , A=1_2_8 , **A , ) -> int:
super().__init__(**A )
snake_case : Any = hidden_size
snake_case : Tuple = num_hidden_layers
snake_case : Any = num_attention_heads
snake_case : Dict = intermediate_size
snake_case : int = hidden_act
snake_case : int = hidden_dropout_prob
snake_case : Tuple = attention_probs_dropout_prob
snake_case : int = initializer_range
snake_case : int = layer_norm_eps
snake_case : Any = patch_size
snake_case : List[Any] = qkv_bias
snake_case : int = frequency_stride
snake_case : Any = time_stride
snake_case : Union[str, Any] = max_length
snake_case : Any = num_mel_bins
| 684 | 1 |
import argparse
import json
import os
import evaluate
import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed
from accelerate import Accelerator, DistributedType
from accelerate.utils.deepspeed import DummyOptim, DummyScheduler
lowerCamelCase : Union[str, Any] = 1_6
lowerCamelCase : Tuple = 3_2
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase = 16 ,lowercase = "bert-base-cased" ) -> int:
snake_case : Optional[int] = AutoTokenizer.from_pretrained(lowercase )
snake_case : Optional[Any] = load_dataset("""glue""" ,"""mrpc""" )
def tokenize_function(lowercase ):
# max_length=None => use the model max length (it's actually the default)
snake_case : Any = tokenizer(examples["""sentence1"""] ,examples["""sentence2"""] ,truncation=lowercase ,max_length=lowercase )
return outputs
# Apply the method we just defined to all the examples in all the splits of the dataset
snake_case : Optional[int] = datasets.map(
lowercase ,batched=lowercase ,remove_columns=["""idx""", """sentence1""", """sentence2"""] ,load_from_cache_file=lowercase )
# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
# transformers library
snake_case : Union[str, Any] = tokenized_datasets.rename_column("""label""" ,"""labels""" )
def collate_fn(lowercase ):
# On TPU it's best to pad everything to the same length or training will be very slow.
if accelerator.distributed_type == DistributedType.TPU:
return tokenizer.pad(lowercase ,padding="""max_length""" ,max_length=128 ,return_tensors="""pt""" )
return tokenizer.pad(lowercase ,padding="""longest""" ,return_tensors="""pt""" )
# Instantiate dataloaders.
snake_case : str = DataLoader(
tokenized_datasets["""train"""] ,shuffle=lowercase ,collate_fn=lowercase ,batch_size=lowercase )
snake_case : Union[str, Any] = DataLoader(
tokenized_datasets["""validation"""] ,shuffle=lowercase ,collate_fn=lowercase ,batch_size=lowercase )
return train_dataloader, eval_dataloader
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ,lowercase ) -> Optional[int]:
model.eval()
snake_case : Union[str, Any] = 0
for step, batch in enumerate(lowercase ):
# We could avoid this line since we set the accelerator with `device_placement=True`.
batch.to(accelerator.device )
with torch.no_grad():
snake_case : int = model(**lowercase )
snake_case : List[str] = outputs.logits.argmax(dim=-1 )
# It is slightly faster to call this once, than multiple times
snake_case , snake_case : Any = accelerator.gather(
(predictions, batch["""labels"""]) ) # If we are in a multiprocess environment, the last batch has duplicates
if accelerator.use_distributed:
if step == len(lowercase ) - 1:
snake_case : Union[str, Any] = predictions[: len(eval_dataloader.dataset ) - samples_seen]
snake_case : str = references[: len(eval_dataloader.dataset ) - samples_seen]
else:
samples_seen += references.shape[0]
metric.add_batch(
predictions=lowercase ,references=lowercase ,)
snake_case : List[str] = metric.compute()
return eval_metric["accuracy"]
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> Any:
# Initialize accelerator
snake_case : Tuple = Accelerator()
# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
snake_case : Optional[Any] = config["""lr"""]
snake_case : Union[str, Any] = int(config["""num_epochs"""] )
snake_case : Dict = int(config["""seed"""] )
snake_case : Union[str, Any] = int(config["""batch_size"""] )
snake_case : Tuple = args.model_name_or_path
set_seed(lowercase )
snake_case , snake_case : Optional[Any] = get_dataloaders(lowercase ,lowercase ,lowercase )
# Instantiate the model (we build the model here so that the seed also control new weights initialization)
snake_case : Union[str, Any] = AutoModelForSequenceClassification.from_pretrained(lowercase ,return_dict=lowercase )
# Instantiate optimizer
snake_case : List[Any] = (
AdamW
if accelerator.state.deepspeed_plugin is None
or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config
else DummyOptim
)
snake_case : List[str] = optimizer_cls(params=model.parameters() ,lr=lowercase )
if accelerator.state.deepspeed_plugin is not None:
snake_case : Optional[Any] = accelerator.state.deepspeed_plugin.deepspeed_config[
"""gradient_accumulation_steps"""
]
else:
snake_case : List[Any] = 1
snake_case : Tuple = (len(lowercase ) * num_epochs) // gradient_accumulation_steps
# Instantiate scheduler
if (
accelerator.state.deepspeed_plugin is None
or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
):
snake_case : Any = get_linear_schedule_with_warmup(
optimizer=lowercase ,num_warmup_steps=0 ,num_training_steps=lowercase ,)
else:
snake_case : Optional[int] = DummyScheduler(lowercase ,total_num_steps=lowercase ,warmup_num_steps=0 )
# Prepare everything
# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
# prepare method.
snake_case , snake_case , snake_case , snake_case , snake_case : List[Any] = accelerator.prepare(
lowercase ,lowercase ,lowercase ,lowercase ,lowercase )
# We need to keep track of how many total steps we have iterated over
snake_case : Union[str, Any] = 0
# We also need to keep track of the stating epoch so files are named properly
snake_case : Union[str, Any] = 0
snake_case : Union[str, Any] = evaluate.load("""glue""" ,"""mrpc""" )
snake_case : Any = num_epochs
if args.partial_train_epoch is not None:
snake_case : str = args.partial_train_epoch
if args.resume_from_checkpoint:
accelerator.load_state(args.resume_from_checkpoint )
snake_case : str = args.resume_from_checkpoint.split("""epoch_""" )[1]
snake_case : int = """"""
for char in epoch_string:
if char.isdigit():
state_epoch_num += char
else:
break
snake_case : List[str] = int(lowercase ) + 1
snake_case : Union[str, Any] = evaluation_loop(lowercase ,lowercase ,lowercase ,lowercase )
accelerator.print("""resumed checkpoint performance:""" ,lowercase )
accelerator.print("""resumed checkpoint's scheduler's lr:""" ,lr_scheduler.get_lr()[0] )
accelerator.print("""resumed optimizers's lr:""" ,optimizer.param_groups[0]["""lr"""] )
with open(os.path.join(args.output_dir ,f"""state_{starting_epoch-1}.json""" ) ,"""r""" ) as f:
snake_case : Any = json.load(lowercase )
assert resumed_state["accuracy"] == accuracy, "Accuracy mismatch, loading from checkpoint failed"
assert (
resumed_state["lr"] == lr_scheduler.get_lr()[0]
), "Scheduler learning rate mismatch, loading from checkpoint failed"
assert (
resumed_state["optimizer_lr"] == optimizer.param_groups[0]["lr"]
), "Optimizer learning rate mismatch, loading from checkpoint failed"
assert resumed_state["epoch"] == starting_epoch - 1, "Epoch mismatch, loading from checkpoint failed"
return
# Now we train the model
snake_case : List[Any] = {}
for epoch in range(lowercase ,lowercase ):
model.train()
for step, batch in enumerate(lowercase ):
snake_case : str = model(**lowercase )
snake_case : str = outputs.loss
snake_case : Dict = loss / gradient_accumulation_steps
accelerator.backward(lowercase )
if step % gradient_accumulation_steps == 0:
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
overall_step += 1
snake_case : Optional[int] = f"""epoch_{epoch}"""
snake_case : Optional[int] = os.path.join(args.output_dir ,lowercase )
accelerator.save_state(lowercase )
snake_case : Dict = evaluation_loop(lowercase ,lowercase ,lowercase ,lowercase )
snake_case : str = accuracy
snake_case : Optional[Any] = lr_scheduler.get_lr()[0]
snake_case : List[str] = optimizer.param_groups[0]["""lr"""]
snake_case : int = epoch
snake_case : int = overall_step
accelerator.print(f"""epoch {epoch}:""" ,lowercase )
accelerator.wait_for_everyone()
if accelerator.is_main_process:
with open(os.path.join(args.output_dir ,f"""state_{epoch}.json""" ) ,"""w""" ) as f:
json.dump(lowercase ,lowercase )
def SCREAMING_SNAKE_CASE__ ( ) -> Union[str, Any]:
snake_case : Optional[int] = argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage.""" )
parser.add_argument(
"""--model_name_or_path""" ,type=lowercase ,default="""bert-base-cased""" ,help="""Path to pretrained model or model identifier from huggingface.co/models.""" ,required=lowercase ,)
parser.add_argument(
"""--output_dir""" ,type=lowercase ,default=""".""" ,help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory.""" ,)
parser.add_argument(
"""--resume_from_checkpoint""" ,type=lowercase ,default=lowercase ,help="""If the training should continue from a checkpoint folder.""" ,)
parser.add_argument(
"""--partial_train_epoch""" ,type=lowercase ,default=lowercase ,help="""If passed, the training will stop after this number of epochs.""" ,)
parser.add_argument(
"""--num_epochs""" ,type=lowercase ,default=2 ,help="""Number of train epochs.""" ,)
snake_case : Optional[Any] = parser.parse_args()
snake_case : Optional[Any] = {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 42, """batch_size""": 16}
training_function(lowercase ,lowercase )
if __name__ == "__main__":
main()
| 684 |
import enum
import warnings
from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
if is_torch_available():
from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
lowerCamelCase : Any = logging.get_logger(__name__)
class __lowercase (enum.Enum ):
"""simple docstring"""
_snake_case = 0
_snake_case = 1
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """generated"""
def __init__( self , *A , **A ) -> Optional[Any]:
super().__init__(*A , **A )
self.check_model_type(
TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
if self.framework == """tf"""
else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING )
def UpperCAmelCase ( self , A=None , A=None , A=None , A=None , A=None , A=None , **A , ) -> Optional[int]:
snake_case : Tuple = {}
if truncation is not None:
snake_case : Union[str, Any] = truncation
snake_case : Dict = generate_kwargs
snake_case : int = {}
if return_tensors is not None and return_type is None:
snake_case : List[Any] = ReturnType.TENSORS if return_tensors else ReturnType.TEXT
if return_type is not None:
snake_case : List[str] = return_type
if clean_up_tokenization_spaces is not None:
snake_case : int = clean_up_tokenization_spaces
if stop_sequence is not None:
snake_case : Tuple = self.tokenizer.encode(A , add_special_tokens=A )
if len(A ) > 1:
warnings.warn(
"""Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
""" the stop sequence will be used as the stop sequence string in the interim.""" )
snake_case : List[str] = stop_sequence_ids[0]
return preprocess_params, forward_params, postprocess_params
def UpperCAmelCase ( self , A , A , A ) -> Union[str, Any]:
return True
def UpperCAmelCase ( self , *A , A ) -> Tuple:
snake_case : Union[str, Any] = self.model.config.prefix if self.model.config.prefix is not None else """"""
if isinstance(args[0] , A ):
if self.tokenizer.pad_token_id is None:
raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" )
snake_case : Union[str, Any] = ([prefix + arg for arg in args[0]],)
snake_case : List[Any] = True
elif isinstance(args[0] , A ):
snake_case : str = (prefix + args[0],)
snake_case : str = False
else:
raise ValueError(
f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" )
snake_case : Optional[Any] = self.tokenizer(*A , padding=A , truncation=A , return_tensors=self.framework )
# This is produced by tokenizers but is an invalid generate kwargs
if "token_type_ids" in inputs:
del inputs["token_type_ids"]
return inputs
def __call__( self , *A , **A ) -> Union[str, Any]:
snake_case : Tuple = super().__call__(*A , **A )
if (
isinstance(args[0] , A )
and all(isinstance(A , A ) for el in args[0] )
and all(len(A ) == 1 for res in result )
):
return [res[0] for res in result]
return result
def UpperCAmelCase ( self , A , A=TruncationStrategy.DO_NOT_TRUNCATE , **A ) -> str:
snake_case : Optional[Any] = self._parse_and_tokenize(A , truncation=A , **A )
return inputs
def UpperCAmelCase ( self , A , **A ) -> Tuple:
if self.framework == "pt":
snake_case , snake_case : List[str] = model_inputs["""input_ids"""].shape
elif self.framework == "tf":
snake_case , snake_case : Optional[Any] = tf.shape(model_inputs["""input_ids"""] ).numpy()
snake_case : Dict = generate_kwargs.get("""min_length""" , self.model.config.min_length )
snake_case : str = generate_kwargs.get("""max_length""" , self.model.config.max_length )
self.check_inputs(A , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] )
snake_case : List[str] = self.model.generate(**A , **A )
snake_case : Dict = output_ids.shape[0]
if self.framework == "pt":
snake_case : List[Any] = output_ids.reshape(A , out_b // in_b , *output_ids.shape[1:] )
elif self.framework == "tf":
snake_case : Any = tf.reshape(A , (in_b, out_b // in_b, *output_ids.shape[1:]) )
return {"output_ids": output_ids}
def UpperCAmelCase ( self , A , A=ReturnType.TEXT , A=False ) -> Union[str, Any]:
snake_case : Tuple = []
for output_ids in model_outputs["output_ids"][0]:
if return_type == ReturnType.TENSORS:
snake_case : Dict = {f"""{self.return_name}_token_ids""": output_ids}
elif return_type == ReturnType.TEXT:
snake_case : int = {
f"""{self.return_name}_text""": self.tokenizer.decode(
A , skip_special_tokens=A , clean_up_tokenization_spaces=A , )
}
records.append(A )
return records
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """summary"""
def __call__( self , *A , **A ) -> str:
return super().__call__(*A , **A )
def UpperCAmelCase ( self , A , A , A ) -> bool:
if max_length < min_length:
logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" )
if input_length < max_length:
logger.warning(
f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """
"""a summarization task, where outputs shorter than the input are typically wanted, you might """
f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" )
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """translation"""
def UpperCAmelCase ( self , A , A , A ) -> Union[str, Any]:
if input_length > 0.9 * max_length:
logger.warning(
f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """
"""increasing your max_length manually, e.g. translator('...', max_length=400)""" )
return True
def UpperCAmelCase ( self , *A , A=TruncationStrategy.DO_NOT_TRUNCATE , A=None , A=None ) -> Optional[int]:
if getattr(self.tokenizer , """_build_translation_inputs""" , A ):
return self.tokenizer._build_translation_inputs(
*A , return_tensors=self.framework , truncation=A , src_lang=A , tgt_lang=A )
else:
return super()._parse_and_tokenize(*A , truncation=A )
def UpperCAmelCase ( self , A=None , A=None , **A ) -> Union[str, Any]:
snake_case , snake_case , snake_case : str = super()._sanitize_parameters(**A )
if src_lang is not None:
snake_case : Tuple = src_lang
if tgt_lang is not None:
snake_case : str = tgt_lang
if src_lang is None and tgt_lang is None:
# Backward compatibility, direct arguments use is preferred.
snake_case : Union[str, Any] = kwargs.get("""task""" , self.task )
snake_case : Any = task.split("""_""" )
if task and len(A ) == 4:
# translation, XX, to YY
snake_case : Optional[Any] = items[1]
snake_case : Dict = items[3]
return preprocess_params, forward_params, postprocess_params
def __call__( self , *A , **A ) -> str:
return super().__call__(*A , **A )
| 684 | 1 |
from pathlib import PurePosixPath
from typing import Optional
import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo
from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """"""
_snake_case = """hf-legacy""" # "hf://"" is reserved for hffs
def __init__( self , A = None , A = None , **A , ) -> List[str]:
super().__init__(self , **A )
snake_case : Dict = repo_info
snake_case : Union[str, Any] = token
snake_case : int = None
def UpperCAmelCase ( self ) -> Union[str, Any]:
if self.dir_cache is None:
snake_case : Dict = {}
for hf_file in self.repo_info.siblings:
# TODO(QL): add sizes
snake_case : Any = {
"""name""": hf_file.rfilename,
"""size""": None,
"""type""": """file""",
}
self.dir_cache.update(
{
str(A ): {"""name""": str(A ), """size""": None, """type""": """directory"""}
for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1]
} )
def UpperCAmelCase ( self , A , A = "rb" , **A , ) -> Dict:
if not isinstance(self.repo_info , A ):
raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" )
snake_case : int = hf_hub_url(self.repo_info.id , A , revision=self.repo_info.sha )
return fsspec.open(
A , mode=A , headers=get_authentication_headers_for_url(A , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open()
def UpperCAmelCase ( self , A , **A ) -> Any:
self._get_dirs()
snake_case : int = self._strip_protocol(A )
if path in self.dir_cache:
return self.dir_cache[path]
else:
raise FileNotFoundError(A )
def UpperCAmelCase ( self , A , A=False , **A ) -> int:
self._get_dirs()
snake_case : Optional[int] = PurePosixPath(path.strip("""/""" ) )
snake_case : Optional[int] = {}
for p, f in self.dir_cache.items():
snake_case : Dict = PurePosixPath(p.strip("""/""" ) )
snake_case : Union[str, Any] = p.parent
if root == path:
snake_case : List[str] = f
snake_case : Optional[int] = list(paths.values() )
if detail:
return out
else:
return sorted(f["""name"""] for f in out )
| 684 |
import inspect
import re
from hashlib import shaaaa
from typing import Dict, List
from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql # noqa F401
from .text import text
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> str:
snake_case : int = []
for line in lines:
snake_case : Dict = re.sub(R"""#.*""" ,"""""" ,lowercase ) # remove comments
if line:
filtered_lines.append(lowercase )
snake_case : Optional[int] = """\n""".join(lowercase )
# Make a hash from all this code
snake_case : List[str] = full_str.encode("""utf-8""" )
return shaaaa(lowercase ).hexdigest()
# get importable module names and hash for caching
lowerCamelCase : Any = {
'csv': (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
'json': (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
'pandas': (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
'parquet': (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
'arrow': (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
'text': (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
'imagefolder': (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
'audiofolder': (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}
# Used to infer the module to use based on the data files extensions
lowerCamelCase : Optional[int] = {
'.csv': ('csv', {}),
'.tsv': ('csv', {'sep': '\t'}),
'.json': ('json', {}),
'.jsonl': ('json', {}),
'.parquet': ('parquet', {}),
'.arrow': ('arrow', {}),
'.txt': ('text', {}),
}
_EXTENSION_TO_MODULE.update({ext: ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
lowerCamelCase : Tuple = {'imagefolder', 'audiofolder'}
# Used to filter data files based on extensions given a module name
lowerCamelCase : Dict[str, List[str]] = {}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
_MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)
_MODULE_TO_EXTENSIONS["imagefolder"].append('.zip')
_MODULE_TO_EXTENSIONS["audiofolder"].append('.zip')
| 684 | 1 |
lowerCamelCase : Union[str, Any] = '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'
lowerCamelCase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}]
lowerCamelCase : Union[str, Any] = {
'{processor_class}': 'FakeProcessorClass',
'{model_class}': 'FakeModelClass',
'{object_class}': 'FakeObjectClass',
}
| 684 |
import argparse
import torch
from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging
logging.set_verbosity_info()
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> Tuple:
# Initialise PyTorch model
snake_case : int = RemBertConfig.from_json_file(lowercase )
print("""Building PyTorch model from configuration: {}""".format(str(lowercase ) ) )
snake_case : Tuple = RemBertModel(lowercase )
# Load weights from tf checkpoint
load_tf_weights_in_rembert(lowercase ,lowercase ,lowercase )
# Save pytorch-model
print("""Save PyTorch model to {}""".format(lowercase ) )
torch.save(model.state_dict() ,lowercase )
if __name__ == "__main__":
lowerCamelCase : str = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
)
parser.add_argument(
'--rembert_config_file',
default=None,
type=str,
required=True,
help=(
'The config json file corresponding to the pre-trained RemBERT model. \n'
'This specifies the model architecture.'
),
)
parser.add_argument(
'--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
)
lowerCamelCase : Dict = parser.parse_args()
convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)
| 684 | 1 |
import json
import os
import unittest
from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES, XLMTokenizer
from transformers.testing_utils import slow
from ...test_tokenization_common import TokenizerTesterMixin
class __lowercase (UpperCamelCase__ , unittest.TestCase ):
"""simple docstring"""
_snake_case = XLMTokenizer
_snake_case = False
def UpperCAmelCase ( self ) -> int:
super().setUp()
# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
snake_case : Union[str, Any] = [
"""l""",
"""o""",
"""w""",
"""e""",
"""r""",
"""s""",
"""t""",
"""i""",
"""d""",
"""n""",
"""w</w>""",
"""r</w>""",
"""t</w>""",
"""lo""",
"""low""",
"""er</w>""",
"""low</w>""",
"""lowest</w>""",
"""newer</w>""",
"""wider</w>""",
"""<unk>""",
]
snake_case : Any = dict(zip(A , range(len(A ) ) ) )
snake_case : Optional[int] = ["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""]
snake_case : str = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] )
snake_case : Dict = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""merges_file"""] )
with open(self.vocab_file , """w""" ) as fp:
fp.write(json.dumps(A ) )
with open(self.merges_file , """w""" ) as fp:
fp.write("""\n""".join(A ) )
def UpperCAmelCase ( self , A ) -> int:
snake_case : str = """lower newer"""
snake_case : int = """lower newer"""
return input_text, output_text
def UpperCAmelCase ( self ) -> Any:
snake_case : Union[str, Any] = XLMTokenizer(self.vocab_file , self.merges_file )
snake_case : Optional[Any] = """lower"""
snake_case : List[Any] = ["""low""", """er</w>"""]
snake_case : str = tokenizer.tokenize(A )
self.assertListEqual(A , A )
snake_case : Dict = tokens + ["""<unk>"""]
snake_case : List[Any] = [1_4, 1_5, 2_0]
self.assertListEqual(tokenizer.convert_tokens_to_ids(A ) , A )
@slow
def UpperCAmelCase ( self ) -> Optional[Any]:
snake_case : List[str] = XLMTokenizer.from_pretrained("""xlm-mlm-en-2048""" )
snake_case : Optional[int] = tokenizer.encode("""sequence builders""" , add_special_tokens=A )
snake_case : Dict = tokenizer.encode("""multi-sequence build""" , add_special_tokens=A )
snake_case : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(A )
snake_case : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(A , A )
assert encoded_sentence == [0] + text + [1]
assert encoded_pair == [0] + text + [1] + text_a + [1]
| 684 |
from ..utils import DummyObject, requires_backends
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[str]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Any:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[int]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> str:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Union[str, Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> List[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Any:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Dict:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Dict:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[int]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> str:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[int]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> List[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Dict:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
| 684 | 1 |
import os
from collections import deque
import torch
from torch.utils.data import Dataset
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def __init__( self , A="" , A="train" ) -> int:
assert os.path.isdir(A )
snake_case : Optional[Any] = []
snake_case : int = os.listdir(A )
for story_filename in story_filenames_list:
if "summary" in story_filename:
continue
snake_case : Tuple = os.path.join(A , A )
if not os.path.isfile(A ):
continue
self.documents.append(A )
def __len__( self ) -> int:
return len(self.documents )
def __getitem__( self , A ) -> List[str]:
snake_case : str = self.documents[idx]
snake_case : Any = document_path.split("""/""" )[-1]
with open(A , encoding="""utf-8""" ) as source:
snake_case : List[Any] = source.read()
snake_case , snake_case : Optional[Any] = process_story(A )
return document_name, story_lines, summary_lines
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> Any:
snake_case : int = list(filter(lambda lowercase : len(lowercase ) != 0 ,[line.strip() for line in raw_story.split("""\n""" )] ) )
# for some unknown reason some lines miss a period, add it
snake_case : Union[str, Any] = [_add_missing_period(lowercase ) for line in nonempty_lines]
# gather article lines
snake_case : List[str] = []
snake_case : Dict = deque(lowercase )
while True:
try:
snake_case : Union[str, Any] = lines.popleft()
if element.startswith("""@highlight""" ):
break
story_lines.append(lowercase )
except IndexError:
# if "@highlight" is absent from the file we pop
# all elements until there is None, raising an exception.
return story_lines, []
# gather summary lines
snake_case : str = list(filter(lambda lowercase : not t.startswith("""@highlight""" ) ,lowercase ) )
return story_lines, summary_lines
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> Optional[int]:
snake_case : List[str] = [""".""", """!""", """?""", """...""", """'""", """`""", """\"""", """\u2019""", """\u2019""", """)"""]
if line.startswith("""@highlight""" ):
return line
if line[-1] in END_TOKENS:
return line
return line + "."
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> int:
if len(lowercase ) > block_size:
return sequence[:block_size]
else:
sequence.extend([pad_token_id] * (block_size - len(lowercase )) )
return sequence
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> List[Any]:
snake_case : Optional[Any] = torch.ones_like(lowercase )
snake_case : List[Any] = sequence == pad_token_id
snake_case : List[Any] = 0
return mask
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> Dict:
snake_case : Tuple = [tokenizer.encode(lowercase ) for line in story_lines]
snake_case : int = [token for sentence in story_lines_token_ids for token in sentence]
snake_case : Optional[int] = [tokenizer.encode(lowercase ) for line in summary_lines]
snake_case : Union[str, Any] = [token for sentence in summary_lines_token_ids for token in sentence]
return story_token_ids, summary_token_ids
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> Any:
snake_case : Optional[Any] = []
for sequence in batch:
snake_case : Dict = -1
snake_case : Optional[int] = []
for s in sequence:
if s == separator_token_id:
sentence_num += 1
embeddings.append(sentence_num % 2 )
batch_embeddings.append(lowercase )
return torch.tensor(lowercase )
| 684 |
import os
import random
import sys
from . import cryptomath_module as cryptomath
from . import rabin_miller
lowerCamelCase : List[str] = 3
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
print("""Generating primitive root of p""" )
while True:
snake_case : Optional[int] = random.randrange(3 ,lowercase )
if pow(lowercase ,2 ,lowercase ) == 1:
continue
if pow(lowercase ,lowercase ,lowercase ) == 1:
continue
return g
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> tuple[tuple[int, int, int, int], tuple[int, int]]:
print("""Generating prime p...""" )
snake_case : Optional[int] = rabin_miller.generate_large_prime(lowercase ) # select large prime number.
snake_case : Optional[int] = primitive_root(lowercase ) # one primitive root on modulo p.
snake_case : Optional[Any] = random.randrange(3 ,lowercase ) # private_key -> have to be greater than 2 for safety.
snake_case : Tuple = cryptomath.find_mod_inverse(pow(lowercase ,lowercase ,lowercase ) ,lowercase )
snake_case : str = (key_size, e_a, e_a, p)
snake_case : Optional[Any] = (key_size, d)
return public_key, private_key
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> None:
if os.path.exists(f"""{name}_pubkey.txt""" ) or os.path.exists(f"""{name}_privkey.txt""" ):
print("""\nWARNING:""" )
print(
f"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
"""Use a different name or delete these files and re-run this program.""" )
sys.exit()
snake_case , snake_case : Optional[Any] = generate_key(lowercase )
print(f"""\nWriting public key to file {name}_pubkey.txt...""" )
with open(f"""{name}_pubkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}""" )
print(f"""Writing private key to file {name}_privkey.txt...""" )
with open(f"""{name}_privkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{private_key[0]},{private_key[1]}""" )
def SCREAMING_SNAKE_CASE__ ( ) -> None:
print("""Making key files...""" )
make_key_files("""elgamal""" ,2048 )
print("""Key files generation successful""" )
if __name__ == "__main__":
main()
| 684 | 1 |
import unittest
from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
if is_torch_available():
import torch
from transformers import (
NystromformerForMaskedLM,
NystromformerForMultipleChoice,
NystromformerForQuestionAnswering,
NystromformerForSequenceClassification,
NystromformerForTokenClassification,
NystromformerModel,
)
from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST
class __lowercase :
"""simple docstring"""
def __init__( self , A , A=1_3 , A=7 , A=True , A=True , A=True , A=True , A=9_9 , A=3_2 , A=5 , A=4 , A=3_7 , A="gelu" , A=0.1 , A=0.1 , A=5_1_2 , A=1_6 , A=2 , A=0.02 , A=3 , A=4 , A=None , ) -> Tuple:
snake_case : Union[str, Any] = parent
snake_case : Union[str, Any] = batch_size
snake_case : Optional[Any] = seq_length
snake_case : Tuple = is_training
snake_case : int = use_input_mask
snake_case : Optional[int] = use_token_type_ids
snake_case : Dict = use_labels
snake_case : List[str] = vocab_size
snake_case : Optional[int] = hidden_size
snake_case : List[str] = num_hidden_layers
snake_case : Any = num_attention_heads
snake_case : Union[str, Any] = intermediate_size
snake_case : Any = hidden_act
snake_case : int = hidden_dropout_prob
snake_case : Dict = attention_probs_dropout_prob
snake_case : Any = max_position_embeddings
snake_case : Tuple = type_vocab_size
snake_case : Optional[Any] = type_sequence_label_size
snake_case : Optional[int] = initializer_range
snake_case : str = num_labels
snake_case : List[str] = num_choices
snake_case : List[str] = scope
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
snake_case : int = None
if self.use_input_mask:
snake_case : Dict = random_attention_mask([self.batch_size, self.seq_length] )
snake_case : List[str] = None
if self.use_token_type_ids:
snake_case : Dict = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
snake_case : Optional[Any] = None
snake_case : Union[str, Any] = None
snake_case : Union[str, Any] = None
if self.use_labels:
snake_case : List[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size )
snake_case : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
snake_case : Any = ids_tensor([self.batch_size] , self.num_choices )
snake_case : Optional[int] = self.get_config()
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def UpperCAmelCase ( self ) -> List[str]:
return NystromformerConfig(
vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : List[Any] = NystromformerModel(config=A )
model.to(A )
model.eval()
snake_case : str = model(A , attention_mask=A , token_type_ids=A )
snake_case : str = model(A , token_type_ids=A )
snake_case : Union[str, Any] = model(A )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : List[Any] = NystromformerForMaskedLM(config=A )
model.to(A )
model.eval()
snake_case : List[Any] = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : str = NystromformerForQuestionAnswering(config=A )
model.to(A )
model.eval()
snake_case : Dict = model(
A , attention_mask=A , token_type_ids=A , start_positions=A , end_positions=A , )
self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) )
self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> int:
snake_case : int = self.num_labels
snake_case : Dict = NystromformerForSequenceClassification(A )
model.to(A )
model.eval()
snake_case : Dict = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : str = self.num_labels
snake_case : List[str] = NystromformerForTokenClassification(config=A )
model.to(A )
model.eval()
snake_case : str = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : Any = self.num_choices
snake_case : Tuple = NystromformerForMultipleChoice(config=A )
model.to(A )
model.eval()
snake_case : List[Any] = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : List[str] = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : List[Any] = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : List[str] = model(
A , attention_mask=A , token_type_ids=A , labels=A , )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def UpperCAmelCase ( self ) -> Any:
snake_case : List[str] = self.prepare_config_and_inputs()
(
(
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) ,
) : Tuple = config_and_inputs
snake_case : str = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
return config, inputs_dict
@require_torch
class __lowercase (UpperCamelCase__ , UpperCamelCase__ , unittest.TestCase ):
"""simple docstring"""
_snake_case = (
(
NystromformerModel,
NystromformerForMaskedLM,
NystromformerForMultipleChoice,
NystromformerForQuestionAnswering,
NystromformerForSequenceClassification,
NystromformerForTokenClassification,
)
if is_torch_available()
else ()
)
_snake_case = (
{
"""feature-extraction""": NystromformerModel,
"""fill-mask""": NystromformerForMaskedLM,
"""question-answering""": NystromformerForQuestionAnswering,
"""text-classification""": NystromformerForSequenceClassification,
"""token-classification""": NystromformerForTokenClassification,
"""zero-shot""": NystromformerForSequenceClassification,
}
if is_torch_available()
else {}
)
_snake_case = False
_snake_case = False
def UpperCAmelCase ( self ) -> str:
snake_case : str = NystromformerModelTester(self )
snake_case : Tuple = ConfigTester(self , config_class=A , hidden_size=3_7 )
def UpperCAmelCase ( self ) -> Optional[int]:
self.config_tester.run_common_tests()
def UpperCAmelCase ( self ) -> str:
snake_case : List[str] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*A )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : List[str] = self.model_tester.prepare_config_and_inputs()
for type in ["absolute", "relative_key", "relative_key_query"]:
snake_case : int = type
self.model_tester.create_and_check_model(*A )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Tuple = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*A )
def UpperCAmelCase ( self ) -> str:
snake_case : Optional[int] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_multiple_choice(*A )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Any = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*A )
def UpperCAmelCase ( self ) -> Optional[Any]:
snake_case : Optional[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*A )
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : Union[str, Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*A )
@slow
def UpperCAmelCase ( self ) -> Optional[int]:
for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
snake_case : Any = NystromformerModel.from_pretrained(A )
self.assertIsNotNone(A )
@require_torch
class __lowercase (unittest.TestCase ):
"""simple docstring"""
@slow
def UpperCAmelCase ( self ) -> Any:
snake_case : Optional[int] = NystromformerModel.from_pretrained("""uw-madison/nystromformer-512""" )
snake_case : Tuple = torch.tensor([[0, 1, 2, 3, 4, 5]] )
with torch.no_grad():
snake_case : Any = model(A )[0]
snake_case : Optional[Any] = torch.Size((1, 6, 7_6_8) )
self.assertEqual(output.shape , A )
snake_case : List[str] = torch.tensor(
[[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]] )
self.assertTrue(torch.allclose(output[:, :3, :3] , A , atol=1e-4 ) )
@slow
def UpperCAmelCase ( self ) -> Tuple:
snake_case : int = """the [MASK] of Belgium is Brussels"""
snake_case : Union[str, Any] = AutoTokenizer.from_pretrained("""uw-madison/nystromformer-512""" )
snake_case : str = NystromformerForMaskedLM.from_pretrained("""uw-madison/nystromformer-512""" )
snake_case : Tuple = tokenizer(A , return_tensors="""pt""" )
with torch.no_grad():
snake_case : int = model(encoding.input_ids ).logits
snake_case : Dict = token_logits[:, 2, :].argmax(-1 )[0]
self.assertEqual(tokenizer.decode(A ) , """capital""" )
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> int:
if exponent == 1:
return base
if exponent % 2 == 0:
snake_case : Dict = _modexpt(lowercase ,exponent // 2 ,lowercase ) % modulo_value
return (x * x) % modulo_value
else:
return (base * _modexpt(lowercase ,exponent - 1 ,lowercase )) % modulo_value
def SCREAMING_SNAKE_CASE__ ( lowercase = 1777 ,lowercase = 1855 ,lowercase = 8 ) -> int:
snake_case : int = base
for _ in range(1 ,lowercase ):
snake_case : List[str] = _modexpt(lowercase ,lowercase ,10**digits )
return result
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 | 1 |
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 : Any = _symbol_database.Default()
lowerCamelCase : Optional[int] = _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 : Optional[int] = globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'sentencepiece_model_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
lowerCamelCase : Optional[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 : Any = 4_5
lowerCamelCase : Optional[Any] = 1_5_8_1
lowerCamelCase : Tuple = 1_5_1_7
lowerCamelCase : Dict = 1_5_7_0
lowerCamelCase : List[Any] = 1_5_8_4
lowerCamelCase : str = 1_7_9_3
lowerCamelCase : Union[str, Any] = 1_7_9_5
lowerCamelCase : Optional[int] = 1_9_1_6
lowerCamelCase : str = 1_8_6_4
lowerCamelCase : Any = 1_9_0_5
lowerCamelCase : Union[str, Any] = 1_9_1_9
lowerCamelCase : List[Any] = 2_4_2_9
lowerCamelCase : str = 2_2_0_8
lowerCamelCase : Union[str, Any] = 2_4_1_8
lowerCamelCase : List[Any] = 2_3_2_3
lowerCamelCase : str = 2_4_0_7
# @@protoc_insertion_point(module_scope)
| 684 |
from itertools import product
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> list[int]:
snake_case : Tuple = sides_number
snake_case : List[str] = max_face_number * dice_number
snake_case : Any = [0] * (max_total + 1)
snake_case : int = 1
snake_case : List[str] = range(lowercase ,max_face_number + 1 )
for dice_numbers in product(lowercase ,repeat=lowercase ):
snake_case : Any = sum(lowercase )
totals_frequencies[total] += 1
return totals_frequencies
def SCREAMING_SNAKE_CASE__ ( ) -> float:
snake_case : List[str] = total_frequency_distribution(
sides_number=4 ,dice_number=9 )
snake_case : str = total_frequency_distribution(
sides_number=6 ,dice_number=6 )
snake_case : Optional[int] = 0
snake_case : List[str] = 9
snake_case : Union[str, Any] = 4 * 9
snake_case : Dict = 6
for peter_total in range(lowercase ,max_peter_total + 1 ):
peter_wins_count += peter_totals_frequencies[peter_total] * sum(
colin_totals_frequencies[min_colin_total:peter_total] )
snake_case : str = (4**9) * (6**6)
snake_case : int = peter_wins_count / total_games_number
snake_case : Optional[int] = round(lowercase ,ndigits=7 )
return rounded_peter_win_probability
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 | 1 |
from __future__ import annotations
from typing import Any
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> None:
create_state_space_tree(lowercase ,[] ,0 )
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> None:
if index == len(lowercase ):
print(lowercase )
return
create_state_space_tree(lowercase ,lowercase ,index + 1 )
current_subsequence.append(sequence[index] )
create_state_space_tree(lowercase ,lowercase ,index + 1 )
current_subsequence.pop()
if __name__ == "__main__":
lowerCamelCase : list[Any] = [3, 1, 2, 4]
generate_all_subsequences(seq)
seq.clear()
seq.extend(['A', 'B', 'C'])
generate_all_subsequences(seq)
| 684 |
from ...utils import (
OptionalDependencyNotAvailable,
is_torch_available,
is_transformers_available,
is_transformers_version,
)
try:
if not (is_transformers_available() and is_torch_available() and is_transformers_version('>=', '4.25.0')):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import (
VersatileDiffusionDualGuidedPipeline,
VersatileDiffusionImageVariationPipeline,
VersatileDiffusionPipeline,
VersatileDiffusionTextToImagePipeline,
)
else:
from .modeling_text_unet import UNetFlatConditionModel
from .pipeline_versatile_diffusion import VersatileDiffusionPipeline
from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline
from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline
from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
| 684 | 1 |
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path
import torch_xla.distributed.xla_multiprocessing as xmp
def SCREAMING_SNAKE_CASE__ ( ) -> Union[str, Any]:
snake_case : Union[str, Any] = 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=lowercase ,default=1 ,help="""Number of TPU cores to use (1 or 8).""" )
# positional
parser.add_argument(
"""training_script""" ,type=lowercase ,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=lowercase )
return parser.parse_args()
def SCREAMING_SNAKE_CASE__ ( ) -> int:
snake_case : Union[str, Any] = parse_args()
# Import training_script as a module.
snake_case : List[Any] = Path(args.training_script )
sys.path.append(str(script_fpath.parent.resolve() ) )
snake_case : Union[str, Any] = script_fpath.stem
snake_case : Optional[Any] = importlib.import_module(lowercase )
# Patch sys.argv
snake_case : List[str] = [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()
| 684 |
import os
def SCREAMING_SNAKE_CASE__ ( ) -> Dict:
with open(os.path.dirname(lowercase ) + """/grid.txt""" ) as f:
snake_case : Tuple = [] # noqa: E741
for _ in range(20 ):
l.append([int(lowercase ) for x in f.readline().split()] )
snake_case : Optional[Any] = 0
# right
for i in range(20 ):
for j in range(17 ):
snake_case : List[Any] = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
if temp > maximum:
snake_case : Tuple = temp
# down
for i in range(17 ):
for j in range(20 ):
snake_case : Any = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
if temp > maximum:
snake_case : str = temp
# diagonal 1
for i in range(17 ):
for j in range(17 ):
snake_case : int = l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
if temp > maximum:
snake_case : int = temp
# diagonal 2
for i in range(17 ):
for j in range(3 ,20 ):
snake_case : Any = l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
if temp > maximum:
snake_case : Any = temp
return maximum
if __name__ == "__main__":
print(solution())
| 684 | 1 |
import os
import pytest
from transformers.dynamic_module_utils import get_imports
lowerCamelCase : Optional[Any] = '\nimport os\n'
lowerCamelCase : str = '\ndef foo():\n import os\n return False\n'
lowerCamelCase : Optional[Any] = '\ndef foo():\n def bar():\n if True:\n import os\n return False\n return bar()\n'
lowerCamelCase : List[str] = '\nimport os\n\ntry:\n import bar\nexcept ImportError:\n raise ValueError()\n'
lowerCamelCase : Optional[int] = '\nimport os\n\ndef foo():\n try:\n import bar\n except ImportError:\n raise ValueError()\n'
lowerCamelCase : int = '\nimport os\n\ntry:\n import bar\nexcept (ImportError, AttributeError):\n raise ValueError()\n'
lowerCamelCase : Union[str, Any] = '\nimport os\n\ntry:\n import bar\nexcept ImportError as e:\n raise ValueError()\n'
lowerCamelCase : Union[str, Any] = '\nimport os\n\ntry:\n import bar\nexcept:\n raise ValueError()\n'
lowerCamelCase : List[str] = '\nimport os\n\ntry:\n import bar\n import baz\nexcept ImportError:\n raise ValueError()\n'
lowerCamelCase : Dict = '\nimport os\n\ntry:\n import bar\n import baz\nexcept ImportError:\n x = 1\n raise ValueError()\n'
lowerCamelCase : Any = [
TOP_LEVEL_IMPORT,
IMPORT_IN_FUNCTION,
DEEPLY_NESTED_IMPORT,
TOP_LEVEL_TRY_IMPORT,
GENERIC_EXCEPT_IMPORT,
MULTILINE_TRY_IMPORT,
MULTILINE_BOTH_IMPORT,
MULTIPLE_EXCEPTS_IMPORT,
EXCEPT_AS_IMPORT,
TRY_IMPORT_IN_FUNCTION,
]
@pytest.mark.parametrize("""case""" ,lowercase )
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> List[Any]:
snake_case : Optional[int] = os.path.join(lowercase ,"""test_file.py""" )
with open(lowercase ,"""w""" ) as _tmp_file:
_tmp_file.write(lowercase )
snake_case : str = get_imports(lowercase )
assert parsed_imports == ["os"]
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list:
for i in range(len(lowercase ) - 1 ,0 ,-1 ):
snake_case : Any = False
for j in range(lowercase ,0 ,-1 ):
if unsorted[j] < unsorted[j - 1]:
snake_case , snake_case : Optional[Any] = unsorted[j - 1], unsorted[j]
snake_case : Dict = True
for j in range(lowercase ):
if unsorted[j] > unsorted[j + 1]:
snake_case , snake_case : Dict = unsorted[j + 1], unsorted[j]
snake_case : Tuple = True
if not swapped:
break
return unsorted
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCamelCase : Any = input('Enter numbers separated by a comma:\n').strip()
lowerCamelCase : Optional[int] = [int(item) for item in user_input.split(',')]
print(f"""{cocktail_shaker_sort(unsorted) = }""")
| 684 | 1 |
from typing import TYPE_CHECKING
from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable
lowerCamelCase : Any = {'configuration_dpt': ['DPT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DPTConfig']}
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Optional[int] = ['DPTFeatureExtractor']
lowerCamelCase : Optional[int] = ['DPTImageProcessor']
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Any = [
'DPT_PRETRAINED_MODEL_ARCHIVE_LIST',
'DPTForDepthEstimation',
'DPTForSemanticSegmentation',
'DPTModel',
'DPTPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig
try:
if not is_vision_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .feature_extraction_dpt import DPTFeatureExtractor
from .image_processing_dpt import DPTImageProcessor
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_dpt import (
DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
DPTForDepthEstimation,
DPTForSemanticSegmentation,
DPTModel,
DPTPreTrainedModel,
)
else:
import sys
lowerCamelCase : Union[str, Any] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 |
import json
import os
import re
import unicodedata
from json.encoder import INFINITY
from typing import Any, Dict, List, Optional, Tuple, Union
import numpy as np
import regex
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging
from ...utils.generic import _is_jax, _is_numpy
lowerCamelCase : Tuple = logging.get_logger(__name__)
lowerCamelCase : Any = {
'artists_file': 'artists.json',
'lyrics_file': 'lyrics.json',
'genres_file': 'genres.json',
}
lowerCamelCase : Any = {
'artists_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json',
},
'genres_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json',
},
'lyrics_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json',
},
}
lowerCamelCase : Optional[int] = {
'jukebox': 5_1_2,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_LYRIC_TOKENS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A , A , A=["v3", "v2", "v2"] , A=5_1_2 , A=5 , A="<|endoftext|>" , **A , ) -> Optional[Any]:
snake_case : Dict = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else unk_token
super().__init__(
unk_token=A , n_genres=A , version=A , max_n_lyric_tokens=A , **A , )
snake_case : Optional[Any] = version
snake_case : Optional[Any] = max_n_lyric_tokens
snake_case : Tuple = n_genres
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : Union[str, Any] = json.load(A )
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : str = json.load(A )
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : List[str] = json.load(A )
snake_case : Tuple = r"""[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+"""
# In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters.
if len(self.lyrics_encoder ) == 7_9:
snake_case : Optional[Any] = oov.replace(r"""\-'""" , r"""\-+'""" )
snake_case : Optional[Any] = regex.compile(A )
snake_case : Optional[Any] = {v: k for k, v in self.artists_encoder.items()}
snake_case : int = {v: k for k, v in self.genres_encoder.items()}
snake_case : List[Any] = {v: k for k, v in self.lyrics_encoder.items()}
@property
def UpperCAmelCase ( self ) -> Optional[Any]:
return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder )
def UpperCAmelCase ( self ) -> str:
return dict(self.artists_encoder , self.genres_encoder , self.lyrics_encoder )
def UpperCAmelCase ( self , A , A , A ) -> Optional[Any]:
snake_case : Optional[int] = [self.artists_encoder.get(A , 0 ) for artist in list_artists]
for genres in range(len(A ) ):
snake_case : Optional[int] = [self.genres_encoder.get(A , 0 ) for genre in list_genres[genres]]
snake_case : Union[str, Any] = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] ))
snake_case : Optional[Any] = [[self.lyrics_encoder.get(A , 0 ) for character in list_lyrics[0]], [], []]
return artists_id, list_genres, lyric_ids
def UpperCAmelCase ( self , A ) -> List[str]:
return list(A )
def UpperCAmelCase ( self , A , A , A , **A ) -> List[str]:
snake_case , snake_case , snake_case : Any = self.prepare_for_tokenization(A , A , A )
snake_case : Tuple = self._tokenize(A )
return artist, genre, lyrics
def UpperCAmelCase ( self , A , A , A , A = False ) -> Tuple[str, str, str, Dict[str, Any]]:
for idx in range(len(self.version ) ):
if self.version[idx] == "v3":
snake_case : Tuple = artists[idx].lower()
snake_case : List[Any] = [genres[idx].lower()]
else:
snake_case : Union[str, Any] = self._normalize(artists[idx] ) + """.v2"""
snake_case : Any = [
self._normalize(A ) + """.v2""" for genre in genres[idx].split("""_""" )
] # split is for the full dictionary with combined genres
if self.version[0] == "v2":
snake_case : str = regex.compile(r"""[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+""" )
snake_case : Dict = """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+'\"()[] \t\n"""
snake_case : Union[str, Any] = {vocab[index]: index + 1 for index in range(len(A ) )}
snake_case : Optional[int] = 0
snake_case : Union[str, Any] = len(A ) + 1
snake_case : Optional[int] = self.vocab
snake_case : str = {v: k for k, v in self.vocab.items()}
snake_case : int = """"""
else:
snake_case : Optional[int] = regex.compile(r"""[^A-Za-z0-9.,:;!?\-+'\"()\[\] \t\n]+""" )
snake_case : int = self._run_strip_accents(A )
snake_case : Any = lyrics.replace("""\\""" , """\n""" )
snake_case : Tuple = self.out_of_vocab.sub("""""" , A ), [], []
return artists, genres, lyrics
def UpperCAmelCase ( self , A ) -> List[Any]:
snake_case : int = unicodedata.normalize("""NFD""" , A )
snake_case : int = []
for char in text:
snake_case : Optional[Any] = unicodedata.category(A )
if cat == "Mn":
continue
output.append(A )
return "".join(A )
def UpperCAmelCase ( self , A ) -> str:
snake_case : Dict = (
[chr(A ) for i in range(ord("""a""" ) , ord("""z""" ) + 1 )]
+ [chr(A ) for i in range(ord("""A""" ) , ord("""Z""" ) + 1 )]
+ [chr(A ) for i in range(ord("""0""" ) , ord("""9""" ) + 1 )]
+ ["""."""]
)
snake_case : Dict = frozenset(A )
snake_case : Dict = re.compile(r"""_+""" )
snake_case : str = """""".join([c if c in accepted else """_""" for c in text.lower()] )
snake_case : List[Any] = pattern.sub("""_""" , A ).strip("""_""" )
return text
def UpperCAmelCase ( self , A ) -> str:
return " ".join(A )
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[Any]:
# Convert to TensorType
if not isinstance(A , A ):
snake_case : Tuple = TensorType(A )
# Get a function reference for the correct framework
if tensor_type == TensorType.TENSORFLOW:
if not is_tf_available():
raise ImportError(
"""Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.""" )
import tensorflow as tf
snake_case : Union[str, Any] = tf.constant
snake_case : int = tf.is_tensor
elif tensor_type == TensorType.PYTORCH:
if not is_torch_available():
raise ImportError("""Unable to convert output to PyTorch tensors format, PyTorch is not installed.""" )
import torch
snake_case : List[str] = torch.tensor
snake_case : Optional[Any] = torch.is_tensor
elif tensor_type == TensorType.JAX:
if not is_flax_available():
raise ImportError("""Unable to convert output to JAX tensors format, JAX is not installed.""" )
import jax.numpy as jnp # noqa: F811
snake_case : Optional[int] = jnp.array
snake_case : Dict = _is_jax
else:
snake_case : List[str] = np.asarray
snake_case : Tuple = _is_numpy
# Do the tensor conversion in batch
try:
if prepend_batch_axis:
snake_case : Any = [inputs]
if not is_tensor(A ):
snake_case : List[Any] = as_tensor(A )
except: # noqa E722
raise ValueError(
"""Unable to create tensor, you should probably activate truncation and/or padding """
"""with 'padding=True' 'truncation=True' to have batched tensors with the same length.""" )
return inputs
def __call__( self , A , A , A="" , A="pt" ) -> BatchEncoding:
snake_case : List[str] = [0, 0, 0]
snake_case : List[str] = [artist] * len(self.version )
snake_case : List[Any] = [genres] * len(self.version )
snake_case , snake_case , snake_case : Optional[int] = self.tokenize(A , A , A )
snake_case , snake_case , snake_case : int = self._convert_token_to_id(A , A , A )
snake_case : Any = [-INFINITY] * len(full_tokens[-1] )
snake_case : int = [
self.convert_to_tensors(
[input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] , tensor_type=A )
for i in range(len(self.version ) )
]
return BatchEncoding({"""input_ids""": input_ids, """attention_masks""": attention_masks} )
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Any = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""artists_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.artists_encoder , ensure_ascii=A ) )
snake_case : Any = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""genres_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.genres_encoder , ensure_ascii=A ) )
snake_case : Tuple = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""lyrics_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.lyrics_encoder , ensure_ascii=A ) )
return (artists_file, genres_file, lyrics_file)
def UpperCAmelCase ( self , A , A , A ) -> List[Any]:
snake_case : Optional[int] = self.artists_decoder.get(A )
snake_case : Optional[Any] = [self.genres_decoder.get(A ) for genre in genres_index]
snake_case : Optional[int] = [self.lyrics_decoder.get(A ) for character in lyric_index]
return artist, genres, lyrics
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> List[str]:
assert x is not None
assert y is not None
snake_case : Optional[Any] = len(lowercase )
snake_case : List[Any] = len(lowercase )
# declaring the array for storing the dp values
snake_case : Optional[int] = [[0] * (n + 1) for _ in range(m + 1 )] # noqa: E741
for i in range(1 ,m + 1 ):
for j in range(1 ,n + 1 ):
snake_case : Union[str, Any] = 1 if x[i - 1] == y[j - 1] else 0
snake_case : List[str] = max(l[i - 1][j] ,l[i][j - 1] ,l[i - 1][j - 1] + match )
snake_case : Tuple = """"""
snake_case , snake_case : List[str] = m, n
while i > 0 and j > 0:
snake_case : Tuple = 1 if x[i - 1] == y[j - 1] else 0
if l[i][j] == l[i - 1][j - 1] + match:
if match == 1:
snake_case : Union[str, Any] = x[i - 1] + seq
i -= 1
j -= 1
elif l[i][j] == l[i - 1][j]:
i -= 1
else:
j -= 1
return l[m][n], seq
if __name__ == "__main__":
lowerCamelCase : Tuple = 'AGGTAB'
lowerCamelCase : int = 'GXTXAYB'
lowerCamelCase : str = 4
lowerCamelCase : List[Any] = 'GTAB'
lowerCamelCase , lowerCamelCase : List[str] = longest_common_subsequence(a, b)
print('len =', ln, ', sub-sequence =', subseq)
import doctest
doctest.testmod()
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> list:
snake_case : str = len(lowercase )
snake_case : Tuple = []
for i in range(len(lowercase ) - pat_len + 1 ):
snake_case : str = True
for j in range(lowercase ):
if s[i + j] != pattern[j]:
snake_case : Dict = False
break
if match_found:
position.append(lowercase )
return position
if __name__ == "__main__":
assert naive_pattern_search('ABCDEFG', 'DE') == [3]
print(naive_pattern_search('ABAAABCDBBABCDDEBCABC', 'ABC'))
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : str = [1]
snake_case , snake_case , snake_case : Any = 0, 0, 0
snake_case : Any = ugly_nums[ia] * 2
snake_case : List[str] = ugly_nums[ia] * 3
snake_case : List[Any] = ugly_nums[ia] * 5
for _ in range(1 ,lowercase ):
snake_case : List[Any] = min(lowercase ,lowercase ,lowercase )
ugly_nums.append(lowercase )
if next_num == next_a:
ia += 1
snake_case : str = ugly_nums[ia] * 2
if next_num == next_a:
ia += 1
snake_case : Dict = ugly_nums[ia] * 3
if next_num == next_a:
ia += 1
snake_case : Dict = ugly_nums[ia] * 5
return ugly_nums[-1]
if __name__ == "__main__":
from doctest import testmod
testmod(verbose=True)
print(f"""{ugly_numbers(2_0_0) = }""")
| 684 |
import numpy as np
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> np.array:
return (2 / (1 + np.exp(-2 * vector ))) - 1
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
import json
import os
import shutil
import tempfile
import unittest
import numpy as np
import pytest
from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available
if is_torch_available():
import torch
if is_vision_available():
from PIL import Image
from transformers import MgpstrProcessor, ViTImageProcessor
@require_torch
@require_vision
class __lowercase (unittest.TestCase ):
"""simple docstring"""
_snake_case = ViTImageProcessor if is_vision_available() else None
@property
def UpperCAmelCase ( self ) -> Union[str, Any]:
return self.image_processor_tester.prepare_image_processor_dict()
def UpperCAmelCase ( self ) -> Optional[Any]:
snake_case : Union[str, Any] = (3, 3_2, 1_2_8)
snake_case : Optional[int] = tempfile.mkdtemp()
# fmt: off
snake_case : Optional[int] = ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""]
# fmt: on
snake_case : List[Any] = dict(zip(A , range(len(A ) ) ) )
snake_case : List[Any] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] )
with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as fp:
fp.write(json.dumps(A ) + """\n""" )
snake_case : Optional[Any] = {
"""do_normalize""": False,
"""do_resize""": True,
"""image_processor_type""": """ViTImageProcessor""",
"""resample""": 3,
"""size""": {"""height""": 3_2, """width""": 1_2_8},
}
snake_case : Optional[int] = os.path.join(self.tmpdirname , A )
with open(self.image_processor_file , """w""" , encoding="""utf-8""" ) as fp:
json.dump(A , A )
def UpperCAmelCase ( self , **A ) -> int:
return MgpstrTokenizer.from_pretrained(self.tmpdirname , **A )
def UpperCAmelCase ( self , **A ) -> Union[str, Any]:
return ViTImageProcessor.from_pretrained(self.tmpdirname , **A )
def UpperCAmelCase ( self ) -> Optional[Any]:
shutil.rmtree(self.tmpdirname )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Tuple = np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )
snake_case : Optional[Any] = Image.fromarray(np.moveaxis(A , 0 , -1 ) )
return image_input
def UpperCAmelCase ( self ) -> List[str]:
snake_case : Optional[Any] = self.get_tokenizer()
snake_case : List[str] = self.get_image_processor()
snake_case : Union[str, Any] = MgpstrProcessor(tokenizer=A , image_processor=A )
processor.save_pretrained(self.tmpdirname )
snake_case : Tuple = MgpstrProcessor.from_pretrained(self.tmpdirname , use_fast=A )
self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer.get_vocab() )
self.assertIsInstance(processor.char_tokenizer , A )
self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() )
self.assertIsInstance(processor.image_processor , A )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Optional[Any] = self.get_tokenizer()
snake_case : List[str] = self.get_image_processor()
snake_case : Tuple = MgpstrProcessor(tokenizer=A , image_processor=A )
processor.save_pretrained(self.tmpdirname )
snake_case : Optional[Any] = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" )
snake_case : Optional[int] = self.get_image_processor(do_normalize=A , padding_value=1.0 )
snake_case : Union[str, Any] = MgpstrProcessor.from_pretrained(
self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=A , padding_value=1.0 )
self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() )
self.assertIsInstance(processor.char_tokenizer , A )
self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() )
self.assertIsInstance(processor.image_processor , A )
def UpperCAmelCase ( self ) -> Any:
snake_case : List[Any] = self.get_image_processor()
snake_case : List[str] = self.get_tokenizer()
snake_case : List[str] = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : List[str] = self.prepare_image_inputs()
snake_case : Union[str, Any] = image_processor(A , return_tensors="""np""" )
snake_case : List[Any] = processor(images=A , return_tensors="""np""" )
for key in input_image_proc.keys():
self.assertAlmostEqual(input_image_proc[key].sum() , input_processor[key].sum() , delta=1e-2 )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Dict = self.get_image_processor()
snake_case : Union[str, Any] = self.get_tokenizer()
snake_case : Optional[int] = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : Optional[int] = """test"""
snake_case : int = processor(text=A )
snake_case : Union[str, Any] = tokenizer(A )
for key in encoded_tok.keys():
self.assertListEqual(encoded_tok[key] , encoded_processor[key] )
def UpperCAmelCase ( self ) -> Dict:
snake_case : Tuple = self.get_image_processor()
snake_case : List[Any] = self.get_tokenizer()
snake_case : List[str] = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : List[str] = """test"""
snake_case : List[Any] = self.prepare_image_inputs()
snake_case : str = processor(text=A , images=A )
self.assertListEqual(list(inputs.keys() ) , ["""pixel_values""", """labels"""] )
# test if it raises when no input is passed
with pytest.raises(A ):
processor()
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : Union[str, Any] = self.get_image_processor()
snake_case : Optional[Any] = self.get_tokenizer()
snake_case : Dict = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : Optional[int] = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]]
snake_case : List[str] = processor.char_decode(A )
snake_case : Optional[Any] = tokenizer.batch_decode(A )
snake_case : Tuple = [seq.replace(""" """ , """""" ) for seq in decoded_tok]
self.assertListEqual(A , A )
def UpperCAmelCase ( self ) -> Any:
snake_case : List[str] = self.get_image_processor()
snake_case : Tuple = self.get_tokenizer()
snake_case : List[str] = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : List[Any] = None
snake_case : Any = self.prepare_image_inputs()
snake_case : List[Any] = processor(text=A , images=A )
self.assertListEqual(list(inputs.keys() ) , processor.model_input_names )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : Optional[int] = self.get_image_processor()
snake_case : Any = self.get_tokenizer()
snake_case : Union[str, Any] = MgpstrProcessor(tokenizer=A , image_processor=A )
snake_case : Union[str, Any] = torch.randn(1 , 2_7 , 3_8 )
snake_case : str = torch.randn(1 , 2_7 , 5_0_2_5_7 )
snake_case : Any = torch.randn(1 , 2_7 , 3_0_5_2_2 )
snake_case : int = processor.batch_decode([char_input, bpe_input, wp_input] )
self.assertListEqual(list(results.keys() ) , ["""generated_text""", """scores""", """char_preds""", """bpe_preds""", """wp_preds"""] )
| 684 |
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_torch_available,
)
lowerCamelCase : Tuple = {'configuration_vit_mae': ['VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMAEConfig']}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : int = [
'VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST',
'ViTMAEForPreTraining',
'ViTMAELayer',
'ViTMAEModel',
'ViTMAEPreTrainedModel',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Dict = [
'TFViTMAEForPreTraining',
'TFViTMAEModel',
'TFViTMAEPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_vit_mae import (
VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
ViTMAEForPreTraining,
ViTMAELayer,
ViTMAEModel,
ViTMAEPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel
else:
import sys
lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase = 600851475143 ) -> int:
try:
snake_case : Optional[int] = int(lowercase )
except (TypeError, ValueError):
raise TypeError("""Parameter n must be int or castable to int.""" )
if n <= 0:
raise ValueError("""Parameter n must be greater than or equal to one.""" )
snake_case : str = 2
snake_case : str = 0
if n == 2:
return 2
while n > 2:
while n % i != 0:
i += 1
snake_case : Any = i
while n % i == 0:
snake_case : Dict = n // i
i += 1
return int(lowercase )
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 |
lowerCamelCase : Union[str, Any] = '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'
lowerCamelCase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}]
lowerCamelCase : Union[str, Any] = {
'{processor_class}': 'FakeProcessorClass',
'{model_class}': 'FakeModelClass',
'{object_class}': 'FakeObjectClass',
}
| 684 | 1 |
import contextlib
import importlib
import io
import unittest
import transformers
# Try to import everything from transformers to ensure every object can be loaded.
from transformers import * # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available
if is_torch_available():
from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification
if is_tf_available():
from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification
if is_flax_available():
from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification
lowerCamelCase : Union[str, Any] = DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co
lowerCamelCase : List[Any] = 'main'
# Default branch name
lowerCamelCase : Tuple = 'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
lowerCamelCase : List[Any] = 'aaaaaaa'
# This commit does not exist, so we should 404.
lowerCamelCase : List[Any] = 'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
lowerCamelCase : int = '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> Optional[int]:
print("""Welcome!""" )
yield
print("""Bye!""" )
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> List[str]:
print("""Bonjour!""" )
yield
print("""Au revoir!""" )
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> int:
# If the spec is missing, importlib would not be able to import the module dynamically.
assert transformers.__spec__ is not None
assert importlib.util.find_spec("""transformers""" ) is not None
class __lowercase (unittest.TestCase ):
"""simple docstring"""
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> Optional[Any]:
with ContextManagers([] ):
print("""Transformers are awesome!""" )
# The print statement adds a new line at the end of the output
self.assertEqual(mock_stdout.getvalue() , """Transformers are awesome!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Welcome!\nTransformers are awesome!\nBye!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_fr(), context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English and French welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n""" )
@require_torch
def UpperCAmelCase ( self ) -> Optional[Any]:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_tf
def UpperCAmelCase ( self ) -> str:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_flax
def UpperCAmelCase ( self ) -> Any:
# Flax models don't have labels
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , [] )
| 684 |
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {'vocab_file': 'spm_char.model'}
lowerCamelCase : List[str] = {
'vocab_file': {
'microsoft/speecht5_asr': 'https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model',
'microsoft/speecht5_tts': 'https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model',
'microsoft/speecht5_vc': 'https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model',
}
}
lowerCamelCase : List[Any] = {
'microsoft/speecht5_asr': 1_0_2_4,
'microsoft/speecht5_tts': 1_0_2_4,
'microsoft/speecht5_vc': 1_0_2_4,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A="<s>" , A="</s>" , A="<unk>" , A="<pad>" , A = None , **A , ) -> None:
snake_case : List[str] = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=A , eos_token=A , unk_token=A , pad_token=A , sp_model_kwargs=self.sp_model_kwargs , **A , )
snake_case : Tuple = vocab_file
snake_case : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(A )
@property
def UpperCAmelCase ( self ) -> List[Any]:
return self.sp_model.get_piece_size()
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = {self.convert_ids_to_tokens(A ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __getstate__( self ) -> List[str]:
snake_case : Optional[Any] = self.__dict__.copy()
snake_case : Optional[Any] = None
return state
def __setstate__( self , A ) -> Tuple:
snake_case : Any = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs""" ):
snake_case : List[Any] = {}
snake_case : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def UpperCAmelCase ( self , A ) -> List[str]:
return self.sp_model.encode(A , out_type=A )
def UpperCAmelCase ( self , A ) -> Tuple:
return self.sp_model.piece_to_id(A )
def UpperCAmelCase ( self , A ) -> int:
snake_case : Union[str, Any] = self.sp_model.IdToPiece(A )
return token
def UpperCAmelCase ( self , A ) -> Tuple:
snake_case : Optional[int] = []
snake_case : str = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(A ) + token
snake_case : Dict = []
else:
current_sub_tokens.append(A )
out_string += self.sp_model.decode(A )
return out_string.strip()
def UpperCAmelCase ( self , A , A=None ) -> List[int]:
if token_ids_a is None:
return token_ids_a + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_a + token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[int]:
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=A , token_ids_a=A , already_has_special_tokens=A )
snake_case : Any = [1]
if token_ids_a is None:
return ([0] * len(A )) + suffix_ones
return ([0] * len(A )) + ([0] * len(A )) + suffix_ones
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Optional[Any] = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(A ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , A )
elif not os.path.isfile(self.vocab_file ):
with open(A , """wb""" ) as fi:
snake_case : Union[str, Any] = self.sp_model.serialized_model_proto()
fi.write(A )
return (out_vocab_file,)
| 684 | 1 |
import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple
import regex as re
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging
if TYPE_CHECKING:
from transformers.pipelines.conversational import Conversation
lowerCamelCase : int = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {
'vocab_file': 'vocab.json',
'merges_file': 'merges.txt',
'tokenizer_config_file': 'tokenizer_config.json',
}
lowerCamelCase : Dict = {
'vocab_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json'},
'merges_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt'},
'tokenizer_config_file': {
'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json'
},
}
lowerCamelCase : Union[str, Any] = {'facebook/blenderbot-3B': 1_2_8}
@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def SCREAMING_SNAKE_CASE__ ( ) -> Optional[int]:
snake_case : Optional[int] = (
list(range(ord("""!""" ) ,ord("""~""" ) + 1 ) ) + list(range(ord("""¡""" ) ,ord("""¬""" ) + 1 ) ) + list(range(ord("""®""" ) ,ord("""ÿ""" ) + 1 ) )
)
snake_case : Dict = bs[:]
snake_case : str = 0
for b in range(2**8 ):
if b not in bs:
bs.append(lowercase )
cs.append(2**8 + n )
n += 1
snake_case : Union[str, Any] = [chr(lowercase ) for n in cs]
return dict(zip(lowercase ,lowercase ) )
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> str:
snake_case : Union[str, Any] = set()
snake_case : List[Any] = word[0]
for char in word[1:]:
pairs.add((prev_char, char) )
snake_case : List[str] = char
return pairs
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A , A="replace" , A="<s>" , A="</s>" , A="</s>" , A="<s>" , A="<unk>" , A="<pad>" , A="<mask>" , A=False , **A , ) -> Tuple:
snake_case : Union[str, Any] = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else bos_token
snake_case : List[Any] = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else eos_token
snake_case : Tuple = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else sep_token
snake_case : Union[str, Any] = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else cls_token
snake_case : List[Any] = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else unk_token
snake_case : Any = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else pad_token
# Mask token behave like a normal word, i.e. include the space before it
snake_case : str = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else mask_token
super().__init__(
errors=A , bos_token=A , eos_token=A , unk_token=A , sep_token=A , cls_token=A , pad_token=A , mask_token=A , add_prefix_space=A , **A , )
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : Union[str, Any] = json.load(A )
snake_case : int = {v: k for k, v in self.encoder.items()}
snake_case : str = errors # how to handle errors in decoding
snake_case : Tuple = bytes_to_unicode()
snake_case : Tuple = {v: k for k, v in self.byte_encoder.items()}
with open(A , encoding="""utf-8""" ) as merges_handle:
snake_case : Dict = merges_handle.read().split("""\n""" )[1:-1]
snake_case : List[Any] = [tuple(merge.split() ) for merge in bpe_merges]
snake_case : List[Any] = dict(zip(A , range(len(A ) ) ) )
snake_case : Optional[Any] = {}
snake_case : Dict = add_prefix_space
# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
snake_case : Optional[int] = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""" )
@property
# Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
def UpperCAmelCase ( self ) -> Dict:
return len(self.encoder )
def UpperCAmelCase ( self ) -> Dict:
return dict(self.encoder , **self.added_tokens_encoder )
def UpperCAmelCase ( self , A ) -> str:
if token in self.cache:
return self.cache[token]
snake_case : List[str] = tuple(A )
snake_case : List[str] = get_pairs(A )
if not pairs:
return token
while True:
snake_case : Union[str, Any] = min(A , key=lambda A : self.bpe_ranks.get(A , float("""inf""" ) ) )
if bigram not in self.bpe_ranks:
break
snake_case , snake_case : str = bigram
snake_case : Any = []
snake_case : Union[str, Any] = 0
while i < len(A ):
try:
snake_case : str = word.index(A , A )
except ValueError:
new_word.extend(word[i:] )
break
else:
new_word.extend(word[i:j] )
snake_case : Optional[int] = j
if word[i] == first and i < len(A ) - 1 and word[i + 1] == second:
new_word.append(first + second )
i += 2
else:
new_word.append(word[i] )
i += 1
snake_case : Any = tuple(A )
snake_case : Optional[Any] = new_word
if len(A ) == 1:
break
else:
snake_case : Union[str, Any] = get_pairs(A )
snake_case : Dict = """ """.join(A )
snake_case : List[str] = word
return word
def UpperCAmelCase ( self , A ) -> Tuple:
snake_case : Union[str, Any] = []
for token in re.findall(self.pat , A ):
snake_case : Optional[int] = """""".join(
self.byte_encoder[b] for b in token.encode("""utf-8""" ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
bpe_tokens.extend(bpe_token for bpe_token in self.bpe(A ).split(""" """ ) )
return bpe_tokens
def UpperCAmelCase ( self , A ) -> Optional[int]:
return self.encoder.get(A , self.encoder.get(self.unk_token ) )
def UpperCAmelCase ( self , A ) -> List[Any]:
return self.decoder.get(A )
def UpperCAmelCase ( self , A ) -> str:
snake_case : Union[str, Any] = """""".join(A )
snake_case : Union[str, Any] = bytearray([self.byte_decoder[c] for c in text] ).decode("""utf-8""" , errors=self.errors )
return text
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Optional[Any] = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
snake_case : Any = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.encoder , indent=2 , sort_keys=A , ensure_ascii=A ) + """\n""" )
snake_case : int = 0
with open(A , """w""" , encoding="""utf-8""" ) as writer:
writer.write("""#version: 0.2\n""" )
for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda A : kv[1] ):
if index != token_index:
logger.warning(
f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
""" Please check that the tokenizer is not corrupted!""" )
snake_case : List[Any] = token_index
writer.write(""" """.join(A ) + """\n""" )
index += 1
return vocab_file, merge_file
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[int]:
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=A , token_ids_a=A , already_has_special_tokens=A )
if token_ids_a is None:
return [1] + ([0] * len(A )) + [1]
return [1] + ([0] * len(A )) + [1, 1] + ([0] * len(A )) + [1]
def UpperCAmelCase ( self , A , A = None ) -> List[int]:
snake_case : int = [self.sep_token_id]
snake_case : Optional[int] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
def UpperCAmelCase ( self , A , A=False , **A ) -> Dict:
snake_case : str = kwargs.pop("""add_prefix_space""" , self.add_prefix_space )
if (is_split_into_words or add_prefix_space) and (len(A ) > 0 and not text[0].isspace()):
snake_case : Optional[int] = """ """ + text
return (text, kwargs)
def UpperCAmelCase ( self , A , A = None ) -> Dict:
return token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A ) -> List[int]:
snake_case : Any = []
for is_user, text in conversation.iter_texts():
if is_user:
# We need to space prefix as it's being done within blenderbot
inputs.append(""" """ + text )
else:
# Generated responses should contain them already.
inputs.append(A )
snake_case : Optional[Any] = """ """.join(A )
snake_case : List[str] = self.encode(A )
if len(A ) > self.model_max_length:
snake_case : Any = input_ids[-self.model_max_length :]
logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens.""" )
return input_ids
| 684 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {
'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json',
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """gpt_neox_japanese"""
def __init__( self , A=3_2_0_0_0 , A=2_5_6_0 , A=3_2 , A=3_2 , A=4 , A="gelu" , A=1.00 , A=1_0_0_0_0 , A=2_0_4_8 , A=0.02 , A=1e-5 , A=True , A=3_1_9_9_6 , A=3_1_9_9_9 , A=0.1 , A=0.0 , **A , ) -> str:
super().__init__(bos_token_id=A , eos_token_id=A , **A )
snake_case : Optional[Any] = vocab_size
snake_case : Optional[Any] = max_position_embeddings
snake_case : Union[str, Any] = hidden_size
snake_case : Union[str, Any] = num_hidden_layers
snake_case : Optional[int] = num_attention_heads
snake_case : Optional[int] = intermediate_multiple_size
snake_case : int = hidden_act
snake_case : str = rotary_pct
snake_case : Optional[Any] = rotary_emb_base
snake_case : Any = initializer_range
snake_case : Any = layer_norm_eps
snake_case : Optional[Any] = use_cache
snake_case : Tuple = attention_dropout
snake_case : Tuple = hidden_dropout
| 684 | 1 |
import argparse
import collections
import os
import re
from transformers.utils import direct_transformers_import
# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_table.py
lowerCamelCase : Any = 'src/transformers'
lowerCamelCase : Dict = 'docs/source/en'
lowerCamelCase : int = '.'
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> Dict:
with open(lowercase ,"""r""" ,encoding="""utf-8""" ,newline="""\n""" ) as f:
snake_case : List[Any] = f.readlines()
# Find the start prompt.
snake_case : Dict = 0
while not lines[start_index].startswith(lowercase ):
start_index += 1
start_index += 1
snake_case : Optional[Any] = start_index
while not lines[end_index].startswith(lowercase ):
end_index += 1
end_index -= 1
while len(lines[start_index] ) <= 1:
start_index += 1
while len(lines[end_index] ) <= 1:
end_index -= 1
end_index += 1
return "".join(lines[start_index:end_index] ), start_index, end_index, lines
# Add here suffixes that are used to identify models, separated by |
lowerCamelCase : List[str] = 'Model|Encoder|Decoder|ForConditionalGeneration'
# Regexes that match TF/Flax/PT model names.
lowerCamelCase : Optional[int] = re.compile(r'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
lowerCamelCase : Optional[int] = re.compile(r'Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
lowerCamelCase : List[Any] = re.compile(r'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)')
# This is to make sure the transformers module imported is the one in the repo.
lowerCamelCase : Union[str, Any] = direct_transformers_import(TRANSFORMERS_PATH)
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> Optional[Any]:
snake_case : Optional[int] = re.finditer(""".+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)""" ,lowercase )
return [m.group(0 ) for m in matches]
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> Dict:
snake_case : Tuple = 2 if text == """✅""" or text == """❌""" else len(lowercase )
snake_case : int = (width - text_length) // 2
snake_case : str = width - text_length - left_indent
return " " * left_indent + text + " " * right_indent
def SCREAMING_SNAKE_CASE__ ( ) -> Dict:
snake_case : Optional[Any] = transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
snake_case : List[str] = {
name: config_maping_names[code]
for code, name in transformers_module.MODEL_NAMES_MAPPING.items()
if code in config_maping_names
}
snake_case : Optional[int] = {name: config.replace("""Config""" ,"""""" ) for name, config in model_name_to_config.items()}
# Dictionaries flagging if each model prefix has a slow/fast tokenizer, backend in PT/TF/Flax.
snake_case : Tuple = collections.defaultdict(lowercase )
snake_case : List[Any] = collections.defaultdict(lowercase )
snake_case : Optional[Any] = collections.defaultdict(lowercase )
snake_case : Dict = collections.defaultdict(lowercase )
snake_case : Dict = collections.defaultdict(lowercase )
# Let's lookup through all transformers object (once).
for attr_name in dir(lowercase ):
snake_case : List[str] = None
if attr_name.endswith("""Tokenizer""" ):
snake_case : int = slow_tokenizers
snake_case : Union[str, Any] = attr_name[:-9]
elif attr_name.endswith("""TokenizerFast""" ):
snake_case : Optional[Any] = fast_tokenizers
snake_case : Any = attr_name[:-13]
elif _re_tf_models.match(lowercase ) is not None:
snake_case : List[Any] = tf_models
snake_case : Union[str, Any] = _re_tf_models.match(lowercase ).groups()[0]
elif _re_flax_models.match(lowercase ) is not None:
snake_case : int = flax_models
snake_case : str = _re_flax_models.match(lowercase ).groups()[0]
elif _re_pt_models.match(lowercase ) is not None:
snake_case : Any = pt_models
snake_case : List[str] = _re_pt_models.match(lowercase ).groups()[0]
if lookup_dict is not None:
while len(lowercase ) > 0:
if attr_name in model_name_to_prefix.values():
snake_case : List[Any] = True
break
# Try again after removing the last word in the name
snake_case : int = """""".join(camel_case_split(lowercase )[:-1] )
# Let's build that table!
snake_case : Union[str, Any] = list(model_name_to_config.keys() )
model_names.sort(key=str.lower )
snake_case : List[Any] = ["""Model""", """Tokenizer slow""", """Tokenizer fast""", """PyTorch support""", """TensorFlow support""", """Flax Support"""]
# We'll need widths to properly display everything in the center (+2 is to leave one extra space on each side).
snake_case : Union[str, Any] = [len(lowercase ) + 2 for c in columns]
snake_case : str = max([len(lowercase ) for name in model_names] ) + 2
# Build the table per se
snake_case : Tuple = """|""" + """|""".join([_center_text(lowercase ,lowercase ) for c, w in zip(lowercase ,lowercase )] ) + """|\n"""
# Use ":-----:" format to center-aligned table cell texts
table += "|" + "|".join([""":""" + """-""" * (w - 2) + """:""" for w in widths] ) + "|\n"
snake_case : Optional[Any] = {True: """✅""", False: """❌"""}
for name in model_names:
snake_case : List[Any] = model_name_to_prefix[name]
snake_case : Any = [
name,
check[slow_tokenizers[prefix]],
check[fast_tokenizers[prefix]],
check[pt_models[prefix]],
check[tf_models[prefix]],
check[flax_models[prefix]],
]
table += "|" + "|".join([_center_text(lowercase ,lowercase ) for l, w in zip(lowercase ,lowercase )] ) + "|\n"
return table
def SCREAMING_SNAKE_CASE__ ( lowercase=False ) -> Dict:
snake_case , snake_case , snake_case , snake_case : List[Any] = _find_text_in_file(
filename=os.path.join(lowercase ,"""index.md""" ) ,start_prompt="""<!--This table is updated automatically from the auto modules""" ,end_prompt="""<!-- End table-->""" ,)
snake_case : List[Any] = get_model_table_from_auto_modules()
if current_table != new_table:
if overwrite:
with open(os.path.join(lowercase ,"""index.md""" ) ,"""w""" ,encoding="""utf-8""" ,newline="""\n""" ) as f:
f.writelines(lines[:start_index] + [new_table] + lines[end_index:] )
else:
raise ValueError(
"""The model table in the `index.md` has not been updated. Run `make fix-copies` to fix this.""" )
if __name__ == "__main__":
lowerCamelCase : List[str] = argparse.ArgumentParser()
parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
lowerCamelCase : Optional[int] = parser.parse_args()
check_model_table(args.fix_and_overwrite)
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : Optional[Any] = hex_num.strip()
if not hex_num:
raise ValueError("""No value was passed to the function""" )
snake_case : Any = hex_num[0] == """-"""
if is_negative:
snake_case : int = hex_num[1:]
try:
snake_case : List[Any] = int(lowercase ,16 )
except ValueError:
raise ValueError("""Invalid value was passed to the function""" )
snake_case : Dict = """"""
while int_num > 0:
snake_case : Dict = str(int_num % 2 ) + bin_str
int_num >>= 1
return int(("""-""" + bin_str) if is_negative else bin_str )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
from math import sqrt
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : Dict = 0
for i in range(1 ,int(sqrt(lowercase ) + 1 ) ):
if n % i == 0 and i != sqrt(lowercase ):
total += i + n // i
elif i == sqrt(lowercase ):
total += i
return total - n
def SCREAMING_SNAKE_CASE__ ( lowercase = 10000 ) -> int:
snake_case : Dict = sum(
i
for i in range(1 ,lowercase )
if sum_of_divisors(sum_of_divisors(lowercase ) ) == i and sum_of_divisors(lowercase ) != i )
return total
if __name__ == "__main__":
print(solution(int(str(input()).strip())))
| 684 |
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 : Optional[int] = logging.get_logger(__name__)
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""pixel_values"""]
def __init__( self , A = True , A = None , A = PIL.Image.BICUBIC , A = True , A = None , A = 1 / 2_5_5 , A = True , A = True , A = None , A = None , **A , ) -> None:
super().__init__(**A )
snake_case : int = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
snake_case : int = get_size_dict(A )
snake_case : Optional[Any] = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
snake_case : Dict = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = do_resize
snake_case : str = size
snake_case : Tuple = resample
snake_case : Any = do_center_crop
snake_case : Tuple = crop_size
snake_case : int = do_rescale
snake_case : Dict = rescale_factor
snake_case : Union[str, Any] = do_normalize
snake_case : Union[str, Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
snake_case : Optional[Any] = image_std if image_std is not None else IMAGENET_STANDARD_STD
def UpperCAmelCase ( self , A , A , A = PIL.Image.BICUBIC , A = None , **A , ) -> np.ndarray:
snake_case : Dict = get_size_dict(A )
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(
A , size=(size["""height"""], size["""width"""]) , resample=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> np.ndarray:
snake_case : Any = get_size_dict(A )
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(A , size=(size["""height"""], size["""width"""]) , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> Tuple:
return rescale(A , scale=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A , A = None , **A , ) -> np.ndarray:
return normalize(A , mean=A , std=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A = None , A = None , A=None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = ChannelDimension.FIRST , **A , ) -> PIL.Image.Image:
snake_case : str = do_resize if do_resize is not None else self.do_resize
snake_case : Dict = resample if resample is not None else self.resample
snake_case : Dict = do_center_crop if do_center_crop is not None else self.do_center_crop
snake_case : Tuple = do_rescale if do_rescale is not None else self.do_rescale
snake_case : Optional[Any] = rescale_factor if rescale_factor is not None else self.rescale_factor
snake_case : List[str] = do_normalize if do_normalize is not None else self.do_normalize
snake_case : int = image_mean if image_mean is not None else self.image_mean
snake_case : List[str] = image_std if image_std is not None else self.image_std
snake_case : Dict = size if size is not None else self.size
snake_case : Tuple = get_size_dict(A )
snake_case : Dict = crop_size if crop_size is not None else self.crop_size
snake_case : List[str] = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = make_list_of_images(A )
if not valid_images(A ):
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.
snake_case : Optional[Any] = [to_numpy_array(A ) for image in images]
if do_resize:
snake_case : Dict = [self.resize(image=A , size=A , resample=A ) for image in images]
if do_center_crop:
snake_case : List[str] = [self.center_crop(image=A , size=A ) for image in images]
if do_rescale:
snake_case : List[str] = [self.rescale(image=A , scale=A ) for image in images]
if do_normalize:
snake_case : str = [self.normalize(image=A , mean=A , std=A ) for image in images]
snake_case : Union[str, Any] = [to_channel_dimension_format(A , A ) for image in images]
snake_case : List[Any] = {"""pixel_values""": images}
return BatchFeature(data=A , tensor_type=A )
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
assert column_title.isupper()
snake_case : List[str] = 0
snake_case : Tuple = len(lowercase ) - 1
snake_case : Any = 0
while index >= 0:
snake_case : Optional[int] = (ord(column_title[index] ) - 64) * pow(26 ,lowercase )
answer += value
power += 1
index -= 1
return answer
if __name__ == "__main__":
from doctest import testmod
testmod()
| 684 |
import inspect
import unittest
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> List[Any]:
try:
import diffusers # noqa: F401
except ImportError:
assert False
def UpperCAmelCase ( self ) -> Tuple:
import diffusers
from diffusers.dependency_versions_table import deps
snake_case : List[str] = inspect.getmembers(A , inspect.isclass )
for cls_name, cls_module in all_classes:
if "dummy_" in cls_module.__module__:
for backend in cls_module._backends:
if backend == "k_diffusion":
snake_case : Tuple = """k-diffusion"""
elif backend == "invisible_watermark":
snake_case : Optional[int] = """invisible-watermark"""
assert backend in deps, f"""{backend} is not in the deps table!"""
| 684 | 1 |
import unittest
from transformers import MraConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
if is_torch_available():
import torch
from transformers import (
MraForMaskedLM,
MraForMultipleChoice,
MraForQuestionAnswering,
MraForSequenceClassification,
MraForTokenClassification,
MraModel,
)
from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST
class __lowercase :
"""simple docstring"""
def __init__( self , A , A=2 , A=8 , A=True , A=True , A=True , A=True , A=9_9 , A=1_6 , A=5 , A=2 , A=3_6 , A="gelu" , A=0.0 , A=0.0 , A=5_1_2 , A=1_6 , A=2 , A=0.02 , A=3 , A=4 , A=None , ) -> List[Any]:
snake_case : Optional[Any] = parent
snake_case : str = batch_size
snake_case : Optional[Any] = seq_length
snake_case : Optional[int] = is_training
snake_case : Dict = use_input_mask
snake_case : Union[str, Any] = use_token_type_ids
snake_case : Tuple = use_labels
snake_case : Any = vocab_size
snake_case : int = hidden_size
snake_case : List[str] = num_hidden_layers
snake_case : Optional[int] = num_attention_heads
snake_case : Any = intermediate_size
snake_case : Union[str, Any] = hidden_act
snake_case : Optional[int] = hidden_dropout_prob
snake_case : Any = attention_probs_dropout_prob
snake_case : List[Any] = max_position_embeddings
snake_case : int = type_vocab_size
snake_case : Dict = type_sequence_label_size
snake_case : Tuple = initializer_range
snake_case : Union[str, Any] = num_labels
snake_case : Optional[Any] = num_choices
snake_case : List[str] = scope
def UpperCAmelCase ( self ) -> str:
snake_case : int = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size )
snake_case : Optional[Any] = None
if self.use_input_mask:
snake_case : List[Any] = random_attention_mask([self.batch_size, self.seq_length] )
snake_case : List[str] = None
if self.use_token_type_ids:
snake_case : Optional[Any] = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size )
snake_case : str = None
snake_case : int = None
snake_case : Optional[int] = None
if self.use_labels:
snake_case : Optional[Any] = ids_tensor([self.batch_size] , self.type_sequence_label_size )
snake_case : List[Any] = ids_tensor([self.batch_size, self.seq_length] , self.num_labels )
snake_case : str = ids_tensor([self.batch_size] , self.num_choices )
snake_case : str = self.get_config()
return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
def UpperCAmelCase ( self ) -> List[Any]:
return MraConfig(
vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=A , initializer_range=self.initializer_range , )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : Optional[int] = self.get_config()
snake_case : Tuple = 3_0_0
return config
def UpperCAmelCase ( self ) -> Any:
(
(
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) ,
) : Union[str, Any] = self.prepare_config_and_inputs()
snake_case : Any = True
snake_case : Dict = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
snake_case : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 )
return (
config,
input_ids,
token_type_ids,
input_mask,
sequence_labels,
token_labels,
choice_labels,
encoder_hidden_states,
encoder_attention_mask,
)
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : Tuple = MraModel(config=A )
model.to(A )
model.eval()
snake_case : Tuple = model(A , attention_mask=A , token_type_ids=A )
snake_case : List[str] = model(A , token_type_ids=A )
snake_case : Tuple = model(A )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A , A , A , ) -> Optional[Any]:
snake_case : List[Any] = True
snake_case : Any = MraModel(A )
model.to(A )
model.eval()
snake_case : str = model(
A , attention_mask=A , token_type_ids=A , encoder_hidden_states=A , encoder_attention_mask=A , )
snake_case : str = model(
A , attention_mask=A , token_type_ids=A , encoder_hidden_states=A , )
snake_case : List[str] = model(A , attention_mask=A , token_type_ids=A )
self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Union[str, Any]:
snake_case : Union[str, Any] = MraForMaskedLM(config=A )
model.to(A )
model.eval()
snake_case : Dict = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Union[str, Any]:
snake_case : Tuple = MraForQuestionAnswering(config=A )
model.to(A )
model.eval()
snake_case : Any = model(
A , attention_mask=A , token_type_ids=A , start_positions=A , end_positions=A , )
self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) )
self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Any:
snake_case : Tuple = self.num_labels
snake_case : Any = MraForSequenceClassification(A )
model.to(A )
model.eval()
snake_case : List[Any] = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Tuple:
snake_case : List[str] = self.num_labels
snake_case : str = MraForTokenClassification(config=A )
model.to(A )
model.eval()
snake_case : Optional[int] = model(A , attention_mask=A , token_type_ids=A , labels=A )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) )
def UpperCAmelCase ( self , A , A , A , A , A , A , A ) -> Dict:
snake_case : List[Any] = self.num_choices
snake_case : str = MraForMultipleChoice(config=A )
model.to(A )
model.eval()
snake_case : Tuple = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : List[Any] = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : Any = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous()
snake_case : Any = model(
A , attention_mask=A , token_type_ids=A , labels=A , )
self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) )
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : Optional[Any] = self.prepare_config_and_inputs()
(
(
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) , (
snake_case
) ,
) : Dict = config_and_inputs
snake_case : List[Any] = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
return config, inputs_dict
@require_torch
class __lowercase (UpperCamelCase__ , unittest.TestCase ):
"""simple docstring"""
_snake_case = (
(
MraModel,
MraForMaskedLM,
MraForMultipleChoice,
MraForQuestionAnswering,
MraForSequenceClassification,
MraForTokenClassification,
)
if is_torch_available()
else ()
)
_snake_case = False
_snake_case = False
_snake_case = False
_snake_case = False
_snake_case = ()
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Union[str, Any] = MraModelTester(self )
snake_case : Optional[Any] = ConfigTester(self , config_class=A , hidden_size=3_7 )
def UpperCAmelCase ( self ) -> Dict:
self.config_tester.run_common_tests()
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_model(*A )
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : List[str] = self.model_tester.prepare_config_and_inputs()
for type in ["absolute", "relative_key", "relative_key_query"]:
snake_case : Dict = type
self.model_tester.create_and_check_model(*A )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_masked_lm(*A )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_multiple_choice(*A )
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_question_answering(*A )
def UpperCAmelCase ( self ) -> str:
snake_case : List[Any] = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_sequence_classification(*A )
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : str = self.model_tester.prepare_config_and_inputs()
self.model_tester.create_and_check_for_token_classification(*A )
@slow
def UpperCAmelCase ( self ) -> Optional[Any]:
for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
snake_case : Tuple = MraModel.from_pretrained(A )
self.assertIsNotNone(A )
@unittest.skip(reason="""MRA does not output attentions""" )
def UpperCAmelCase ( self ) -> Optional[Any]:
return
@require_torch
class __lowercase (unittest.TestCase ):
"""simple docstring"""
@slow
def UpperCAmelCase ( self ) -> Dict:
snake_case : List[str] = MraModel.from_pretrained("""uw-madison/mra-base-512-4""" )
snake_case : Optional[Any] = torch.arange(2_5_6 ).unsqueeze(0 )
with torch.no_grad():
snake_case : Optional[int] = model(A )[0]
snake_case : Any = torch.Size((1, 2_5_6, 7_6_8) )
self.assertEqual(output.shape , A )
snake_case : Any = torch.tensor(
[[[-0.01_40, 0.08_30, -0.03_81], [0.15_46, 0.14_02, 0.02_20], [0.11_62, 0.08_51, 0.01_65]]] )
self.assertTrue(torch.allclose(output[:, :3, :3] , A , atol=1e-4 ) )
@slow
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Optional[int] = MraForMaskedLM.from_pretrained("""uw-madison/mra-base-512-4""" )
snake_case : Optional[Any] = torch.arange(2_5_6 ).unsqueeze(0 )
with torch.no_grad():
snake_case : Dict = model(A )[0]
snake_case : List[str] = 5_0_2_6_5
snake_case : Union[str, Any] = torch.Size((1, 2_5_6, vocab_size) )
self.assertEqual(output.shape , A )
snake_case : str = torch.tensor(
[[[9.25_95, -3.60_38, 11.88_19], [9.38_69, -3.26_93, 11.09_56], [11.85_24, -3.49_38, 13.12_10]]] )
self.assertTrue(torch.allclose(output[:, :3, :3] , A , atol=1e-4 ) )
@slow
def UpperCAmelCase ( self ) -> int:
snake_case : List[Any] = MraForMaskedLM.from_pretrained("""uw-madison/mra-base-4096-8-d3""" )
snake_case : List[Any] = torch.arange(4_0_9_6 ).unsqueeze(0 )
with torch.no_grad():
snake_case : List[str] = model(A )[0]
snake_case : List[str] = 5_0_2_6_5
snake_case : int = torch.Size((1, 4_0_9_6, vocab_size) )
self.assertEqual(output.shape , A )
snake_case : Union[str, Any] = torch.tensor(
[[[5.47_89, -2.35_64, 7.50_64], [7.90_67, -1.33_69, 9.96_68], [9.07_12, -1.81_06, 7.03_80]]] )
self.assertTrue(torch.allclose(output[:, :3, :3] , A , atol=1e-4 ) )
| 684 |
import contextlib
import importlib
import io
import unittest
import transformers
# Try to import everything from transformers to ensure every object can be loaded.
from transformers import * # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available
if is_torch_available():
from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification
if is_tf_available():
from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification
if is_flax_available():
from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification
lowerCamelCase : Union[str, Any] = DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co
lowerCamelCase : List[Any] = 'main'
# Default branch name
lowerCamelCase : Tuple = 'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
lowerCamelCase : List[Any] = 'aaaaaaa'
# This commit does not exist, so we should 404.
lowerCamelCase : List[Any] = 'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
lowerCamelCase : int = '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> Optional[int]:
print("""Welcome!""" )
yield
print("""Bye!""" )
@contextlib.contextmanager
def SCREAMING_SNAKE_CASE__ ( ) -> List[str]:
print("""Bonjour!""" )
yield
print("""Au revoir!""" )
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> int:
# If the spec is missing, importlib would not be able to import the module dynamically.
assert transformers.__spec__ is not None
assert importlib.util.find_spec("""transformers""" ) is not None
class __lowercase (unittest.TestCase ):
"""simple docstring"""
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> Optional[Any]:
with ContextManagers([] ):
print("""Transformers are awesome!""" )
# The print statement adds a new line at the end of the output
self.assertEqual(mock_stdout.getvalue() , """Transformers are awesome!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Welcome!\nTransformers are awesome!\nBye!\n""" )
@unittest.mock.patch("""sys.stdout""" , new_callable=io.StringIO )
def UpperCAmelCase ( self , A ) -> int:
with ContextManagers([context_fr(), context_en()] ):
print("""Transformers are awesome!""" )
# The output should be wrapped with an English and French welcome and goodbye
self.assertEqual(mock_stdout.getvalue() , """Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n""" )
@require_torch
def UpperCAmelCase ( self ) -> Optional[Any]:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_tf
def UpperCAmelCase ( self ) -> str:
self.assertEqual(find_labels(A ) , ["""labels"""] )
self.assertEqual(find_labels(A ) , ["""labels""", """next_sentence_label"""] )
self.assertEqual(find_labels(A ) , ["""start_positions""", """end_positions"""] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , ["""labels"""] )
@require_flax
def UpperCAmelCase ( self ) -> Any:
# Flax models don't have labels
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
self.assertEqual(find_labels(A ) , [] )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
pass
self.assertEqual(find_labels(A ) , [] )
| 684 | 1 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Union[str, Any] = logging.get_logger(__name__)
lowerCamelCase : Tuple = {
'tanreinama/GPTSAN-2.8B-spout_is_uniform': (
'https://huggingface.co/tanreinama/GPTSAN-2.8B-spout_is_uniform/resolve/main/config.json'
),
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """gptsan-japanese"""
_snake_case = [
"""past_key_values""",
]
_snake_case = {
"""hidden_size""": """d_model""",
"""num_attention_heads""": """num_heads""",
"""num_hidden_layers""": """num_layers""",
}
def __init__( self , A=3_6_0_0_0 , A=1_2_8_0 , A=1_0_2_4 , A=8_1_9_2 , A=4_0_9_6 , A=1_2_8 , A=1_0 , A=0 , A=1_6 , A=1_6 , A=1_2_8 , A=0.0 , A=1e-5 , A=False , A=0.0 , A="float32" , A=False , A=False , A=False , A=0.0_02 , A=False , A=True , A=3_5_9_9_8 , A=3_5_9_9_5 , A=3_5_9_9_9 , **A , ) -> Any:
snake_case : Tuple = vocab_size
snake_case : List[Any] = max_position_embeddings
snake_case : Tuple = d_model
snake_case : Optional[Any] = d_ff
snake_case : List[Any] = d_ext
snake_case : str = d_spout
snake_case : List[Any] = num_switch_layers
snake_case : Tuple = num_ext_layers
snake_case : Optional[int] = num_switch_layers + num_ext_layers
snake_case : Any = num_heads
snake_case : Tuple = num_experts
snake_case : int = expert_capacity
snake_case : Optional[int] = dropout_rate
snake_case : int = layer_norm_epsilon
snake_case : List[Any] = router_bias
snake_case : Tuple = router_jitter_noise
snake_case : Optional[Any] = router_dtype
snake_case : Optional[Any] = router_ignore_padding_tokens
snake_case : str = output_hidden_states
snake_case : Tuple = output_attentions
snake_case : Optional[Any] = initializer_factor
snake_case : List[Any] = output_router_logits
snake_case : Any = use_cache
super().__init__(
separator_token_id=A , pad_token_id=A , eos_token_id=A , **A , )
| 684 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Optional[Any] = logging.get_logger(__name__)
lowerCamelCase : Dict = {
'MIT/ast-finetuned-audioset-10-10-0.4593': (
'https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json'
),
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """audio-spectrogram-transformer"""
def __init__( self , A=7_6_8 , A=1_2 , A=1_2 , A=3_0_7_2 , A="gelu" , A=0.0 , A=0.0 , A=0.02 , A=1e-1_2 , A=1_6 , A=True , A=1_0 , A=1_0 , A=1_0_2_4 , A=1_2_8 , **A , ) -> int:
super().__init__(**A )
snake_case : Any = hidden_size
snake_case : Tuple = num_hidden_layers
snake_case : Any = num_attention_heads
snake_case : Dict = intermediate_size
snake_case : int = hidden_act
snake_case : int = hidden_dropout_prob
snake_case : Tuple = attention_probs_dropout_prob
snake_case : int = initializer_range
snake_case : int = layer_norm_eps
snake_case : Any = patch_size
snake_case : List[Any] = qkv_bias
snake_case : int = frequency_stride
snake_case : Any = time_stride
snake_case : Union[str, Any] = max_length
snake_case : Any = num_mel_bins
| 684 | 1 |
from collections.abc import Callable
class __lowercase :
"""simple docstring"""
def __init__( self , A = None ) -> None:
# Stores actual heap items.
snake_case : list = []
# Stores indexes of each item for supporting updates and deletion.
snake_case : dict = {}
# Stores current size of heap.
snake_case : Union[str, Any] = 0
# Stores function used to evaluate the score of an item on which basis ordering
# will be done.
snake_case : Any = key or (lambda A : x)
def UpperCAmelCase ( self , A ) -> int | None:
return int((i - 1) / 2 ) if i > 0 else None
def UpperCAmelCase ( self , A ) -> int | None:
snake_case : List[Any] = int(2 * i + 1 )
return left if 0 < left < self.size else None
def UpperCAmelCase ( self , A ) -> int | None:
snake_case : Union[str, Any] = int(2 * i + 2 )
return right if 0 < right < self.size else None
def UpperCAmelCase ( self , A , A ) -> None:
snake_case , snake_case : Optional[Any] = (
self.pos_map[self.arr[j][0]],
self.pos_map[self.arr[i][0]],
)
# Then swap the items in the list.
snake_case , snake_case : List[Any] = self.arr[j], self.arr[i]
def UpperCAmelCase ( self , A , A ) -> bool:
return self.arr[i][1] < self.arr[j][1]
def UpperCAmelCase ( self , A ) -> int:
snake_case : Dict = self._left(A )
snake_case : Optional[Any] = self._right(A )
snake_case : str = i
if left is not None and not self._cmp(A , A ):
snake_case : str = left
if right is not None and not self._cmp(A , A ):
snake_case : Optional[Any] = right
return valid_parent
def UpperCAmelCase ( self , A ) -> None:
snake_case : List[Any] = self._parent(A )
while parent is not None and not self._cmp(A , A ):
self._swap(A , A )
snake_case , snake_case : Optional[Any] = parent, self._parent(A )
def UpperCAmelCase ( self , A ) -> None:
snake_case : Any = self._get_valid_parent(A )
while valid_parent != index:
self._swap(A , A )
snake_case , snake_case : Union[str, Any] = valid_parent, self._get_valid_parent(A )
def UpperCAmelCase ( self , A , A ) -> None:
if item not in self.pos_map:
return
snake_case : Dict = self.pos_map[item]
snake_case : Tuple = [item, self.key(A )]
# Make sure heap is right in both up and down direction.
# Ideally only one of them will make any change.
self._heapify_up(A )
self._heapify_down(A )
def UpperCAmelCase ( self , A ) -> None:
if item not in self.pos_map:
return
snake_case : Optional[int] = self.pos_map[item]
del self.pos_map[item]
snake_case : int = self.arr[self.size - 1]
snake_case : List[Any] = index
self.size -= 1
# Make sure heap is right in both up and down direction. Ideally only one
# of them will make any change- so no performance loss in calling both.
if self.size > index:
self._heapify_up(A )
self._heapify_down(A )
def UpperCAmelCase ( self , A , A ) -> None:
snake_case : Union[str, Any] = len(self.arr )
if arr_len == self.size:
self.arr.append([item, self.key(A )] )
else:
snake_case : List[Any] = [item, self.key(A )]
snake_case : List[Any] = self.size
self.size += 1
self._heapify_up(self.size - 1 )
def UpperCAmelCase ( self ) -> tuple | None:
return self.arr[0] if self.size else None
def UpperCAmelCase ( self ) -> tuple | None:
snake_case : int = self.get_top()
if top_item_tuple:
self.delete_item(top_item_tuple[0] )
return top_item_tuple
def SCREAMING_SNAKE_CASE__ ( ) -> None:
pass
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 |
import enum
import warnings
from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline
if is_tf_available():
import tensorflow as tf
from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
if is_torch_available():
from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
lowerCamelCase : Any = logging.get_logger(__name__)
class __lowercase (enum.Enum ):
"""simple docstring"""
_snake_case = 0
_snake_case = 1
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """generated"""
def __init__( self , *A , **A ) -> Optional[Any]:
super().__init__(*A , **A )
self.check_model_type(
TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
if self.framework == """tf"""
else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING )
def UpperCAmelCase ( self , A=None , A=None , A=None , A=None , A=None , A=None , **A , ) -> Optional[int]:
snake_case : Tuple = {}
if truncation is not None:
snake_case : Union[str, Any] = truncation
snake_case : Dict = generate_kwargs
snake_case : int = {}
if return_tensors is not None and return_type is None:
snake_case : List[Any] = ReturnType.TENSORS if return_tensors else ReturnType.TEXT
if return_type is not None:
snake_case : List[str] = return_type
if clean_up_tokenization_spaces is not None:
snake_case : int = clean_up_tokenization_spaces
if stop_sequence is not None:
snake_case : Tuple = self.tokenizer.encode(A , add_special_tokens=A )
if len(A ) > 1:
warnings.warn(
"""Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
""" the stop sequence will be used as the stop sequence string in the interim.""" )
snake_case : List[str] = stop_sequence_ids[0]
return preprocess_params, forward_params, postprocess_params
def UpperCAmelCase ( self , A , A , A ) -> Union[str, Any]:
return True
def UpperCAmelCase ( self , *A , A ) -> Tuple:
snake_case : Union[str, Any] = self.model.config.prefix if self.model.config.prefix is not None else """"""
if isinstance(args[0] , A ):
if self.tokenizer.pad_token_id is None:
raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" )
snake_case : Union[str, Any] = ([prefix + arg for arg in args[0]],)
snake_case : List[Any] = True
elif isinstance(args[0] , A ):
snake_case : str = (prefix + args[0],)
snake_case : str = False
else:
raise ValueError(
f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" )
snake_case : Optional[Any] = self.tokenizer(*A , padding=A , truncation=A , return_tensors=self.framework )
# This is produced by tokenizers but is an invalid generate kwargs
if "token_type_ids" in inputs:
del inputs["token_type_ids"]
return inputs
def __call__( self , *A , **A ) -> Union[str, Any]:
snake_case : Tuple = super().__call__(*A , **A )
if (
isinstance(args[0] , A )
and all(isinstance(A , A ) for el in args[0] )
and all(len(A ) == 1 for res in result )
):
return [res[0] for res in result]
return result
def UpperCAmelCase ( self , A , A=TruncationStrategy.DO_NOT_TRUNCATE , **A ) -> str:
snake_case : Optional[Any] = self._parse_and_tokenize(A , truncation=A , **A )
return inputs
def UpperCAmelCase ( self , A , **A ) -> Tuple:
if self.framework == "pt":
snake_case , snake_case : List[str] = model_inputs["""input_ids"""].shape
elif self.framework == "tf":
snake_case , snake_case : Optional[Any] = tf.shape(model_inputs["""input_ids"""] ).numpy()
snake_case : Dict = generate_kwargs.get("""min_length""" , self.model.config.min_length )
snake_case : str = generate_kwargs.get("""max_length""" , self.model.config.max_length )
self.check_inputs(A , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] )
snake_case : List[str] = self.model.generate(**A , **A )
snake_case : Dict = output_ids.shape[0]
if self.framework == "pt":
snake_case : List[Any] = output_ids.reshape(A , out_b // in_b , *output_ids.shape[1:] )
elif self.framework == "tf":
snake_case : Any = tf.reshape(A , (in_b, out_b // in_b, *output_ids.shape[1:]) )
return {"output_ids": output_ids}
def UpperCAmelCase ( self , A , A=ReturnType.TEXT , A=False ) -> Union[str, Any]:
snake_case : Tuple = []
for output_ids in model_outputs["output_ids"][0]:
if return_type == ReturnType.TENSORS:
snake_case : Dict = {f"""{self.return_name}_token_ids""": output_ids}
elif return_type == ReturnType.TEXT:
snake_case : int = {
f"""{self.return_name}_text""": self.tokenizer.decode(
A , skip_special_tokens=A , clean_up_tokenization_spaces=A , )
}
records.append(A )
return records
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """summary"""
def __call__( self , *A , **A ) -> str:
return super().__call__(*A , **A )
def UpperCAmelCase ( self , A , A , A ) -> bool:
if max_length < min_length:
logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" )
if input_length < max_length:
logger.warning(
f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """
"""a summarization task, where outputs shorter than the input are typically wanted, you might """
f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" )
@add_end_docstrings(UpperCamelCase__ )
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """translation"""
def UpperCAmelCase ( self , A , A , A ) -> Union[str, Any]:
if input_length > 0.9 * max_length:
logger.warning(
f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """
"""increasing your max_length manually, e.g. translator('...', max_length=400)""" )
return True
def UpperCAmelCase ( self , *A , A=TruncationStrategy.DO_NOT_TRUNCATE , A=None , A=None ) -> Optional[int]:
if getattr(self.tokenizer , """_build_translation_inputs""" , A ):
return self.tokenizer._build_translation_inputs(
*A , return_tensors=self.framework , truncation=A , src_lang=A , tgt_lang=A )
else:
return super()._parse_and_tokenize(*A , truncation=A )
def UpperCAmelCase ( self , A=None , A=None , **A ) -> Union[str, Any]:
snake_case , snake_case , snake_case : str = super()._sanitize_parameters(**A )
if src_lang is not None:
snake_case : Tuple = src_lang
if tgt_lang is not None:
snake_case : str = tgt_lang
if src_lang is None and tgt_lang is None:
# Backward compatibility, direct arguments use is preferred.
snake_case : Union[str, Any] = kwargs.get("""task""" , self.task )
snake_case : Any = task.split("""_""" )
if task and len(A ) == 4:
# translation, XX, to YY
snake_case : Optional[Any] = items[1]
snake_case : Dict = items[3]
return preprocess_params, forward_params, postprocess_params
def __call__( self , *A , **A ) -> str:
return super().__call__(*A , **A )
| 684 | 1 |
import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch
import numpy as np
import pytest
from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex
from .utils import require_elasticsearch, require_faiss
lowerCamelCase : Optional[int] = pytest.mark.integration
@require_faiss
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : List[str] = Dataset.from_dict({"""filename""": ["""my_name-train""" + """_""" + str(A ) for x in np.arange(3_0 ).tolist()]} )
return dset
def UpperCAmelCase ( self ) -> Any:
import faiss
snake_case : Dataset = self._create_dummy_dataset()
snake_case : Optional[int] = dset.map(
lambda A , A : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=A , keep_in_memory=A )
snake_case : Tuple = dset.add_faiss_index("""vecs""" , batch_size=1_0_0 , metric_type=faiss.METRIC_INNER_PRODUCT )
snake_case , snake_case : Optional[int] = dset.get_nearest_examples("""vecs""" , np.ones(5 , dtype=np.floataa ) )
self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" )
dset.drop_index("""vecs""" )
def UpperCAmelCase ( self ) -> List[Any]:
import faiss
snake_case : Dataset = self._create_dummy_dataset()
dset.add_faiss_index_from_external_arrays(
external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 , 1 ) , index_name="""vecs""" , batch_size=1_0_0 , metric_type=faiss.METRIC_INNER_PRODUCT , )
snake_case , snake_case : List[str] = dset.get_nearest_examples("""vecs""" , np.ones(5 , dtype=np.floataa ) )
self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" )
def UpperCAmelCase ( self ) -> Any:
import faiss
snake_case : Dataset = self._create_dummy_dataset()
dset.add_faiss_index_from_external_arrays(
external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 , 1 ) , index_name="""vecs""" , metric_type=faiss.METRIC_INNER_PRODUCT , )
# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
# see https://bugs.python.org/issue14243 and
# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
with tempfile.NamedTemporaryFile(delete=A ) as tmp_file:
dset.save_faiss_index("""vecs""" , tmp_file.name )
dset.load_faiss_index("""vecs2""" , tmp_file.name )
os.unlink(tmp_file.name )
snake_case , snake_case : Any = dset.get_nearest_examples("""vecs2""" , np.ones(5 , dtype=np.floataa ) )
self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" )
def UpperCAmelCase ( self ) -> List[str]:
snake_case : Dataset = self._create_dummy_dataset()
dset.add_faiss_index_from_external_arrays(
external_arrays=np.ones((3_0, 5) ) * np.arange(3_0 ).reshape(-1 , 1 ) , index_name="""vecs""" )
dset.drop_index("""vecs""" )
self.assertRaises(A , partial(dset.get_nearest_examples , """vecs2""" , np.ones(5 , dtype=np.floataa ) ) )
def UpperCAmelCase ( self ) -> Any:
from elasticsearch import Elasticsearch
snake_case : Dataset = self._create_dummy_dataset()
with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch(
"""elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk:
snake_case : int = {"""acknowledged""": True}
mocked_bulk.return_value([(True, None)] * 3_0 )
snake_case : List[str] = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 2_9}]}}
snake_case : Dict = Elasticsearch()
dset.add_elasticsearch_index("""filename""" , es_client=A )
snake_case , snake_case : Optional[int] = dset.get_nearest_examples("""filename""" , """my_name-train_29""" )
self.assertEqual(examples["""filename"""][0] , """my_name-train_29""" )
@require_faiss
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> Any:
import faiss
snake_case : str = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )
# add vectors
index.add_vectors(np.eye(5 , dtype=np.floataa ) )
self.assertIsNotNone(index.faiss_index )
self.assertEqual(index.faiss_index.ntotal , 5 )
index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) )
self.assertEqual(index.faiss_index.ntotal , 1_0 )
# single query
snake_case : Any = np.zeros(5 , dtype=np.floataa )
snake_case : List[str] = 1
snake_case , snake_case : int = index.search(A )
self.assertRaises(A , index.search , query.reshape(-1 , 1 ) )
self.assertGreater(scores[0] , 0 )
self.assertEqual(indices[0] , 1 )
# batched queries
snake_case : Union[str, Any] = np.eye(5 , dtype=np.floataa )[::-1]
snake_case , snake_case : List[Any] = index.search_batch(A )
self.assertRaises(A , index.search_batch , queries[0] )
snake_case : Tuple = [scores[0] for scores in total_scores]
snake_case : List[Any] = [indices[0] for indices in total_indices]
self.assertGreater(np.min(A ) , 0 )
self.assertListEqual([4, 3, 2, 1, 0] , A )
def UpperCAmelCase ( self ) -> Tuple:
import faiss
snake_case : List[str] = FaissIndex(string_factory="""Flat""" )
index.add_vectors(np.eye(5 , dtype=np.floataa ) )
self.assertIsInstance(index.faiss_index , faiss.IndexFlat )
snake_case : List[Any] = FaissIndex(string_factory="""LSH""" )
index.add_vectors(np.eye(5 , dtype=np.floataa ) )
self.assertIsInstance(index.faiss_index , faiss.IndexLSH )
with self.assertRaises(A ):
snake_case : Tuple = FaissIndex(string_factory="""Flat""" , custom_index=faiss.IndexFlat(5 ) )
def UpperCAmelCase ( self ) -> Any:
import faiss
snake_case : Optional[Any] = faiss.IndexFlat(5 )
snake_case : Any = FaissIndex(custom_index=A )
index.add_vectors(np.eye(5 , dtype=np.floataa ) )
self.assertIsInstance(index.faiss_index , faiss.IndexFlat )
def UpperCAmelCase ( self ) -> List[Any]:
import faiss
snake_case : Optional[Any] = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )
index.add_vectors(np.eye(5 , dtype=np.floataa ) )
# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
# see https://bugs.python.org/issue14243 and
# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
with tempfile.NamedTemporaryFile(delete=A ) as tmp_file:
index.save(tmp_file.name )
snake_case : Dict = FaissIndex.load(tmp_file.name )
os.unlink(tmp_file.name )
snake_case : Tuple = np.zeros(5 , dtype=np.floataa )
snake_case : Optional[int] = 1
snake_case , snake_case : List[Any] = index.search(A )
self.assertGreater(scores[0] , 0 )
self.assertEqual(indices[0] , 1 )
@require_faiss
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> Any:
import faiss
snake_case : Optional[Any] = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )
index.add_vectors(np.eye(5 ,dtype=np.floataa ) )
snake_case : int = """index.faiss"""
snake_case : int = f"""mock://{index_name}"""
index.save(lowercase ,storage_options=mockfs.storage_options )
snake_case : Dict = FaissIndex.load(lowercase ,storage_options=mockfs.storage_options )
snake_case : Dict = np.zeros(5 ,dtype=np.floataa )
snake_case : str = 1
snake_case , snake_case : Optional[Any] = index.search(lowercase )
assert scores[0] > 0
assert indices[0] == 1
@require_elasticsearch
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> str:
from elasticsearch import Elasticsearch
with patch("""elasticsearch.Elasticsearch.search""" ) as mocked_search, patch(
"""elasticsearch.client.IndicesClient.create""" ) as mocked_index_create, patch("""elasticsearch.helpers.streaming_bulk""" ) as mocked_bulk:
snake_case : Dict = Elasticsearch()
snake_case : Tuple = {"""acknowledged""": True}
snake_case : int = ElasticSearchIndex(es_client=A )
mocked_bulk.return_value([(True, None)] * 3 )
index.add_documents(["""foo""", """bar""", """foobar"""] )
# single query
snake_case : Optional[int] = """foo"""
snake_case : Tuple = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
snake_case , snake_case : Tuple = index.search(A )
self.assertEqual(scores[0] , 1 )
self.assertEqual(indices[0] , 0 )
# single query with timeout
snake_case : List[Any] = """foo"""
snake_case : Dict = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 0}]}}
snake_case , snake_case : Any = index.search(A , request_timeout=3_0 )
self.assertEqual(scores[0] , 1 )
self.assertEqual(indices[0] , 0 )
# batched queries
snake_case : Tuple = ["""foo""", """bar""", """foobar"""]
snake_case : Optional[Any] = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
snake_case , snake_case : Any = index.search_batch(A )
snake_case : List[Any] = [scores[0] for scores in total_scores]
snake_case : int = [indices[0] for indices in total_indices]
self.assertGreater(np.min(A ) , 0 )
self.assertListEqual([1, 1, 1] , A )
# batched queries with timeout
snake_case : Optional[Any] = ["""foo""", """bar""", """foobar"""]
snake_case : int = {"""hits""": {"""hits""": [{"""_score""": 1, """_id""": 1}]}}
snake_case , snake_case : Union[str, Any] = index.search_batch(A , request_timeout=3_0 )
snake_case : int = [scores[0] for scores in total_scores]
snake_case : Optional[Any] = [indices[0] for indices in total_indices]
self.assertGreater(np.min(A ) , 0 )
self.assertListEqual([1, 1, 1] , A )
| 684 |
import inspect
import re
from hashlib import shaaaa
from typing import Dict, List
from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql # noqa F401
from .text import text
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> str:
snake_case : int = []
for line in lines:
snake_case : Dict = re.sub(R"""#.*""" ,"""""" ,lowercase ) # remove comments
if line:
filtered_lines.append(lowercase )
snake_case : Optional[int] = """\n""".join(lowercase )
# Make a hash from all this code
snake_case : List[str] = full_str.encode("""utf-8""" )
return shaaaa(lowercase ).hexdigest()
# get importable module names and hash for caching
lowerCamelCase : Any = {
'csv': (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
'json': (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
'pandas': (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
'parquet': (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
'arrow': (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
'text': (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
'imagefolder': (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
'audiofolder': (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}
# Used to infer the module to use based on the data files extensions
lowerCamelCase : Optional[int] = {
'.csv': ('csv', {}),
'.tsv': ('csv', {'sep': '\t'}),
'.json': ('json', {}),
'.jsonl': ('json', {}),
'.parquet': ('parquet', {}),
'.arrow': ('arrow', {}),
'.txt': ('text', {}),
}
_EXTENSION_TO_MODULE.update({ext: ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
lowerCamelCase : Tuple = {'imagefolder', 'audiofolder'}
# Used to filter data files based on extensions given a module name
lowerCamelCase : Dict[str, List[str]] = {}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
_MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)
_MODULE_TO_EXTENSIONS["imagefolder"].append('.zip')
_MODULE_TO_EXTENSIONS["audiofolder"].append('.zip')
| 684 | 1 |
lowerCamelCase : List[Any] = [sum(int(c, 1_0) ** 2 for c in i.__str__()) for i in range(1_0_0_0_0_0)]
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : List[str] = 0
while number:
# Increased Speed Slightly by checking every 5 digits together.
sum_of_digits_squared += DIGITS_SQUARED[number % 100000]
number //= 100000
return sum_of_digits_squared
# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.
# The other one ends with 1 and has only one element 1.
# So 58 and 1 are chosen to be declared at the starting.
# Changed dictionary to an array to quicken the solution
lowerCamelCase : list[bool | None] = [None] * 1_0_0_0_0_0_0_0
lowerCamelCase : Union[str, Any] = True
lowerCamelCase : Tuple = False
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> bool:
if CHAINS[number - 1] is not None:
return CHAINS[number - 1] # type: ignore
snake_case : Optional[int] = chain(next_number(lowercase ) )
snake_case : Tuple = number_chain
while number < 10000000:
snake_case : List[Any] = number_chain
number *= 10
return number_chain
def SCREAMING_SNAKE_CASE__ ( lowercase = 10000000 ) -> int:
for i in range(1 ,lowercase ):
if CHAINS[i] is None:
chain(i + 1 )
return CHAINS[:number].count(lowercase )
if __name__ == "__main__":
import doctest
doctest.testmod()
print(f"""{solution() = }""")
| 684 |
import argparse
import torch
from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging
logging.set_verbosity_info()
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> Tuple:
# Initialise PyTorch model
snake_case : int = RemBertConfig.from_json_file(lowercase )
print("""Building PyTorch model from configuration: {}""".format(str(lowercase ) ) )
snake_case : Tuple = RemBertModel(lowercase )
# Load weights from tf checkpoint
load_tf_weights_in_rembert(lowercase ,lowercase ,lowercase )
# Save pytorch-model
print("""Save PyTorch model to {}""".format(lowercase ) )
torch.save(model.state_dict() ,lowercase )
if __name__ == "__main__":
lowerCamelCase : str = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
'--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
)
parser.add_argument(
'--rembert_config_file',
default=None,
type=str,
required=True,
help=(
'The config json file corresponding to the pre-trained RemBERT model. \n'
'This specifies the model architecture.'
),
)
parser.add_argument(
'--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
)
lowerCamelCase : Dict = parser.parse_args()
convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)
| 684 | 1 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> tuple[float, float]:
# Check if the input is valid
if not len(lowercase ) == len(lowercase ) == 3:
raise ValueError("""Please enter a valid equation.""" )
if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
raise ValueError("""Both a & b of two equations can't be zero.""" )
# Extract the coefficients
snake_case , snake_case , snake_case : Union[str, Any] = equationa
snake_case , snake_case , snake_case : Any = equationa
# Calculate the determinants of the matrices
snake_case : Dict = aa * ba - aa * ba
snake_case : Dict = ca * ba - ca * ba
snake_case : List[str] = aa * ca - aa * ca
# Check if the system of linear equations has a solution (using Cramer's rule)
if determinant == 0:
if determinant_x == determinant_y == 0:
raise ValueError("""Infinite solutions. (Consistent system)""" )
else:
raise ValueError("""No solution. (Inconsistent system)""" )
else:
if determinant_x == determinant_y == 0:
# Trivial solution (Inconsistent system)
return (0.0, 0.0)
else:
snake_case : Any = determinant_x / determinant
snake_case : Any = determinant_y / determinant
# Non-Trivial Solution (Consistent system)
return (x, y)
| 684 |
from ..utils import DummyObject, requires_backends
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[str]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Any:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[int]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> str:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Union[str, Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> List[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Any:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> int:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Dict:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Dict:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[int]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[Any]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> str:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> List[Any]:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Optional[int]:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Optional[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Tuple:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> List[Any]:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> str:
requires_backends(cls , ["""flax"""] )
class __lowercase (metaclass=UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""flax"""]
def __init__( self , *A , **A ) -> Tuple:
requires_backends(self , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Dict:
requires_backends(cls , ["""flax"""] )
@classmethod
def UpperCAmelCase ( cls , *A , **A ) -> Union[str, Any]:
requires_backends(cls , ["""flax"""] )
| 684 | 1 |
import json
from typing import TYPE_CHECKING, List, Optional, Tuple
from tokenizers import pre_tokenizers, processors
from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_blenderbot import BlenderbotTokenizer
if TYPE_CHECKING:
from transformers.pipelines.conversational import Conversation
lowerCamelCase : Dict = logging.get_logger(__name__)
lowerCamelCase : int = {
'vocab_file': 'vocab.json',
'merges_file': 'merges.txt',
'tokenizer_config_file': 'tokenizer_config.json',
}
lowerCamelCase : Tuple = {
'vocab_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json'},
'merges_file': {'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt'},
'tokenizer_config_file': {
'facebook/blenderbot-3B': 'https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json'
},
}
lowerCamelCase : Tuple = {'facebook/blenderbot-3B': 1_2_8}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
_snake_case = BlenderbotTokenizer
def __init__( self , A=None , A=None , A=None , A="replace" , A="<s>" , A="</s>" , A="</s>" , A="<s>" , A="<unk>" , A="<pad>" , A="<mask>" , A=False , A=True , **A , ) -> Any:
super().__init__(
A , A , tokenizer_file=A , errors=A , bos_token=A , eos_token=A , sep_token=A , cls_token=A , unk_token=A , pad_token=A , mask_token=A , add_prefix_space=A , trim_offsets=A , **A , )
snake_case : Dict = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() )
if pre_tok_state.get("""add_prefix_space""" , A ) != add_prefix_space:
snake_case : Optional[int] = getattr(A , pre_tok_state.pop("""type""" ) )
snake_case : Dict = add_prefix_space
snake_case : List[str] = pre_tok_class(**A )
snake_case : Any = add_prefix_space
snake_case : List[str] = """post_processor"""
snake_case : Union[str, Any] = getattr(self.backend_tokenizer , A , A )
if tokenizer_component_instance:
snake_case : str = json.loads(tokenizer_component_instance.__getstate__() )
# The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
if "sep" in state:
snake_case : Union[str, Any] = tuple(state["""sep"""] )
if "cls" in state:
snake_case : int = tuple(state["""cls"""] )
snake_case : List[Any] = False
if state.get("""add_prefix_space""" , A ) != add_prefix_space:
snake_case : str = add_prefix_space
snake_case : int = True
if state.get("""trim_offsets""" , A ) != trim_offsets:
snake_case : Dict = trim_offsets
snake_case : Union[str, Any] = True
if changes_to_apply:
snake_case : List[str] = getattr(A , state.pop("""type""" ) )
snake_case : Any = component_class(**A )
setattr(self.backend_tokenizer , A , A )
@property
# Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot
def UpperCAmelCase ( self ) -> str:
if self._mask_token is None:
if self.verbose:
logger.error("""Using mask_token, but it is not set yet.""" )
return None
return str(self._mask_token )
@mask_token.setter
def UpperCAmelCase ( self , A ) -> Any:
snake_case : List[Any] = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else value
snake_case : str = value
def UpperCAmelCase ( self , *A , **A ) -> BatchEncoding:
snake_case : Optional[int] = kwargs.get("""is_split_into_words""" , A )
assert self.add_prefix_space or not is_split_into_words, (
f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
"to use it with pretokenized inputs."
)
return super()._batch_encode_plus(*A , **A )
def UpperCAmelCase ( self , *A , **A ) -> BatchEncoding:
snake_case : List[Any] = kwargs.get("""is_split_into_words""" , A )
assert self.add_prefix_space or not is_split_into_words, (
f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
"to use it with pretokenized inputs."
)
return super()._encode_plus(*A , **A )
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
snake_case : Union[str, Any] = self._tokenizer.model.save(A , name=A )
return tuple(A )
def UpperCAmelCase ( self , A , A = None ) -> List[int]:
snake_case : Union[str, Any] = [self.sep_token_id]
snake_case : Optional[Any] = [self.cls_token_id]
if token_ids_a is None:
return len(cls + token_ids_a + sep ) * [0]
return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
def UpperCAmelCase ( self , A , A = None ) -> List[str]:
return token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A ) -> List[int]:
snake_case : Union[str, Any] = []
for is_user, text in conversation.iter_texts():
if is_user:
# We need to space prefix as it's being done within blenderbot
inputs.append(""" """ + text )
else:
# Generated responses should contain them already.
inputs.append(A )
snake_case : int = """ """.join(A )
snake_case : Any = self.encode(A )
if len(A ) > self.model_max_length:
snake_case : str = input_ids[-self.model_max_length :]
logger.warning(f"""Trimmed input from conversation as it was longer than {self.model_max_length} tokens.""" )
return input_ids
| 684 |
import os
import random
import sys
from . import cryptomath_module as cryptomath
from . import rabin_miller
lowerCamelCase : List[str] = 3
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
print("""Generating primitive root of p""" )
while True:
snake_case : Optional[int] = random.randrange(3 ,lowercase )
if pow(lowercase ,2 ,lowercase ) == 1:
continue
if pow(lowercase ,lowercase ,lowercase ) == 1:
continue
return g
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> tuple[tuple[int, int, int, int], tuple[int, int]]:
print("""Generating prime p...""" )
snake_case : Optional[int] = rabin_miller.generate_large_prime(lowercase ) # select large prime number.
snake_case : Optional[int] = primitive_root(lowercase ) # one primitive root on modulo p.
snake_case : Optional[Any] = random.randrange(3 ,lowercase ) # private_key -> have to be greater than 2 for safety.
snake_case : Tuple = cryptomath.find_mod_inverse(pow(lowercase ,lowercase ,lowercase ) ,lowercase )
snake_case : str = (key_size, e_a, e_a, p)
snake_case : Optional[Any] = (key_size, d)
return public_key, private_key
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> None:
if os.path.exists(f"""{name}_pubkey.txt""" ) or os.path.exists(f"""{name}_privkey.txt""" ):
print("""\nWARNING:""" )
print(
f"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
"""Use a different name or delete these files and re-run this program.""" )
sys.exit()
snake_case , snake_case : Optional[Any] = generate_key(lowercase )
print(f"""\nWriting public key to file {name}_pubkey.txt...""" )
with open(f"""{name}_pubkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}""" )
print(f"""Writing private key to file {name}_privkey.txt...""" )
with open(f"""{name}_privkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{private_key[0]},{private_key[1]}""" )
def SCREAMING_SNAKE_CASE__ ( ) -> None:
print("""Making key files...""" )
make_key_files("""elgamal""" ,2048 )
print("""Key files generation successful""" )
if __name__ == "__main__":
main()
| 684 | 1 |
import inspect
import re
from hashlib import shaaaa
from typing import Dict, List
from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql # noqa F401
from .text import text
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> str:
snake_case : int = []
for line in lines:
snake_case : Dict = re.sub(R"""#.*""" ,"""""" ,lowercase ) # remove comments
if line:
filtered_lines.append(lowercase )
snake_case : Optional[int] = """\n""".join(lowercase )
# Make a hash from all this code
snake_case : List[str] = full_str.encode("""utf-8""" )
return shaaaa(lowercase ).hexdigest()
# get importable module names and hash for caching
lowerCamelCase : Any = {
'csv': (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
'json': (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
'pandas': (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
'parquet': (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
'arrow': (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
'text': (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
'imagefolder': (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
'audiofolder': (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}
# Used to infer the module to use based on the data files extensions
lowerCamelCase : Optional[int] = {
'.csv': ('csv', {}),
'.tsv': ('csv', {'sep': '\t'}),
'.json': ('json', {}),
'.jsonl': ('json', {}),
'.parquet': ('parquet', {}),
'.arrow': ('arrow', {}),
'.txt': ('text', {}),
}
_EXTENSION_TO_MODULE.update({ext: ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('imagefolder', {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ('audiofolder', {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
lowerCamelCase : Tuple = {'imagefolder', 'audiofolder'}
# Used to filter data files based on extensions given a module name
lowerCamelCase : Dict[str, List[str]] = {}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
_MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)
_MODULE_TO_EXTENSIONS["imagefolder"].append('.zip')
_MODULE_TO_EXTENSIONS["audiofolder"].append('.zip')
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> int:
if exponent == 1:
return base
if exponent % 2 == 0:
snake_case : Dict = _modexpt(lowercase ,exponent // 2 ,lowercase ) % modulo_value
return (x * x) % modulo_value
else:
return (base * _modexpt(lowercase ,exponent - 1 ,lowercase )) % modulo_value
def SCREAMING_SNAKE_CASE__ ( lowercase = 1777 ,lowercase = 1855 ,lowercase = 8 ) -> int:
snake_case : int = base
for _ in range(1 ,lowercase ):
snake_case : List[str] = _modexpt(lowercase ,lowercase ,10**digits )
return result
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 | 1 |
import argparse
import re
import torch
from CLAP import create_model
from transformers import AutoFeatureExtractor, ClapConfig, ClapModel
lowerCamelCase : Dict = {
'text_branch': 'text_model',
'audio_branch': 'audio_model.audio_encoder',
'attn': 'attention.self',
'self.proj': 'output.dense',
'attention.self_mask': 'attn_mask',
'mlp.fc1': 'intermediate.dense',
'mlp.fc2': 'output.dense',
'norm1': 'layernorm_before',
'norm2': 'layernorm_after',
'bn0': 'batch_norm',
}
lowerCamelCase : Tuple = AutoFeatureExtractor.from_pretrained('laion/clap-htsat-unfused', truncation='rand_trunc')
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase=False ) -> Tuple:
snake_case , snake_case : Dict = create_model(
"""HTSAT-tiny""" ,"""roberta""" ,lowercase ,precision="""fp32""" ,device="""cuda:0""" if torch.cuda.is_available() else """cpu""" ,enable_fusion=lowercase ,fusion_type="""aff_2d""" if enable_fusion else None ,)
return model, model_cfg
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> List[Any]:
snake_case : str = {}
snake_case : List[Any] = R""".*sequential.(\d+).*"""
snake_case : List[Any] = R""".*_projection.(\d+).*"""
for key, value in state_dict.items():
# check if any key needs to be modified
for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
if key_to_modify in key:
snake_case : Dict = key.replace(lowercase ,lowercase )
if re.match(lowercase ,lowercase ):
# replace sequential layers with list
snake_case : Any = re.match(lowercase ,lowercase ).group(1 )
snake_case : Any = key.replace(f"""sequential.{sequential_layer}.""" ,f"""layers.{int(lowercase )//3}.linear.""" )
elif re.match(lowercase ,lowercase ):
snake_case : Union[str, Any] = int(re.match(lowercase ,lowercase ).group(1 ) )
# Because in CLAP they use `nn.Sequential`...
snake_case : Any = 1 if projecton_layer == 0 else 2
snake_case : Tuple = key.replace(f"""_projection.{projecton_layer}.""" ,f"""_projection.linear{transformers_projection_layer}.""" )
if "audio" and "qkv" in key:
# split qkv into query key and value
snake_case : Tuple = value
snake_case : List[str] = mixed_qkv.size(0 ) // 3
snake_case : Any = mixed_qkv[:qkv_dim]
snake_case : Any = mixed_qkv[qkv_dim : qkv_dim * 2]
snake_case : Tuple = mixed_qkv[qkv_dim * 2 :]
snake_case : Dict = query_layer
snake_case : Optional[Any] = key_layer
snake_case : str = value_layer
else:
snake_case : Optional[int] = value
return model_state_dict
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ,lowercase=False ) -> List[Any]:
snake_case , snake_case : Optional[int] = init_clap(lowercase ,enable_fusion=lowercase )
clap_model.eval()
snake_case : str = clap_model.state_dict()
snake_case : int = rename_state_dict(lowercase )
snake_case : Any = ClapConfig()
snake_case : Any = enable_fusion
snake_case : str = ClapModel(lowercase )
# ignore the spectrogram embedding layer
model.load_state_dict(lowercase ,strict=lowercase )
model.save_pretrained(lowercase )
transformers_config.save_pretrained(lowercase )
if __name__ == "__main__":
lowerCamelCase : Union[str, Any] = argparse.ArgumentParser()
parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to fairseq checkpoint')
parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
parser.add_argument('--enable_fusion', action='store_true', help='Whether to enable fusion or not')
lowerCamelCase : Union[str, Any] = parser.parse_args()
convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
| 684 |
from itertools import product
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> list[int]:
snake_case : Tuple = sides_number
snake_case : List[str] = max_face_number * dice_number
snake_case : Any = [0] * (max_total + 1)
snake_case : int = 1
snake_case : List[str] = range(lowercase ,max_face_number + 1 )
for dice_numbers in product(lowercase ,repeat=lowercase ):
snake_case : Any = sum(lowercase )
totals_frequencies[total] += 1
return totals_frequencies
def SCREAMING_SNAKE_CASE__ ( ) -> float:
snake_case : List[str] = total_frequency_distribution(
sides_number=4 ,dice_number=9 )
snake_case : str = total_frequency_distribution(
sides_number=6 ,dice_number=6 )
snake_case : Optional[int] = 0
snake_case : List[str] = 9
snake_case : Union[str, Any] = 4 * 9
snake_case : Dict = 6
for peter_total in range(lowercase ,max_peter_total + 1 ):
peter_wins_count += peter_totals_frequencies[peter_total] * sum(
colin_totals_frequencies[min_colin_total:peter_total] )
snake_case : str = (4**9) * (6**6)
snake_case : int = peter_wins_count / total_games_number
snake_case : Optional[int] = round(lowercase ,ndigits=7 )
return rounded_peter_win_probability
if __name__ == "__main__":
print(f"""{solution() = }""")
| 684 | 1 |
import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple
from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available
from ...test_tokenization_common import TokenizerTesterMixin
if is_torch_available():
lowerCamelCase : Optional[Any] = 'pt'
elif is_tf_available():
lowerCamelCase : Dict = 'tf'
else:
lowerCamelCase : str = 'jax'
class __lowercase (UpperCamelCase__ , unittest.TestCase ):
"""simple docstring"""
_snake_case = ByTaTokenizer
_snake_case = False
def UpperCAmelCase ( self ) -> List[str]:
super().setUp()
snake_case : Optional[Any] = ByTaTokenizer()
tokenizer.save_pretrained(self.tmpdirname )
@cached_property
def UpperCAmelCase ( self ) -> Any:
return ByTaTokenizer.from_pretrained("""google/byt5-small""" )
def UpperCAmelCase ( self , **A ) -> ByTaTokenizer:
return self.tokenizer_class.from_pretrained(self.tmpdirname , **A )
def UpperCAmelCase ( self , A , A=False , A=2_0 , A=5 ) -> Tuple[str, list]:
# XXX The default common tokenizer tests assume that every ID is decodable on its own.
# This assumption is invalid for ByT5 because single bytes might not be
# valid utf-8 (byte 128 for instance).
# Here we're overriding the smallest possible method to provide
# a clean sequence without making the same assumption.
snake_case : List[str] = []
for i in range(len(A ) ):
try:
snake_case : Tuple = tokenizer.decode([i] , clean_up_tokenization_spaces=A )
except UnicodeDecodeError:
pass
toks.append((i, tok) )
snake_case : List[Any] = list(filter(lambda A : re.match(r"""^[ a-zA-Z]+$""" , t[1] ) , A ) )
snake_case : Any = list(filter(lambda A : [t[0]] == tokenizer.encode(t[1] , add_special_tokens=A ) , A ) )
if max_length is not None and len(A ) > max_length:
snake_case : Dict = toks[:max_length]
if min_length is not None and len(A ) < min_length and len(A ) > 0:
while len(A ) < min_length:
snake_case : Any = toks + toks
# toks_str = [t[1] for t in toks]
snake_case : Union[str, Any] = [t[0] for t in toks]
# Ensure consistency
snake_case : List[str] = tokenizer.decode(A , clean_up_tokenization_spaces=A )
if " " not in output_txt and len(A ) > 1:
snake_case : Optional[int] = (
tokenizer.decode([toks_ids[0]] , clean_up_tokenization_spaces=A )
+ """ """
+ tokenizer.decode(toks_ids[1:] , clean_up_tokenization_spaces=A )
)
if with_prefix_space:
snake_case : Optional[int] = """ """ + output_txt
snake_case : Optional[Any] = tokenizer.encode(A , add_special_tokens=A )
return output_txt, output_ids
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = self.ta_base_tokenizer
snake_case : Optional[Any] = tokenizer(["""hi</s>""", """I went to the gym</s>""", """</s>"""] )
snake_case : Union[str, Any] = tokenizer(["""hi""", """I went to the gym""", """"""] )
self.assertListEqual(batch_with_eos_added["""input_ids"""] , batch_without_eos_added["""input_ids"""] )
def UpperCAmelCase ( self ) -> str:
snake_case : Tuple = self.ta_base_tokenizer
snake_case : Optional[Any] = """Unicode €."""
snake_case : Any = tokenizer(A )
snake_case : Optional[int] = [8_8, 1_1_3, 1_0_8, 1_0_2, 1_1_4, 1_0_3, 1_0_4, 3_5, 2_2_9, 1_3_3, 1_7_5, 4_9, 1]
self.assertEqual(encoded["""input_ids"""] , A )
# decoding
snake_case : List[Any] = tokenizer.decode(A )
self.assertEqual(A , """Unicode €.</s>""" )
snake_case : int = tokenizer("""e è é ê ë""" )
snake_case : List[str] = [1_0_4, 3_5, 1_9_8, 1_7_1, 3_5, 1_9_8, 1_7_2, 3_5, 1_9_8, 1_7_3, 3_5, 1_9_8, 1_7_4, 1]
self.assertEqual(encoded["""input_ids"""] , A )
# decoding
snake_case : Optional[Any] = tokenizer.decode(A )
self.assertEqual(A , """e è é ê ë</s>""" )
# encode/decode, but with `encode` instead of `__call__`
self.assertEqual(tokenizer.decode(tokenizer.encode("""e è é ê ë""" ) ) , """e è é ê ë</s>""" )
def UpperCAmelCase ( self ) -> str:
snake_case : Union[str, Any] = self.ta_base_tokenizer
snake_case : List[str] = ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
# fmt: off
snake_case : int = [6_8, 3_5, 1_1_1, 1_1_4, 1_1_3, 1_0_6, 3_5, 1_1_5, 1_0_0, 1_1_7, 1_0_0, 1_0_6, 1_1_7, 1_0_0, 1_1_5, 1_0_7, 3_5, 1_0_5, 1_1_4, 1_1_7, 3_5, 1_1_8, 1_2_0, 1_1_2, 1_1_2, 1_0_0, 1_1_7, 1_0_8, 1_2_5, 1_0_0, 1_1_9, 1_0_8, 1_1_4, 1_1_3, 4_9, 1, 0]
# fmt: on
snake_case : str = tokenizer(A , padding=A , return_tensors=A )
self.assertIsInstance(A , A )
if FRAMEWORK != "jax":
snake_case : List[Any] = list(batch.input_ids.numpy()[0] )
else:
snake_case : Optional[Any] = list(batch.input_ids.tolist()[0] )
self.assertListEqual(A , A )
self.assertEqual((2, 3_7) , batch.input_ids.shape )
self.assertEqual((2, 3_7) , batch.attention_mask.shape )
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : List[str] = self.ta_base_tokenizer
snake_case : Any = ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
snake_case : List[str] = tokenizer(A , padding=A , return_tensors=A )
# check if input_ids are returned and no decoder_input_ids
self.assertIn("""input_ids""" , A )
self.assertIn("""attention_mask""" , A )
self.assertNotIn("""decoder_input_ids""" , A )
self.assertNotIn("""decoder_attention_mask""" , A )
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : List[str] = self.ta_base_tokenizer
snake_case : Dict = [
"""Summary of the text.""",
"""Another summary.""",
]
snake_case : Tuple = tokenizer(
text_target=A , max_length=3_2 , padding="""max_length""" , truncation=A , return_tensors=A )
self.assertEqual(3_2 , targets["""input_ids"""].shape[1] )
def UpperCAmelCase ( self ) -> List[str]:
snake_case : List[Any] = self.ta_base_tokenizer
snake_case : Optional[Any] = ["""A long paragraph for summarization. </s>"""]
snake_case : List[Any] = ["""Summary of the text. </s>"""]
# fmt: off
snake_case : Dict = [6_8, 3_5, 1_1_1, 1_1_4, 1_1_3, 1_0_6, 3_5, 1_1_5, 1_0_0, 1_1_7, 1_0_0, 1_0_6, 1_1_7, 1_0_0, 1_1_5, 1_0_7, 3_5, 1_0_5, 1_1_4, 1_1_7, 3_5, 1_1_8, 1_2_0, 1_1_2, 1_1_2, 1_0_0, 1_1_7, 1_0_8, 1_2_5, 1_0_0, 1_1_9, 1_0_8, 1_1_4, 1_1_3, 4_9, 3_5, 1]
snake_case : List[Any] = [8_6, 1_2_0, 1_1_2, 1_1_2, 1_0_0, 1_1_7, 1_2_4, 3_5, 1_1_4, 1_0_5, 3_5, 1_1_9, 1_0_7, 1_0_4, 3_5, 1_1_9, 1_0_4, 1_2_3, 1_1_9, 4_9, 3_5, 1]
# fmt: on
snake_case : Dict = tokenizer(A , text_target=A )
self.assertEqual(A , batch["""input_ids"""][0] )
self.assertEqual(A , batch["""labels"""][0] )
def UpperCAmelCase ( self ) -> Optional[Any]:
# safety check on max_len default value so we are sure the test works
snake_case : Dict = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
self.assertNotEqual(tokenizer.model_max_length , 4_2 )
# Now let's start the test
snake_case : List[str] = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
# Isolate this from the other tests because we save additional tokens/etc
snake_case : Dict = tempfile.mkdtemp()
snake_case : str = """ He is very happy, UNwant\u00E9d,running"""
snake_case : Dict = tokenizer.encode(A , add_special_tokens=A )
tokenizer.save_pretrained(A )
snake_case : List[Any] = tokenizer.__class__.from_pretrained(A )
snake_case : Tuple = after_tokenizer.encode(A , add_special_tokens=A )
self.assertListEqual(A , A )
shutil.rmtree(A )
snake_case : Tuple = self.get_tokenizers(model_max_length=4_2 )
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
# Isolate this from the other tests because we save additional tokens/etc
snake_case : List[str] = tempfile.mkdtemp()
snake_case : Any = """ He is very happy, UNwant\u00E9d,running"""
tokenizer.add_tokens(["""bim""", """bambam"""] )
snake_case : Any = tokenizer.additional_special_tokens
additional_special_tokens.append("""new_additional_special_token""" )
tokenizer.add_special_tokens({"""additional_special_tokens""": additional_special_tokens} )
snake_case : Tuple = tokenizer.encode(A , add_special_tokens=A )
tokenizer.save_pretrained(A )
snake_case : Tuple = tokenizer.__class__.from_pretrained(A )
snake_case : int = after_tokenizer.encode(A , add_special_tokens=A )
self.assertListEqual(A , A )
self.assertIn("""new_additional_special_token""" , after_tokenizer.additional_special_tokens )
self.assertEqual(after_tokenizer.model_max_length , 4_2 )
snake_case : Optional[int] = tokenizer.__class__.from_pretrained(A , model_max_length=4_3 )
self.assertEqual(tokenizer.model_max_length , 4_3 )
shutil.rmtree(A )
def UpperCAmelCase ( self ) -> Any:
snake_case : Union[str, Any] = []
if self.test_slow_tokenizer:
tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()) )
if self.test_rust_tokenizer:
tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()) )
for tokenizer_class, tokenizer_utils in tokenizer_list:
with tempfile.TemporaryDirectory() as tmp_dir:
tokenizer_utils.save_pretrained(A )
with open(os.path.join(A , """special_tokens_map.json""" ) , encoding="""utf-8""" ) as json_file:
snake_case : Union[str, Any] = json.load(A )
with open(os.path.join(A , """tokenizer_config.json""" ) , encoding="""utf-8""" ) as json_file:
snake_case : Dict = json.load(A )
snake_case : int = [f"""<extra_id_{i}>""" for i in range(1_2_5 )]
snake_case : Any = added_tokens_extra_ids + [
"""an_additional_special_token"""
]
snake_case : Optional[int] = added_tokens_extra_ids + [
"""an_additional_special_token"""
]
with open(os.path.join(A , """special_tokens_map.json""" ) , """w""" , encoding="""utf-8""" ) as outfile:
json.dump(A , A )
with open(os.path.join(A , """tokenizer_config.json""" ) , """w""" , encoding="""utf-8""" ) as outfile:
json.dump(A , A )
# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
# "special_tokens_map.json" files
snake_case : Tuple = tokenizer_class.from_pretrained(
A , )
self.assertIn(
"""an_additional_special_token""" , tokenizer_without_change_in_init.additional_special_tokens )
# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
self.assertEqual(
["""an_additional_special_token"""] , tokenizer_without_change_in_init.convert_ids_to_tokens(
tokenizer_without_change_in_init.convert_tokens_to_ids(["""an_additional_special_token"""] ) ) , )
# Now we test that we can change the value of additional_special_tokens in the from_pretrained
snake_case : Union[str, Any] = added_tokens_extra_ids + [AddedToken("""a_new_additional_special_token""" , lstrip=A )]
snake_case : List[Any] = tokenizer_class.from_pretrained(
A , additional_special_tokens=A , )
self.assertIn("""a_new_additional_special_token""" , tokenizer.additional_special_tokens )
self.assertEqual(
["""a_new_additional_special_token"""] , tokenizer.convert_ids_to_tokens(
tokenizer.convert_tokens_to_ids(["""a_new_additional_special_token"""] ) ) , )
def UpperCAmelCase ( self ) -> Any:
snake_case : List[Any] = []
if self.test_slow_tokenizer:
tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()) )
if self.test_rust_tokenizer:
tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()) )
for tokenizer_class, tokenizer_utils in tokenizer_list:
with tempfile.TemporaryDirectory() as tmp_dir:
tokenizer_utils.save_pretrained(A )
snake_case : Any = tokenizer_class.from_pretrained(A )
self.assertTrue(tokenizer.decode([2_5_5] ) == """""" )
def UpperCAmelCase ( self ) -> Tuple:
pass
def UpperCAmelCase ( self ) -> Union[str, Any]:
pass
def UpperCAmelCase ( self ) -> Any:
pass
def UpperCAmelCase ( self ) -> str:
pass
def UpperCAmelCase ( self ) -> Tuple:
# The default common tokenizer tests uses invalid tokens for ByT5 that can only accept one-character strings
# and special added tokens as tokens
snake_case : Optional[Any] = self.get_tokenizers(fast=A , do_lower_case=A )
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
snake_case : Optional[Any] = ["""t""", """h""", """i""", """s""", """ """, """i""", """s""", """ """, """a""", """ """, """t""", """e""", """x""", """t""", """</s>"""]
snake_case : Optional[Any] = tokenizer.convert_tokens_to_string(A )
self.assertIsInstance(A , A )
def UpperCAmelCase ( self ) -> Union[str, Any]:
snake_case : Dict = self.get_tokenizers()
for tokenizer in tokenizers:
with self.subTest(f"""{tokenizer.__class__.__name__}""" ):
snake_case : Union[str, Any] = [
"""bos_token""",
"""eos_token""",
"""unk_token""",
"""sep_token""",
"""pad_token""",
"""cls_token""",
"""mask_token""",
]
snake_case : Optional[int] = 0
snake_case : Tuple = tokenizer.convert_ids_to_tokens(
A , skip_special_tokens=A )
for attr in attributes_list:
setattr(A , attr + """_id""" , A )
self.assertEqual(getattr(A , A ) , A )
self.assertEqual(getattr(A , attr + """_id""" ) , A )
setattr(A , attr + """_id""" , A )
self.assertEqual(getattr(A , A ) , A )
self.assertEqual(getattr(A , attr + """_id""" ) , A )
setattr(A , """additional_special_tokens_ids""" , [] )
self.assertListEqual(getattr(A , """additional_special_tokens""" ) , [] )
self.assertListEqual(getattr(A , """additional_special_tokens_ids""" ) , [] )
setattr(A , """additional_special_tokens_ids""" , [token_id_to_test_setters] )
self.assertListEqual(getattr(A , """additional_special_tokens""" ) , [token_to_test_setters] )
self.assertListEqual(getattr(A , """additional_special_tokens_ids""" ) , [token_id_to_test_setters] )
| 684 |
from ...utils import (
OptionalDependencyNotAvailable,
is_torch_available,
is_transformers_available,
is_transformers_version,
)
try:
if not (is_transformers_available() and is_torch_available() and is_transformers_version('>=', '4.25.0')):
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
from ...utils.dummy_torch_and_transformers_objects import (
VersatileDiffusionDualGuidedPipeline,
VersatileDiffusionImageVariationPipeline,
VersatileDiffusionPipeline,
VersatileDiffusionTextToImagePipeline,
)
else:
from .modeling_text_unet import UNetFlatConditionModel
from .pipeline_versatile_diffusion import VersatileDiffusionPipeline
from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline
from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline
from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline
| 684 | 1 |
from __future__ import annotations
from sys import maxsize
from typing import Generic, TypeVar
lowerCamelCase : Tuple = TypeVar('T')
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
return (position - 1) // 2
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
return (2 * position) + 1
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
return (2 * position) + 2
class __lowercase (Generic[T] ):
"""simple docstring"""
def __init__( self ) -> None:
snake_case : list[tuple[T, int]] = []
snake_case : dict[T, int] = {}
snake_case : int = 0
def __len__( self ) -> int:
return self.elements
def __repr__( self ) -> str:
return str(self.heap )
def UpperCAmelCase ( self ) -> bool:
# Check if the priority queue is empty
return self.elements == 0
def UpperCAmelCase ( self , A , A ) -> None:
# Add an element with given priority to the queue
self.heap.append((elem, weight) )
snake_case : Optional[Any] = self.elements
self.elements += 1
self._bubble_up(A )
def UpperCAmelCase ( self ) -> T:
# Remove and return the element with lowest weight (highest priority)
if self.elements > 1:
self._swap_nodes(0 , self.elements - 1 )
snake_case , snake_case : Dict = self.heap.pop()
del self.position_map[elem]
self.elements -= 1
if self.elements > 0:
snake_case , snake_case : Optional[int] = self.heap[0]
self._bubble_down(A )
return elem
def UpperCAmelCase ( self , A , A ) -> None:
# Update the weight of the given key
snake_case : List[str] = self.position_map[elem]
snake_case : Optional[Any] = (elem, weight)
if position > 0:
snake_case : Union[str, Any] = get_parent_position(A )
snake_case , snake_case : Optional[Any] = self.heap[parent_position]
if parent_weight > weight:
self._bubble_up(A )
else:
self._bubble_down(A )
else:
self._bubble_down(A )
def UpperCAmelCase ( self , A ) -> None:
# Place a node at the proper position (upward movement) [to be used internally
# only]
snake_case : Any = self.position_map[elem]
if curr_pos == 0:
return None
snake_case : Union[str, Any] = get_parent_position(A )
snake_case , snake_case : str = self.heap[curr_pos]
snake_case , snake_case : Optional[Any] = self.heap[parent_position]
if parent_weight > weight:
self._swap_nodes(A , A )
return self._bubble_up(A )
return None
def UpperCAmelCase ( self , A ) -> None:
# Place a node at the proper position (downward movement) [to be used
# internally only]
snake_case : List[Any] = self.position_map[elem]
snake_case , snake_case : Union[str, Any] = self.heap[curr_pos]
snake_case : Dict = get_child_left_position(A )
snake_case : Any = get_child_right_position(A )
if child_left_position < self.elements and child_right_position < self.elements:
snake_case , snake_case : List[str] = self.heap[child_left_position]
snake_case , snake_case : Optional[int] = self.heap[child_right_position]
if child_right_weight < child_left_weight and child_right_weight < weight:
self._swap_nodes(A , A )
return self._bubble_down(A )
if child_left_position < self.elements:
snake_case , snake_case : str = self.heap[child_left_position]
if child_left_weight < weight:
self._swap_nodes(A , A )
return self._bubble_down(A )
else:
return None
if child_right_position < self.elements:
snake_case , snake_case : Any = self.heap[child_right_position]
if child_right_weight < weight:
self._swap_nodes(A , A )
return self._bubble_down(A )
return None
def UpperCAmelCase ( self , A , A ) -> None:
# Swap the nodes at the given positions
snake_case : Optional[int] = self.heap[nodea_pos][0]
snake_case : Any = self.heap[nodea_pos][0]
snake_case , snake_case : Optional[Any] = (
self.heap[nodea_pos],
self.heap[nodea_pos],
)
snake_case : str = nodea_pos
snake_case : List[str] = nodea_pos
class __lowercase (Generic[T] ):
"""simple docstring"""
def __init__( self ) -> None:
snake_case : dict[T, dict[T, int]] = {}
snake_case : int = 0
def __repr__( self ) -> str:
return str(self.connections )
def __len__( self ) -> int:
return self.nodes
def UpperCAmelCase ( self , A ) -> None:
# Add a node in the graph if it is not in the graph
if node not in self.connections:
snake_case : List[Any] = {}
self.nodes += 1
def UpperCAmelCase ( self , A , A , A ) -> None:
# Add an edge between 2 nodes in the graph
self.add_node(A )
self.add_node(A )
snake_case : Any = weight
snake_case : str = weight
def SCREAMING_SNAKE_CASE__ ( lowercase ,) -> tuple[dict[T, int], dict[T, T | None]]:
snake_case : dict[T, int] = {node: maxsize for node in graph.connections}
snake_case : dict[T, T | None] = {node: None for node in graph.connections}
snake_case : MinPriorityQueue[T] = MinPriorityQueue()
for node, weight in dist.items():
priority_queue.push(lowercase ,lowercase )
if priority_queue.is_empty():
return dist, parent
# initialization
snake_case : Dict = priority_queue.extract_min()
snake_case : Dict = 0
for neighbour in graph.connections[node]:
if dist[neighbour] > dist[node] + graph.connections[node][neighbour]:
snake_case : List[str] = dist[node] + graph.connections[node][neighbour]
priority_queue.update_key(lowercase ,dist[neighbour] )
snake_case : str = node
# running prim's algorithm
while not priority_queue.is_empty():
snake_case : Union[str, Any] = priority_queue.extract_min()
for neighbour in graph.connections[node]:
if dist[neighbour] > dist[node] + graph.connections[node][neighbour]:
snake_case : Dict = dist[node] + graph.connections[node][neighbour]
priority_queue.update_key(lowercase ,dist[neighbour] )
snake_case : Dict = node
return dist, parent
| 684 |
import os
def SCREAMING_SNAKE_CASE__ ( ) -> Dict:
with open(os.path.dirname(lowercase ) + """/grid.txt""" ) as f:
snake_case : Tuple = [] # noqa: E741
for _ in range(20 ):
l.append([int(lowercase ) for x in f.readline().split()] )
snake_case : Optional[Any] = 0
# right
for i in range(20 ):
for j in range(17 ):
snake_case : List[Any] = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
if temp > maximum:
snake_case : Tuple = temp
# down
for i in range(17 ):
for j in range(20 ):
snake_case : Any = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
if temp > maximum:
snake_case : str = temp
# diagonal 1
for i in range(17 ):
for j in range(17 ):
snake_case : int = l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
if temp > maximum:
snake_case : int = temp
# diagonal 2
for i in range(17 ):
for j in range(3 ,20 ):
snake_case : Any = l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
if temp > maximum:
snake_case : Any = temp
return maximum
if __name__ == "__main__":
print(solution())
| 684 | 1 |
import argparse
import math
import traceback
import dateutil.parser as date_parser
import requests
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> Optional[int]:
snake_case : Optional[Any] = {}
snake_case : List[str] = job["""started_at"""]
snake_case : List[str] = job["""completed_at"""]
snake_case : int = date_parser.parse(lowercase )
snake_case : Union[str, Any] = date_parser.parse(lowercase )
snake_case : Dict = round((end_datetime - start_datetime).total_seconds() / 60.0 )
snake_case : str = start
snake_case : Tuple = end
snake_case : Dict = duration_in_min
return job_info
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase=None ) -> Optional[int]:
snake_case : Union[str, Any] = None
if token is not None:
snake_case : Any = {"""Accept""": """application/vnd.github+json""", """Authorization""": f"""Bearer {token}"""}
snake_case : Union[str, Any] = f"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100"""
snake_case : List[str] = requests.get(lowercase ,headers=lowercase ).json()
snake_case : int = {}
try:
job_time.update({job["""name"""]: extract_time_from_single_job(lowercase ) for job in result["""jobs"""]} )
snake_case : Optional[int] = math.ceil((result["""total_count"""] - 100) / 100 )
for i in range(lowercase ):
snake_case : List[str] = requests.get(url + f"""&page={i + 2}""" ,headers=lowercase ).json()
job_time.update({job["""name"""]: extract_time_from_single_job(lowercase ) for job in result["""jobs"""]} )
return job_time
except Exception:
print(f"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" )
return {}
if __name__ == "__main__":
lowerCamelCase : Union[str, Any] = argparse.ArgumentParser()
# Required parameters
parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
lowerCamelCase : Dict = parser.parse_args()
lowerCamelCase : List[Any] = get_job_time(args.workflow_run_id)
lowerCamelCase : List[str] = dict(sorted(job_time.items(), key=lambda item: item[1]["duration"], reverse=True))
for k, v in job_time.items():
print(f"""{k}: {v["duration"]}""")
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list:
for i in range(len(lowercase ) - 1 ,0 ,-1 ):
snake_case : Any = False
for j in range(lowercase ,0 ,-1 ):
if unsorted[j] < unsorted[j - 1]:
snake_case , snake_case : Optional[Any] = unsorted[j - 1], unsorted[j]
snake_case : Dict = True
for j in range(lowercase ):
if unsorted[j] > unsorted[j + 1]:
snake_case , snake_case : Dict = unsorted[j + 1], unsorted[j]
snake_case : Tuple = True
if not swapped:
break
return unsorted
if __name__ == "__main__":
import doctest
doctest.testmod()
lowerCamelCase : Any = input('Enter numbers separated by a comma:\n').strip()
lowerCamelCase : Optional[int] = [int(item) for item in user_input.split(',')]
print(f"""{cocktail_shaker_sort(unsorted) = }""")
| 684 | 1 |
from __future__ import annotations
def SCREAMING_SNAKE_CASE__ ( lowercase = 4 ) -> list[list[int]]:
snake_case : str = abs(lowercase ) or 4
return [[1 + x + y * row_size for x in range(lowercase )] for y in range(lowercase )]
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
return reverse_row(transpose(lowercase ) )
# OR.. transpose(reverse_column(matrix))
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
return reverse_row(reverse_column(lowercase ) )
# OR.. reverse_column(reverse_row(matrix))
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
return reverse_column(transpose(lowercase ) )
# OR.. transpose(reverse_row(matrix))
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
snake_case : Tuple = [list(lowercase ) for x in zip(*lowercase )]
return matrix
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
snake_case : List[str] = matrix[::-1]
return matrix
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> list[list[int]]:
snake_case : Dict = [x[::-1] for x in matrix]
return matrix
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> None:
for i in matrix:
print(*lowercase )
if __name__ == "__main__":
lowerCamelCase : Dict = make_matrix()
print('\norigin:\n')
print_matrix(matrix)
print('\nrotate 90 counterclockwise:\n')
print_matrix(rotate_aa(matrix))
lowerCamelCase : Union[str, Any] = make_matrix()
print('\norigin:\n')
print_matrix(matrix)
print('\nrotate 180:\n')
print_matrix(rotate_aaa(matrix))
lowerCamelCase : List[str] = make_matrix()
print('\norigin:\n')
print_matrix(matrix)
print('\nrotate 270 counterclockwise:\n')
print_matrix(rotate_aaa(matrix))
| 684 |
import json
import os
import re
import unicodedata
from json.encoder import INFINITY
from typing import Any, Dict, List, Optional, Tuple, Union
import numpy as np
import regex
from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_flax_available, is_tf_available, is_torch_available, logging
from ...utils.generic import _is_jax, _is_numpy
lowerCamelCase : Tuple = logging.get_logger(__name__)
lowerCamelCase : Any = {
'artists_file': 'artists.json',
'lyrics_file': 'lyrics.json',
'genres_file': 'genres.json',
}
lowerCamelCase : Any = {
'artists_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/artists.json',
},
'genres_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/genres.json',
},
'lyrics_file': {
'jukebox': 'https://huggingface.co/ArthurZ/jukebox/blob/main/lyrics.json',
},
}
lowerCamelCase : Optional[int] = {
'jukebox': 5_1_2,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_LYRIC_TOKENS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A , A , A=["v3", "v2", "v2"] , A=5_1_2 , A=5 , A="<|endoftext|>" , **A , ) -> Optional[Any]:
snake_case : Dict = AddedToken(A , lstrip=A , rstrip=A ) if isinstance(A , A ) else unk_token
super().__init__(
unk_token=A , n_genres=A , version=A , max_n_lyric_tokens=A , **A , )
snake_case : Optional[Any] = version
snake_case : Optional[Any] = max_n_lyric_tokens
snake_case : Tuple = n_genres
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : Union[str, Any] = json.load(A )
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : str = json.load(A )
with open(A , encoding="""utf-8""" ) as vocab_handle:
snake_case : List[str] = json.load(A )
snake_case : Tuple = r"""[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+"""
# In v2, we had a n_vocab=80 and in v3 we missed + and so n_vocab=79 of characters.
if len(self.lyrics_encoder ) == 7_9:
snake_case : Optional[Any] = oov.replace(r"""\-'""" , r"""\-+'""" )
snake_case : Optional[Any] = regex.compile(A )
snake_case : Optional[Any] = {v: k for k, v in self.artists_encoder.items()}
snake_case : int = {v: k for k, v in self.genres_encoder.items()}
snake_case : List[Any] = {v: k for k, v in self.lyrics_encoder.items()}
@property
def UpperCAmelCase ( self ) -> Optional[Any]:
return len(self.artists_encoder ) + len(self.genres_encoder ) + len(self.lyrics_encoder )
def UpperCAmelCase ( self ) -> str:
return dict(self.artists_encoder , self.genres_encoder , self.lyrics_encoder )
def UpperCAmelCase ( self , A , A , A ) -> Optional[Any]:
snake_case : Optional[int] = [self.artists_encoder.get(A , 0 ) for artist in list_artists]
for genres in range(len(A ) ):
snake_case : Optional[int] = [self.genres_encoder.get(A , 0 ) for genre in list_genres[genres]]
snake_case : Union[str, Any] = list_genres[genres] + [-1] * (self.n_genres - len(list_genres[genres] ))
snake_case : Optional[Any] = [[self.lyrics_encoder.get(A , 0 ) for character in list_lyrics[0]], [], []]
return artists_id, list_genres, lyric_ids
def UpperCAmelCase ( self , A ) -> List[str]:
return list(A )
def UpperCAmelCase ( self , A , A , A , **A ) -> List[str]:
snake_case , snake_case , snake_case : Any = self.prepare_for_tokenization(A , A , A )
snake_case : Tuple = self._tokenize(A )
return artist, genre, lyrics
def UpperCAmelCase ( self , A , A , A , A = False ) -> Tuple[str, str, str, Dict[str, Any]]:
for idx in range(len(self.version ) ):
if self.version[idx] == "v3":
snake_case : Tuple = artists[idx].lower()
snake_case : List[Any] = [genres[idx].lower()]
else:
snake_case : Union[str, Any] = self._normalize(artists[idx] ) + """.v2"""
snake_case : Any = [
self._normalize(A ) + """.v2""" for genre in genres[idx].split("""_""" )
] # split is for the full dictionary with combined genres
if self.version[0] == "v2":
snake_case : str = regex.compile(r"""[^A-Za-z0-9.,:;!?\-'\"()\[\] \t\n]+""" )
snake_case : Dict = """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;!?-+'\"()[] \t\n"""
snake_case : Union[str, Any] = {vocab[index]: index + 1 for index in range(len(A ) )}
snake_case : Optional[int] = 0
snake_case : Union[str, Any] = len(A ) + 1
snake_case : Optional[int] = self.vocab
snake_case : str = {v: k for k, v in self.vocab.items()}
snake_case : int = """"""
else:
snake_case : Optional[int] = regex.compile(r"""[^A-Za-z0-9.,:;!?\-+'\"()\[\] \t\n]+""" )
snake_case : int = self._run_strip_accents(A )
snake_case : Any = lyrics.replace("""\\""" , """\n""" )
snake_case : Tuple = self.out_of_vocab.sub("""""" , A ), [], []
return artists, genres, lyrics
def UpperCAmelCase ( self , A ) -> List[Any]:
snake_case : int = unicodedata.normalize("""NFD""" , A )
snake_case : int = []
for char in text:
snake_case : Optional[Any] = unicodedata.category(A )
if cat == "Mn":
continue
output.append(A )
return "".join(A )
def UpperCAmelCase ( self , A ) -> str:
snake_case : Dict = (
[chr(A ) for i in range(ord("""a""" ) , ord("""z""" ) + 1 )]
+ [chr(A ) for i in range(ord("""A""" ) , ord("""Z""" ) + 1 )]
+ [chr(A ) for i in range(ord("""0""" ) , ord("""9""" ) + 1 )]
+ ["""."""]
)
snake_case : Dict = frozenset(A )
snake_case : Dict = re.compile(r"""_+""" )
snake_case : str = """""".join([c if c in accepted else """_""" for c in text.lower()] )
snake_case : List[Any] = pattern.sub("""_""" , A ).strip("""_""" )
return text
def UpperCAmelCase ( self , A ) -> str:
return " ".join(A )
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[Any]:
# Convert to TensorType
if not isinstance(A , A ):
snake_case : Tuple = TensorType(A )
# Get a function reference for the correct framework
if tensor_type == TensorType.TENSORFLOW:
if not is_tf_available():
raise ImportError(
"""Unable to convert output to TensorFlow tensors format, TensorFlow is not installed.""" )
import tensorflow as tf
snake_case : Union[str, Any] = tf.constant
snake_case : int = tf.is_tensor
elif tensor_type == TensorType.PYTORCH:
if not is_torch_available():
raise ImportError("""Unable to convert output to PyTorch tensors format, PyTorch is not installed.""" )
import torch
snake_case : List[str] = torch.tensor
snake_case : Optional[Any] = torch.is_tensor
elif tensor_type == TensorType.JAX:
if not is_flax_available():
raise ImportError("""Unable to convert output to JAX tensors format, JAX is not installed.""" )
import jax.numpy as jnp # noqa: F811
snake_case : Optional[int] = jnp.array
snake_case : Dict = _is_jax
else:
snake_case : List[str] = np.asarray
snake_case : Tuple = _is_numpy
# Do the tensor conversion in batch
try:
if prepend_batch_axis:
snake_case : Any = [inputs]
if not is_tensor(A ):
snake_case : List[Any] = as_tensor(A )
except: # noqa E722
raise ValueError(
"""Unable to create tensor, you should probably activate truncation and/or padding """
"""with 'padding=True' 'truncation=True' to have batched tensors with the same length.""" )
return inputs
def __call__( self , A , A , A="" , A="pt" ) -> BatchEncoding:
snake_case : List[str] = [0, 0, 0]
snake_case : List[str] = [artist] * len(self.version )
snake_case : List[Any] = [genres] * len(self.version )
snake_case , snake_case , snake_case : Optional[int] = self.tokenize(A , A , A )
snake_case , snake_case , snake_case : int = self._convert_token_to_id(A , A , A )
snake_case : Any = [-INFINITY] * len(full_tokens[-1] )
snake_case : int = [
self.convert_to_tensors(
[input_ids + [artists_id[i]] + genres_ids[i] + full_tokens[i]] , tensor_type=A )
for i in range(len(self.version ) )
]
return BatchEncoding({"""input_ids""": input_ids, """attention_masks""": attention_masks} )
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Any = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""artists_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.artists_encoder , ensure_ascii=A ) )
snake_case : Any = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""genres_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.genres_encoder , ensure_ascii=A ) )
snake_case : Tuple = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""lyrics_file"""] )
with open(A , """w""" , encoding="""utf-8""" ) as f:
f.write(json.dumps(self.lyrics_encoder , ensure_ascii=A ) )
return (artists_file, genres_file, lyrics_file)
def UpperCAmelCase ( self , A , A , A ) -> List[Any]:
snake_case : Optional[int] = self.artists_decoder.get(A )
snake_case : Optional[Any] = [self.genres_decoder.get(A ) for genre in genres_index]
snake_case : Optional[int] = [self.lyrics_decoder.get(A ) for character in lyric_index]
return artist, genres, lyrics
| 684 | 1 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : str = logging.get_logger(__name__)
lowerCamelCase : List[str] = {'openai-gpt': 'https://huggingface.co/openai-gpt/resolve/main/config.json'}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """openai-gpt"""
_snake_case = {
"""max_position_embeddings""": """n_positions""",
"""hidden_size""": """n_embd""",
"""num_attention_heads""": """n_head""",
"""num_hidden_layers""": """n_layer""",
}
def __init__( self , A=4_0_4_7_8 , A=5_1_2 , A=7_6_8 , A=1_2 , A=1_2 , A="gelu" , A=0.1 , A=0.1 , A=0.1 , A=1e-5 , A=0.02 , A="cls_index" , A=True , A=None , A=True , A=0.1 , **A , ) -> str:
snake_case : Dict = vocab_size
snake_case : str = n_positions
snake_case : str = n_embd
snake_case : Union[str, Any] = n_layer
snake_case : List[str] = n_head
snake_case : List[Any] = afn
snake_case : List[Any] = resid_pdrop
snake_case : Optional[int] = embd_pdrop
snake_case : Tuple = attn_pdrop
snake_case : Tuple = layer_norm_epsilon
snake_case : str = initializer_range
snake_case : Optional[Any] = summary_type
snake_case : Union[str, Any] = summary_use_proj
snake_case : Any = summary_activation
snake_case : Any = summary_first_dropout
snake_case : List[Any] = summary_proj_to_labels
super().__init__(**A )
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> list:
snake_case : str = len(lowercase )
snake_case : Tuple = []
for i in range(len(lowercase ) - pat_len + 1 ):
snake_case : str = True
for j in range(lowercase ):
if s[i + j] != pattern[j]:
snake_case : Dict = False
break
if match_found:
position.append(lowercase )
return position
if __name__ == "__main__":
assert naive_pattern_search('ABCDEFG', 'DE') == [3]
print(naive_pattern_search('ABAAABCDBBABCDDEBCABC', 'ABC'))
| 684 | 1 |
# XXX: we want transformers master here - in the absense of conftest manipulating sys.path:
# hack it in for now:
import sys
from pathlib import Path
lowerCamelCase : List[Any] = Path(__file__).resolve().parents[3] / 'src'
sys.path.insert(1, str(git_repo_path))
import dataclasses # noqa
import io # noqa
import itertools # noqa
import json # noqa
import os # noqa
import unittest # noqa
from copy import deepcopy # noqa
from parameterized import parameterized # noqa
from transformers import TrainingArguments, is_torch_available # noqa
from transformers.deepspeed import is_deepspeed_available # noqa
from transformers.file_utils import WEIGHTS_NAME # noqa
from transformers.testing_utils import ( # noqa
CaptureLogger,
ExtendSysPath,
TestCasePlus,
execute_subprocess_async,
get_gpu_count,
mockenv_context,
require_deepspeed,
require_torch_gpu,
require_torch_multi_gpu,
slow,
)
from transformers.trainer_utils import set_seed # noqa
set_seed(4_2)
lowerCamelCase : Tuple = {'base': 'patrickvonplaten/wav2vec2_tiny_random', 'robust': 'patrickvonplaten/wav2vec2_tiny_random_robust'}
lowerCamelCase : Any = 'zero2'
lowerCamelCase : Dict = 'zero3'
lowerCamelCase : List[Any] = [ZEROa, ZEROa]
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ,lowercase ) -> Optional[int]:
# customize the test name generator function as we want both params to appear in the sub-test
# name, as by default it shows only the first param
snake_case : Optional[Any] = parameterized.to_safe_name("""_""".join(str(lowercase ) for x in param.args ) )
return f"""{func.__name__}_{param_based_name}"""
# Cartesian-product of zero stages with models to test
lowerCamelCase : Optional[int] = list(itertools.product(stages, models.keys()))
@slow
@require_deepspeed
@require_torch_gpu
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
@parameterized.expand(A , name_func=A )
def UpperCAmelCase ( self , A , A ) -> Dict:
self.run_and_check(
stage=A , model=A , distributed=A , fpaa=A , )
@require_torch_multi_gpu
@parameterized.expand(A , name_func=A )
def UpperCAmelCase ( self , A , A ) -> List[Any]:
self.run_and_check(
stage=A , model=A , distributed=A , fpaa=A , )
@parameterized.expand(A , name_func=A )
def UpperCAmelCase ( self , A , A ) -> str:
self.run_and_check(
stage=A , model=A , distributed=A , fpaa=A , )
@require_torch_multi_gpu
@parameterized.expand(A , name_func=A )
def UpperCAmelCase ( self , A , A ) -> Optional[Any]:
self.run_and_check(
stage=A , model=A , distributed=A , fpaa=A , )
def UpperCAmelCase ( self , A ) -> Tuple:
# XXX: run_asr is premature and doesn't save any results
# so all we check for now is that the process didn't fail
pass
def UpperCAmelCase ( self , A , A , A = 1_0 , A = True , A = True , A = True , ) -> Tuple:
snake_case : List[str] = models[model]
snake_case : List[Any] = self.run_trainer(
stage=A , model_name=A , eval_steps=A , num_train_epochs=1 , distributed=A , fpaa=A , )
self.do_checks(A )
return output_dir
def UpperCAmelCase ( self , A , A , A = 1_0 , A = 1 , A = True , A = True , ) -> Dict:
snake_case : List[Any] = self.get_auto_remove_tmp_dir("""./xxx""" , after=A )
snake_case : List[Any] = f"""
--model_name_or_path {model_name}
--dataset_name hf-internal-testing/librispeech_asr_dummy
--dataset_config_name clean
--train_split_name validation
--validation_split_name validation
--output_dir {output_dir}
--num_train_epochs {str(A )}
--per_device_train_batch_size 2
--per_device_eval_batch_size 2
--evaluation_strategy steps
--learning_rate 5e-4
--warmup_steps 8
--orthography timit
--preprocessing_num_workers 1
--group_by_length
--freeze_feature_extractor
--report_to none
--save_steps 0
--eval_steps {eval_steps}
--report_to none
""".split()
if fpaa:
args.extend(["""--fp16"""] )
# currently ds_config_wav2vec2_zero.json requires "zero_optimization.find_unused_parameters": true,
# hence the separate config files
snake_case : Union[str, Any] = f"""--deepspeed {self.test_file_dir_str}/ds_config_wav2vec2_{stage}.json""".split()
snake_case : List[Any] = [f"""{self.examples_dir_str}/research_projects/wav2vec2/run_asr.py"""]
snake_case : str = self.get_launcher(A )
snake_case : List[str] = launcher + script + args + ds_args
# keep for quick debug
# print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
execute_subprocess_async(A , env=self.get_env() )
return output_dir
def UpperCAmelCase ( self , A=False ) -> Optional[Any]:
# 1. explicitly set --num_nodes=1 just in case these tests end up run on a multi-node setup
# - it won't be able to handle that
# 2. for now testing with just 2 gpus max (since some quality tests may give different
# results with mode gpus because we use very little data)
snake_case : str = min(2 , get_gpu_count() ) if distributed else 1
return f"""deepspeed --num_nodes 1 --num_gpus {num_gpus}""".split()
| 684 |
import numpy as np
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> np.array:
return (2 / (1 + np.exp(-2 * vector ))) - 1
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
import gc
import random
import unittest
import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
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
enable_full_determinism()
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> Optional[int]:
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
@property
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : str = 1
snake_case : Union[str, Any] = 3
snake_case : Any = (3_2, 3_2)
snake_case : Union[str, Any] = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0 ) ).to(A )
return image
@property
def UpperCAmelCase ( self ) -> Dict:
torch.manual_seed(0 )
snake_case : Tuple = UNetaDConditionModel(
block_out_channels=(3_2, 3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=7 , out_channels=4 , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""", """CrossAttnDownBlock2D""") , up_block_types=("""CrossAttnUpBlock2D""", """CrossAttnUpBlock2D""", """UpBlock2D""") , cross_attention_dim=3_2 , attention_head_dim=8 , use_linear_projection=A , only_cross_attention=(True, True, False) , num_class_embeds=1_0_0 , )
return model
@property
def UpperCAmelCase ( self ) -> str:
torch.manual_seed(0 )
snake_case : Tuple = AutoencoderKL(
block_out_channels=[3_2, 3_2, 6_4] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=4 , )
return model
@property
def UpperCAmelCase ( self ) -> Tuple:
torch.manual_seed(0 )
snake_case : Optional[int] = CLIPTextConfig(
bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1e-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_0_0_0 , hidden_act="""gelu""" , projection_dim=5_1_2 , )
return CLIPTextModel(A )
def UpperCAmelCase ( self ) -> Tuple:
snake_case : Optional[int] = """cpu""" # ensure determinism for the device-dependent torch.Generator
snake_case : Any = self.dummy_cond_unet_upscale
snake_case : Optional[int] = DDPMScheduler()
snake_case : Optional[int] = DDIMScheduler(prediction_type="""v_prediction""" )
snake_case : Optional[Any] = self.dummy_vae
snake_case : str = self.dummy_text_encoder
snake_case : List[Any] = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )
snake_case : Tuple = self.dummy_image.cpu().permute(0 , 2 , 3 , 1 )[0]
snake_case : Any = Image.fromarray(np.uinta(A ) ).convert("""RGB""" ).resize((6_4, 6_4) )
# make sure here that pndm scheduler skips prk
snake_case : Dict = StableDiffusionUpscalePipeline(
unet=A , low_res_scheduler=A , scheduler=A , vae=A , text_encoder=A , tokenizer=A , max_noise_level=3_5_0 , )
snake_case : Union[str, Any] = sd_pipe.to(A )
sd_pipe.set_progress_bar_config(disable=A )
snake_case : Dict = """A painting of a squirrel eating a burger"""
snake_case : Optional[Any] = torch.Generator(device=A ).manual_seed(0 )
snake_case : Any = sd_pipe(
[prompt] , image=A , generator=A , guidance_scale=6.0 , noise_level=2_0 , num_inference_steps=2 , output_type="""np""" , )
snake_case : Union[str, Any] = output.images
snake_case : Union[str, Any] = torch.Generator(device=A ).manual_seed(0 )
snake_case : List[str] = sd_pipe(
[prompt] , image=A , generator=A , guidance_scale=6.0 , noise_level=2_0 , num_inference_steps=2 , output_type="""np""" , return_dict=A , )[0]
snake_case : str = image[0, -3:, -3:, -1]
snake_case : Any = image_from_tuple[0, -3:, -3:, -1]
snake_case : Optional[Any] = low_res_image.size[0] * 4
assert image.shape == (1, expected_height_width, expected_height_width, 3)
snake_case : Union[str, Any] = np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61] )
assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2
def UpperCAmelCase ( self ) -> Dict:
snake_case : Optional[int] = """cpu""" # ensure determinism for the device-dependent torch.Generator
snake_case : Dict = self.dummy_cond_unet_upscale
snake_case : Any = DDPMScheduler()
snake_case : Union[str, Any] = DDIMScheduler(prediction_type="""v_prediction""" )
snake_case : List[str] = self.dummy_vae
snake_case : List[Any] = self.dummy_text_encoder
snake_case : Any = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )
snake_case : str = self.dummy_image.cpu().permute(0 , 2 , 3 , 1 )[0]
snake_case : Optional[Any] = Image.fromarray(np.uinta(A ) ).convert("""RGB""" ).resize((6_4, 6_4) )
# make sure here that pndm scheduler skips prk
snake_case : Union[str, Any] = StableDiffusionUpscalePipeline(
unet=A , low_res_scheduler=A , scheduler=A , vae=A , text_encoder=A , tokenizer=A , max_noise_level=3_5_0 , )
snake_case : Dict = sd_pipe.to(A )
sd_pipe.set_progress_bar_config(disable=A )
snake_case : List[str] = """A painting of a squirrel eating a burger"""
snake_case : str = sd_pipe(
2 * [prompt] , image=2 * [low_res_image] , guidance_scale=6.0 , noise_level=2_0 , num_inference_steps=2 , output_type="""np""" , )
snake_case : Union[str, Any] = output.images
assert image.shape[0] == 2
snake_case : Optional[int] = torch.Generator(device=A ).manual_seed(0 )
snake_case : Tuple = sd_pipe(
[prompt] , image=A , generator=A , num_images_per_prompt=2 , guidance_scale=6.0 , noise_level=2_0 , num_inference_steps=2 , output_type="""np""" , )
snake_case : Tuple = output.images
assert image.shape[0] == 2
@unittest.skipIf(torch_device != """cuda""" , """This test requires a GPU""" )
def UpperCAmelCase ( self ) -> str:
snake_case : str = self.dummy_cond_unet_upscale
snake_case : Tuple = DDPMScheduler()
snake_case : str = DDIMScheduler(prediction_type="""v_prediction""" )
snake_case : str = self.dummy_vae
snake_case : List[Any] = self.dummy_text_encoder
snake_case : Dict = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )
snake_case : Optional[int] = self.dummy_image.cpu().permute(0 , 2 , 3 , 1 )[0]
snake_case : Optional[Any] = Image.fromarray(np.uinta(A ) ).convert("""RGB""" ).resize((6_4, 6_4) )
# put models in fp16, except vae as it overflows in fp16
snake_case : Any = unet.half()
snake_case : List[str] = text_encoder.half()
# make sure here that pndm scheduler skips prk
snake_case : Union[str, Any] = StableDiffusionUpscalePipeline(
unet=A , low_res_scheduler=A , scheduler=A , vae=A , text_encoder=A , tokenizer=A , max_noise_level=3_5_0 , )
snake_case : Dict = sd_pipe.to(A )
sd_pipe.set_progress_bar_config(disable=A )
snake_case : Optional[int] = """A painting of a squirrel eating a burger"""
snake_case : Dict = torch.manual_seed(0 )
snake_case : Tuple = sd_pipe(
[prompt] , image=A , generator=A , num_inference_steps=2 , output_type="""np""" , ).images
snake_case : Optional[Any] = low_res_image.size[0] * 4
assert image.shape == (1, expected_height_width, expected_height_width, 3)
@slow
@require_torch_gpu
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> Union[str, Any]:
# clean up the VRAM after each test
super().tearDown()
gc.collect()
torch.cuda.empty_cache()
def UpperCAmelCase ( self ) -> List[Any]:
snake_case : List[str] = load_image(
"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
"""/sd2-upscale/low_res_cat.png""" )
snake_case : List[Any] = load_numpy(
"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
"""/upsampled_cat.npy""" )
snake_case : Optional[int] = """stabilityai/stable-diffusion-x4-upscaler"""
snake_case : Union[str, Any] = StableDiffusionUpscalePipeline.from_pretrained(A )
pipe.to(A )
pipe.set_progress_bar_config(disable=A )
pipe.enable_attention_slicing()
snake_case : Any = """a cat sitting on a park bench"""
snake_case : Optional[Any] = torch.manual_seed(0 )
snake_case : str = pipe(
prompt=A , image=A , generator=A , output_type="""np""" , )
snake_case : List[Any] = output.images[0]
assert image.shape == (5_1_2, 5_1_2, 3)
assert np.abs(expected_image - image ).max() < 1e-3
def UpperCAmelCase ( self ) -> Dict:
snake_case : Any = load_image(
"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
"""/sd2-upscale/low_res_cat.png""" )
snake_case : Dict = load_numpy(
"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"""
"""/upsampled_cat_fp16.npy""" )
snake_case : Union[str, Any] = """stabilityai/stable-diffusion-x4-upscaler"""
snake_case : int = StableDiffusionUpscalePipeline.from_pretrained(
A , torch_dtype=torch.floataa , )
pipe.to(A )
pipe.set_progress_bar_config(disable=A )
pipe.enable_attention_slicing()
snake_case : int = """a cat sitting on a park bench"""
snake_case : Union[str, Any] = torch.manual_seed(0 )
snake_case : List[str] = pipe(
prompt=A , image=A , generator=A , output_type="""np""" , )
snake_case : Union[str, Any] = output.images[0]
assert image.shape == (5_1_2, 5_1_2, 3)
assert np.abs(expected_image - image ).max() < 5e-1
def UpperCAmelCase ( self ) -> Dict:
torch.cuda.empty_cache()
torch.cuda.reset_max_memory_allocated()
torch.cuda.reset_peak_memory_stats()
snake_case : List[Any] = load_image(
"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
"""/sd2-upscale/low_res_cat.png""" )
snake_case : int = """stabilityai/stable-diffusion-x4-upscaler"""
snake_case : Any = StableDiffusionUpscalePipeline.from_pretrained(
A , torch_dtype=torch.floataa , )
pipe.to(A )
pipe.set_progress_bar_config(disable=A )
pipe.enable_attention_slicing(1 )
pipe.enable_sequential_cpu_offload()
snake_case : List[Any] = """a cat sitting on a park bench"""
snake_case : Optional[Any] = torch.manual_seed(0 )
snake_case : List[Any] = pipe(
prompt=A , image=A , generator=A , num_inference_steps=5 , output_type="""np""" , )
snake_case : Any = torch.cuda.max_memory_allocated()
# make sure that less than 2.9 GB is allocated
assert mem_bytes < 2.9 * 1_0**9
| 684 |
from typing import TYPE_CHECKING
from ...utils import (
OptionalDependencyNotAvailable,
_LazyModule,
is_flax_available,
is_tf_available,
is_torch_available,
)
lowerCamelCase : Tuple = {'configuration_vit_mae': ['VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMAEConfig']}
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : int = [
'VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST',
'ViTMAEForPreTraining',
'ViTMAELayer',
'ViTMAEModel',
'ViTMAEPreTrainedModel',
]
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
lowerCamelCase : Dict = [
'TFViTMAEForPreTraining',
'TFViTMAEModel',
'TFViTMAEPreTrainedModel',
]
if TYPE_CHECKING:
from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig
try:
if not is_torch_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_vit_mae import (
VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
ViTMAEForPreTraining,
ViTMAELayer,
ViTMAEModel,
ViTMAEPreTrainedModel,
)
try:
if not is_tf_available():
raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
pass
else:
from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel
else:
import sys
lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 | 1 |
from typing import TYPE_CHECKING
from ..utils import _LazyModule
lowerCamelCase : Any = {
'config': [
'EXTERNAL_DATA_FORMAT_SIZE_LIMIT',
'OnnxConfig',
'OnnxConfigWithPast',
'OnnxSeq2SeqConfigWithPast',
'PatchingSpec',
],
'convert': ['export', 'validate_model_outputs'],
'features': ['FeaturesManager'],
'utils': ['ParameterFormat', 'compute_serialized_parameters_size'],
}
if TYPE_CHECKING:
from .config import (
EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
OnnxConfig,
OnnxConfigWithPast,
OnnxSeqaSeqConfigWithPast,
PatchingSpec,
)
from .convert import export, validate_model_outputs
from .features import FeaturesManager
from .utils import ParameterFormat, compute_serialized_parameters_size
else:
import sys
lowerCamelCase : int = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
| 684 |
lowerCamelCase : Union[str, Any] = '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'
lowerCamelCase : Tuple = [{'type': 'code', 'content': INSTALL_CONTENT}]
lowerCamelCase : Union[str, Any] = {
'{processor_class}': 'FakeProcessorClass',
'{model_class}': 'FakeModelClass',
'{object_class}': 'FakeObjectClass',
}
| 684 | 1 |
import os
import random
import sys
from . import cryptomath_module as cryptomath
from . import rabin_miller
lowerCamelCase : List[str] = 3
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
print("""Generating primitive root of p""" )
while True:
snake_case : Optional[int] = random.randrange(3 ,lowercase )
if pow(lowercase ,2 ,lowercase ) == 1:
continue
if pow(lowercase ,lowercase ,lowercase ) == 1:
continue
return g
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> tuple[tuple[int, int, int, int], tuple[int, int]]:
print("""Generating prime p...""" )
snake_case : Optional[int] = rabin_miller.generate_large_prime(lowercase ) # select large prime number.
snake_case : Optional[int] = primitive_root(lowercase ) # one primitive root on modulo p.
snake_case : Optional[Any] = random.randrange(3 ,lowercase ) # private_key -> have to be greater than 2 for safety.
snake_case : Tuple = cryptomath.find_mod_inverse(pow(lowercase ,lowercase ,lowercase ) ,lowercase )
snake_case : str = (key_size, e_a, e_a, p)
snake_case : Optional[Any] = (key_size, d)
return public_key, private_key
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> None:
if os.path.exists(f"""{name}_pubkey.txt""" ) or os.path.exists(f"""{name}_privkey.txt""" ):
print("""\nWARNING:""" )
print(
f"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
"""Use a different name or delete these files and re-run this program.""" )
sys.exit()
snake_case , snake_case : Optional[Any] = generate_key(lowercase )
print(f"""\nWriting public key to file {name}_pubkey.txt...""" )
with open(f"""{name}_pubkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}""" )
print(f"""Writing private key to file {name}_privkey.txt...""" )
with open(f"""{name}_privkey.txt""" ,"""w""" ) as fo:
fo.write(f"""{private_key[0]},{private_key[1]}""" )
def SCREAMING_SNAKE_CASE__ ( ) -> None:
print("""Making key files...""" )
make_key_files("""elgamal""" ,2048 )
print("""Key files generation successful""" )
if __name__ == "__main__":
main()
| 684 |
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {'vocab_file': 'spm_char.model'}
lowerCamelCase : List[str] = {
'vocab_file': {
'microsoft/speecht5_asr': 'https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model',
'microsoft/speecht5_tts': 'https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model',
'microsoft/speecht5_vc': 'https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model',
}
}
lowerCamelCase : List[Any] = {
'microsoft/speecht5_asr': 1_0_2_4,
'microsoft/speecht5_tts': 1_0_2_4,
'microsoft/speecht5_vc': 1_0_2_4,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A="<s>" , A="</s>" , A="<unk>" , A="<pad>" , A = None , **A , ) -> None:
snake_case : List[str] = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=A , eos_token=A , unk_token=A , pad_token=A , sp_model_kwargs=self.sp_model_kwargs , **A , )
snake_case : Tuple = vocab_file
snake_case : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(A )
@property
def UpperCAmelCase ( self ) -> List[Any]:
return self.sp_model.get_piece_size()
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = {self.convert_ids_to_tokens(A ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __getstate__( self ) -> List[str]:
snake_case : Optional[Any] = self.__dict__.copy()
snake_case : Optional[Any] = None
return state
def __setstate__( self , A ) -> Tuple:
snake_case : Any = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs""" ):
snake_case : List[Any] = {}
snake_case : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def UpperCAmelCase ( self , A ) -> List[str]:
return self.sp_model.encode(A , out_type=A )
def UpperCAmelCase ( self , A ) -> Tuple:
return self.sp_model.piece_to_id(A )
def UpperCAmelCase ( self , A ) -> int:
snake_case : Union[str, Any] = self.sp_model.IdToPiece(A )
return token
def UpperCAmelCase ( self , A ) -> Tuple:
snake_case : Optional[int] = []
snake_case : str = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(A ) + token
snake_case : Dict = []
else:
current_sub_tokens.append(A )
out_string += self.sp_model.decode(A )
return out_string.strip()
def UpperCAmelCase ( self , A , A=None ) -> List[int]:
if token_ids_a is None:
return token_ids_a + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_a + token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[int]:
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=A , token_ids_a=A , already_has_special_tokens=A )
snake_case : Any = [1]
if token_ids_a is None:
return ([0] * len(A )) + suffix_ones
return ([0] * len(A )) + ([0] * len(A )) + suffix_ones
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Optional[Any] = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(A ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , A )
elif not os.path.isfile(self.vocab_file ):
with open(A , """wb""" ) as fi:
snake_case : Union[str, Any] = self.sp_model.serialized_model_proto()
fi.write(A )
return (out_vocab_file,)
| 684 | 1 |
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple
import sentencepiece as spm
from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {'vocab_file': 'spm_char.model'}
lowerCamelCase : List[str] = {
'vocab_file': {
'microsoft/speecht5_asr': 'https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model',
'microsoft/speecht5_tts': 'https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model',
'microsoft/speecht5_vc': 'https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model',
}
}
lowerCamelCase : List[Any] = {
'microsoft/speecht5_asr': 1_0_2_4,
'microsoft/speecht5_tts': 1_0_2_4,
'microsoft/speecht5_vc': 1_0_2_4,
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = VOCAB_FILES_NAMES
_snake_case = PRETRAINED_VOCAB_FILES_MAP
_snake_case = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
_snake_case = ["""input_ids""", """attention_mask"""]
def __init__( self , A , A="<s>" , A="</s>" , A="<unk>" , A="<pad>" , A = None , **A , ) -> None:
snake_case : List[str] = {} if sp_model_kwargs is None else sp_model_kwargs
super().__init__(
bos_token=A , eos_token=A , unk_token=A , pad_token=A , sp_model_kwargs=self.sp_model_kwargs , **A , )
snake_case : Tuple = vocab_file
snake_case : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(A )
@property
def UpperCAmelCase ( self ) -> List[Any]:
return self.sp_model.get_piece_size()
def UpperCAmelCase ( self ) -> Optional[int]:
snake_case : Any = {self.convert_ids_to_tokens(A ): i for i in range(self.vocab_size )}
vocab.update(self.added_tokens_encoder )
return vocab
def __getstate__( self ) -> List[str]:
snake_case : Optional[Any] = self.__dict__.copy()
snake_case : Optional[Any] = None
return state
def __setstate__( self , A ) -> Tuple:
snake_case : Any = d
# for backward compatibility
if not hasattr(self , """sp_model_kwargs""" ):
snake_case : List[Any] = {}
snake_case : Any = spm.SentencePieceProcessor(**self.sp_model_kwargs )
self.sp_model.Load(self.vocab_file )
def UpperCAmelCase ( self , A ) -> List[str]:
return self.sp_model.encode(A , out_type=A )
def UpperCAmelCase ( self , A ) -> Tuple:
return self.sp_model.piece_to_id(A )
def UpperCAmelCase ( self , A ) -> int:
snake_case : Union[str, Any] = self.sp_model.IdToPiece(A )
return token
def UpperCAmelCase ( self , A ) -> Tuple:
snake_case : Optional[int] = []
snake_case : str = """"""
for token in tokens:
# make sure that special tokens are not decoded using sentencepiece model
if token in self.all_special_tokens:
out_string += self.sp_model.decode(A ) + token
snake_case : Dict = []
else:
current_sub_tokens.append(A )
out_string += self.sp_model.decode(A )
return out_string.strip()
def UpperCAmelCase ( self , A , A=None ) -> List[int]:
if token_ids_a is None:
return token_ids_a + [self.eos_token_id]
# We don't expect to process pairs, but leave the pair logic for API consistency
return token_ids_a + token_ids_a + [self.eos_token_id]
def UpperCAmelCase ( self , A , A = None , A = False ) -> List[int]:
if already_has_special_tokens:
return super().get_special_tokens_mask(
token_ids_a=A , token_ids_a=A , already_has_special_tokens=A )
snake_case : Any = [1]
if token_ids_a is None:
return ([0] * len(A )) + suffix_ones
return ([0] * len(A )) + ([0] * len(A )) + suffix_ones
def UpperCAmelCase ( self , A , A = None ) -> Tuple[str]:
if not os.path.isdir(A ):
logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" )
return
snake_case : Optional[Any] = os.path.join(
A , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
if os.path.abspath(self.vocab_file ) != os.path.abspath(A ) and os.path.isfile(self.vocab_file ):
copyfile(self.vocab_file , A )
elif not os.path.isfile(self.vocab_file ):
with open(A , """wb""" ) as fi:
snake_case : Union[str, Any] = self.sp_model.serialized_model_proto()
fi.write(A )
return (out_vocab_file,)
| 684 |
from ...configuration_utils import PretrainedConfig
from ...utils import logging
lowerCamelCase : Any = logging.get_logger(__name__)
lowerCamelCase : Optional[int] = {
'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/config.json',
}
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = """gpt_neox_japanese"""
def __init__( self , A=3_2_0_0_0 , A=2_5_6_0 , A=3_2 , A=3_2 , A=4 , A="gelu" , A=1.00 , A=1_0_0_0_0 , A=2_0_4_8 , A=0.02 , A=1e-5 , A=True , A=3_1_9_9_6 , A=3_1_9_9_9 , A=0.1 , A=0.0 , **A , ) -> str:
super().__init__(bos_token_id=A , eos_token_id=A , **A )
snake_case : Optional[Any] = vocab_size
snake_case : Optional[Any] = max_position_embeddings
snake_case : Union[str, Any] = hidden_size
snake_case : Union[str, Any] = num_hidden_layers
snake_case : Optional[int] = num_attention_heads
snake_case : Optional[int] = intermediate_multiple_size
snake_case : int = hidden_act
snake_case : str = rotary_pct
snake_case : Optional[Any] = rotary_emb_base
snake_case : Any = initializer_range
snake_case : Any = layer_norm_eps
snake_case : Optional[Any] = use_cache
snake_case : Tuple = attention_dropout
snake_case : Tuple = hidden_dropout
| 684 | 1 |
from __future__ import annotations
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase = None ,lowercase = None ) -> None:
if start is None:
snake_case : List[str] = 0
if end is None:
snake_case : Any = len(lowercase ) - 1
if start >= end:
return
snake_case : Union[str, Any] = (start + end) // 2
slowsort(lowercase ,lowercase ,lowercase )
slowsort(lowercase ,mid + 1 ,lowercase )
if sequence[end] < sequence[mid]:
snake_case , snake_case : Optional[Any] = sequence[mid], sequence[end]
slowsort(lowercase ,lowercase ,end - 1 )
if __name__ == "__main__":
from doctest import testmod
testmod()
| 684 |
def SCREAMING_SNAKE_CASE__ ( lowercase ) -> int:
snake_case : Optional[Any] = hex_num.strip()
if not hex_num:
raise ValueError("""No value was passed to the function""" )
snake_case : Any = hex_num[0] == """-"""
if is_negative:
snake_case : int = hex_num[1:]
try:
snake_case : List[Any] = int(lowercase ,16 )
except ValueError:
raise ValueError("""Invalid value was passed to the function""" )
snake_case : Dict = """"""
while int_num > 0:
snake_case : Dict = str(int_num % 2 ) + bin_str
int_num >>= 1
return int(("""-""" + bin_str) if is_negative else bin_str )
if __name__ == "__main__":
import doctest
doctest.testmod()
| 684 | 1 |
import logging
import sys
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Union
import librosa
import torch
from datasets import DatasetDict, load_dataset
from packaging import version
from torch import nn
from transformers import (
HfArgumentParser,
Trainer,
TrainingArguments,
WavaVecaConfig,
WavaVecaFeatureExtractor,
WavaVecaForPreTraining,
is_apex_available,
trainer_utils,
)
from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices
if is_apex_available():
from apex import amp
if version.parse(version.parse(torch.__version__).base_version) >= version.parse('1.6'):
lowerCamelCase : Dict = True
from torch.cuda.amp import autocast
lowerCamelCase : List[Any] = logging.getLogger(__name__)
@dataclass
class __lowercase :
"""simple docstring"""
_snake_case = field(
metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""} )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""} , )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """Whether to freeze the feature extractor layers of the model."""} )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """Whether to log verbose messages or not."""} , )
_snake_case = field(
default=2.0 , metadata={"""help""": """Maximum temperature for gumbel softmax."""} )
_snake_case = field(
default=0.5 , metadata={"""help""": """Minimum temperature for gumbel softmax."""} )
_snake_case = field(
default=0.999_995 , metadata={"""help""": """Decay of gumbel temperature during training."""} )
def SCREAMING_SNAKE_CASE__ ( lowercase ,lowercase ) -> Tuple:
logging.basicConfig(
format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" ,datefmt="""%m/%d/%Y %H:%M:%S""" ,handlers=[logging.StreamHandler(sys.stdout )] ,)
snake_case : int = logging.WARNING
if model_args.verbose_logging:
snake_case : List[str] = logging.DEBUG
elif trainer_utils.is_main_process(training_args.local_rank ):
snake_case : Any = logging.INFO
logger.setLevel(lowercase )
@dataclass
class __lowercase :
"""simple docstring"""
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """The name of the dataset to use (via the datasets library)."""} )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """The configuration name of the dataset to use (via the datasets library)."""} )
_snake_case = field(
default="""train""" , metadata={
"""help""": """The name of the training data set split to use (via the datasets library). Defaults to 'train'"""
} , )
_snake_case = field(
default="""validation""" , metadata={
"""help""": (
"""The name of the validation data set split to use (via the datasets library). Defaults to 'validation'"""
)
} , )
_snake_case = field(
default="""file""" , metadata={"""help""": """Column in the dataset that contains speech file path. Defaults to 'file'"""} , )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """Overwrite the cached preprocessed datasets or not."""} )
_snake_case = field(
default=1 , metadata={
"""help""": """The percentage of the train set used as validation set in case there's no validation split"""
} , )
_snake_case = field(
default=UpperCamelCase__ , metadata={"""help""": """The number of processes to use for the preprocessing."""} , )
_snake_case = field(
default=20.0 , metadata={"""help""": """Filter audio files that are longer than `max_duration_in_seconds` seconds"""} )
@dataclass
class __lowercase :
"""simple docstring"""
_snake_case = 42
_snake_case = 42
_snake_case = "longest"
_snake_case = None
_snake_case = None
def __call__( self , A ) -> Dict[str, torch.Tensor]:
# reformat list to dict and set to pytorch format
snake_case : Dict = self.feature_extractor.pad(
A , max_length=self.max_length , padding=self.padding , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors="""pt""" , )
snake_case : Tuple = self.model._get_feat_extract_output_lengths(batch["""input_values"""].shape[-1] )
snake_case : Any = batch["""input_values"""].shape[0]
# make sure that no loss is computed on padded inputs
if batch["attention_mask"] is not None:
# compute real output lengths according to convolution formula
snake_case : Optional[int] = self.model._get_feat_extract_output_lengths(batch["""attention_mask"""].sum(-1 ) ).to(
torch.long )
snake_case : Optional[Any] = torch.zeros(
(batch_size, mask_indices_seq_length) , dtype=torch.long , device=batch["""input_values"""].device )
# these two operations makes sure that all values
# before the output lengths indices are attended to
snake_case : List[str] = 1
snake_case : str = attention_mask.flip([-1] ).cumsum(-1 ).flip([-1] ).bool()
# sample randomly masked indices
snake_case : Tuple = _compute_mask_indices(
(batch_size, mask_indices_seq_length) , self.model.config.mask_time_prob , self.model.config.mask_time_length , attention_mask=A , min_masks=2 , )
return batch
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
def __init__( self , *A , A=1 , A=0 , A=1.0 , **A ) -> int:
super().__init__(*A , **A )
snake_case : Optional[Any] = 0
snake_case : Union[str, Any] = max_gumbel_temp
snake_case : List[str] = min_gumbel_temp
snake_case : List[Any] = gumbel_temp_decay
def UpperCAmelCase ( self , A , A ) -> torch.Tensor:
model.train()
snake_case : Optional[Any] = self._prepare_inputs(A )
if self.use_amp:
with autocast():
snake_case : int = self.compute_loss(A , A )
else:
snake_case : Tuple = self.compute_loss(A , A )
if self.args.n_gpu > 1 or self.deepspeed:
if model.module.config.ctc_loss_reduction == "mean":
snake_case : Union[str, Any] = loss.mean()
elif model.module.config.ctc_loss_reduction == "sum":
snake_case : Optional[int] = loss.sum() / (inputs["""mask_time_indices"""]).sum()
else:
raise ValueError(f"""{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']""" )
if self.args.gradient_accumulation_steps > 1:
snake_case : Union[str, Any] = loss / self.args.gradient_accumulation_steps
if self.use_amp:
self.scaler.scale(A ).backward()
elif self.use_apex:
with amp.scale_loss(A , self.optimizer ) as scaled_loss:
scaled_loss.backward()
elif self.deepspeed:
self.deepspeed.backward(A )
else:
loss.backward()
self.num_update_step += 1
# make sure gumbel softmax temperature is decayed
if self.args.n_gpu > 1 or self.deepspeed:
model.module.set_gumbel_temperature(
max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) )
else:
model.set_gumbel_temperature(
max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) )
return loss.detach()
def SCREAMING_SNAKE_CASE__ ( ) -> List[Any]:
# See all possible arguments in src/transformers/training_args.py
# or by passing the --help flag to this script.
# We now keep distinct sets of args, for a cleaner separation of concerns.
snake_case : str = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) )
snake_case , snake_case , snake_case : List[str] = parser.parse_args_into_dataclasses()
configure_logger(lowercase ,lowercase )
# Downloading and loading a dataset from the hub.
snake_case : Tuple = load_dataset(data_args.dataset_name ,data_args.dataset_config_name ,cache_dir=model_args.cache_dir )
if "validation" not in datasets.keys():
# make sure only "validation" and "train" keys remain"
snake_case : List[Any] = DatasetDict()
snake_case : Union[str, Any] = load_dataset(
data_args.dataset_name ,data_args.dataset_config_name ,split=f"""{data_args.train_split_name}[:{data_args.validation_split_percentage}%]""" ,cache_dir=model_args.cache_dir ,)
snake_case : str = load_dataset(
data_args.dataset_name ,data_args.dataset_config_name ,split=f"""{data_args.train_split_name}[{data_args.validation_split_percentage}%:]""" ,cache_dir=model_args.cache_dir ,)
else:
# make sure only "validation" and "train" keys remain"
snake_case : Optional[int] = DatasetDict()
snake_case : List[str] = load_dataset(
data_args.dataset_name ,data_args.dataset_config_name ,split="""validation""" ,cache_dir=model_args.cache_dir ,)
snake_case : Optional[int] = load_dataset(
data_args.dataset_name ,data_args.dataset_config_name ,split=f"""{data_args.train_split_name}""" ,cache_dir=model_args.cache_dir ,)
# only normalized-inputs-training is supported
snake_case : Dict = WavaVecaFeatureExtractor.from_pretrained(
model_args.model_name_or_path ,cache_dir=model_args.cache_dir ,do_normalize=lowercase )
def prepare_dataset(lowercase ):
# check that all files have the correct sampling rate
snake_case , snake_case : str = librosa.load(batch[data_args.speech_file_column] ,sr=feature_extractor.sampling_rate )
return batch
# load audio files into numpy arrays
snake_case : List[str] = datasets.map(
lowercase ,num_proc=data_args.preprocessing_num_workers ,remove_columns=datasets["""train"""].column_names )
# filter audio files that are too long
snake_case : Union[str, Any] = vectorized_datasets.filter(
lambda lowercase : len(data["""speech"""] ) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate ) )
def normalize(lowercase ):
return feature_extractor(batch["""speech"""] ,sampling_rate=feature_extractor.sampling_rate )
# normalize and transform to `BatchFeatures`
snake_case : str = vectorized_datasets.map(
lowercase ,batched=lowercase ,num_proc=data_args.preprocessing_num_workers ,load_from_cache_file=not data_args.overwrite_cache ,remove_columns=vectorized_datasets["""train"""].column_names ,)
# pretraining is only supported for "newer" stable layer norm architecture
# apply_spec_augment has to be True, mask_feature_prob has to be 0.0
snake_case : Union[str, Any] = WavaVecaConfig.from_pretrained(
model_args.model_name_or_path ,cache_dir=model_args.cache_dir ,gradient_checkpointing=training_args.gradient_checkpointing ,)
if not config.do_stable_layer_norm or config.feat_extract_norm != "layer":
raise ValueError(
"""PreTraining is only supported for ``config.do_stable_layer_norm=True`` and"""
""" ``config.feat_extract_norm='layer'""" )
snake_case : Union[str, Any] = WavaVecaForPreTraining(lowercase )
snake_case : List[str] = DataCollatorForWavaVecaPretraining(model=lowercase ,feature_extractor=lowercase )
snake_case : str = WavaVecaPreTrainer(
model=lowercase ,data_collator=lowercase ,args=lowercase ,train_dataset=vectorized_datasets["""train"""] ,eval_dataset=vectorized_datasets["""validation"""] ,tokenizer=lowercase ,max_gumbel_temp=model_args.max_gumbel_temperature ,min_gumbel_temp=model_args.min_gumbel_temperature ,gumbel_temp_decay=model_args.gumbel_temperature_decay ,)
trainer.train()
if __name__ == "__main__":
main()
| 684 |
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 : Optional[int] = logging.get_logger(__name__)
class __lowercase (UpperCamelCase__ ):
"""simple docstring"""
_snake_case = ["""pixel_values"""]
def __init__( self , A = True , A = None , A = PIL.Image.BICUBIC , A = True , A = None , A = 1 / 2_5_5 , A = True , A = True , A = None , A = None , **A , ) -> None:
super().__init__(**A )
snake_case : int = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
snake_case : int = get_size_dict(A )
snake_case : Optional[Any] = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
snake_case : Dict = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = do_resize
snake_case : str = size
snake_case : Tuple = resample
snake_case : Any = do_center_crop
snake_case : Tuple = crop_size
snake_case : int = do_rescale
snake_case : Dict = rescale_factor
snake_case : Union[str, Any] = do_normalize
snake_case : Union[str, Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
snake_case : Optional[Any] = image_std if image_std is not None else IMAGENET_STANDARD_STD
def UpperCAmelCase ( self , A , A , A = PIL.Image.BICUBIC , A = None , **A , ) -> np.ndarray:
snake_case : Dict = get_size_dict(A )
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(
A , size=(size["""height"""], size["""width"""]) , resample=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> np.ndarray:
snake_case : Any = get_size_dict(A )
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(A , size=(size["""height"""], size["""width"""]) , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A = None , **A , ) -> Tuple:
return rescale(A , scale=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A , A , A = None , **A , ) -> np.ndarray:
return normalize(A , mean=A , std=A , data_format=A , **A )
def UpperCAmelCase ( self , A , A = None , A = None , A=None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = None , A = ChannelDimension.FIRST , **A , ) -> PIL.Image.Image:
snake_case : str = do_resize if do_resize is not None else self.do_resize
snake_case : Dict = resample if resample is not None else self.resample
snake_case : Dict = do_center_crop if do_center_crop is not None else self.do_center_crop
snake_case : Tuple = do_rescale if do_rescale is not None else self.do_rescale
snake_case : Optional[Any] = rescale_factor if rescale_factor is not None else self.rescale_factor
snake_case : List[str] = do_normalize if do_normalize is not None else self.do_normalize
snake_case : int = image_mean if image_mean is not None else self.image_mean
snake_case : List[str] = image_std if image_std is not None else self.image_std
snake_case : Dict = size if size is not None else self.size
snake_case : Tuple = get_size_dict(A )
snake_case : Dict = crop_size if crop_size is not None else self.crop_size
snake_case : List[str] = get_size_dict(A , param_name="""crop_size""" )
snake_case : int = make_list_of_images(A )
if not valid_images(A ):
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.
snake_case : Optional[Any] = [to_numpy_array(A ) for image in images]
if do_resize:
snake_case : Dict = [self.resize(image=A , size=A , resample=A ) for image in images]
if do_center_crop:
snake_case : List[str] = [self.center_crop(image=A , size=A ) for image in images]
if do_rescale:
snake_case : List[str] = [self.rescale(image=A , scale=A ) for image in images]
if do_normalize:
snake_case : str = [self.normalize(image=A , mean=A , std=A ) for image in images]
snake_case : Union[str, Any] = [to_channel_dimension_format(A , A ) for image in images]
snake_case : List[Any] = {"""pixel_values""": images}
return BatchFeature(data=A , tensor_type=A )
| 684 | 1 |
import re
import string
import numpy as np
import datasets
lowerCamelCase : Any = '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'
lowerCamelCase : Optional[Any] = '\nArgs:\n predictions: List of predicted texts.\n references: List of reference texts.\n regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n ignore when calculating the exact matches. Note: these regexes are removed\n from the input data before the changes based on the options below (e.g. ignore_case,\n ignore_punctuation, ignore_numbers) are applied.\n ignore_case: Boolean, defaults to False. If true, turns everything\n to lowercase so that capitalization differences are ignored.\n ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n comparing predictions and references.\n ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n comparing predictions and references.\nReturns:\n exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n >>> exact_match = datasets.load_metric("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds)\n >>> print(round(results["exact_match"], 1))\n 25.0\n\n >>> exact_match = datasets.load_metric("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n >>> print(round(results["exact_match"], 1))\n 50.0\n\n\n >>> exact_match = datasets.load_metric("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n >>> print(round(results["exact_match"], 1))\n 75.0\n\n >>> exact_match = datasets.load_metric("exact_match")\n >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n >>> preds = ["cat?", "theater", "yelling", "agent"]\n >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n >>> print(round(results["exact_match"], 1))\n 100.0\n\n >>> exact_match = datasets.load_metric("exact_match")\n >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n >>> results = exact_match.compute(references=refs, predictions=preds)\n >>> print(round(results["exact_match"], 1))\n 33.3\n\n'
lowerCamelCase : List[Any] = '\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION )
class __lowercase (datasets.Metric ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> Union[str, Any]:
return datasets.MetricInfo(
description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(
{
"""predictions""": datasets.Value("""string""" , id="""sequence""" ),
"""references""": datasets.Value("""string""" , id="""sequence""" ),
} ) , reference_urls=[] , )
def UpperCAmelCase ( self , A , A , A=None , A=False , A=False , A=False , ) -> str:
if regexes_to_ignore is not None:
for s in regexes_to_ignore:
snake_case : Optional[int] = np.array([re.sub(A , """""" , A ) for x in predictions] )
snake_case : Optional[int] = np.array([re.sub(A , """""" , A ) for x in references] )
else:
snake_case : List[Any] = np.asarray(A )
snake_case : List[Any] = np.asarray(A )
if ignore_case:
snake_case : List[Any] = np.char.lower(A )
snake_case : List[str] = np.char.lower(A )
if ignore_punctuation:
snake_case : List[str] = string.punctuation.maketrans("""""" , """""" , string.punctuation )
snake_case : Dict = np.char.translate(A , table=A )
snake_case : Optional[int] = np.char.translate(A , table=A )
if ignore_numbers:
snake_case : Dict = string.digits.maketrans("""""" , """""" , string.digits )
snake_case : List[str] = np.char.translate(A , table=A )
snake_case : Tuple = np.char.translate(A , table=A )
snake_case : Dict = predictions == references
return {"exact_match": np.mean(A ) * 1_0_0}
| 684 |
import inspect
import unittest
class __lowercase (unittest.TestCase ):
"""simple docstring"""
def UpperCAmelCase ( self ) -> List[Any]:
try:
import diffusers # noqa: F401
except ImportError:
assert False
def UpperCAmelCase ( self ) -> Tuple:
import diffusers
from diffusers.dependency_versions_table import deps
snake_case : List[str] = inspect.getmembers(A , inspect.isclass )
for cls_name, cls_module in all_classes:
if "dummy_" in cls_module.__module__:
for backend in cls_module._backends:
if backend == "k_diffusion":
snake_case : Tuple = """k-diffusion"""
elif backend == "invisible_watermark":
snake_case : Optional[int] = """invisible-watermark"""
assert backend in deps, f"""{backend} is not in the deps table!"""
| 684 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.