code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
'''simple docstring''' import math from typing import Dict, Iterable, List, Optional, Tuple, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, get_image_size, is_torch_available, is_torch_tensor, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_torch_available(): import torch if is_vision_available(): import PIL __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) def UpperCAmelCase_ ( __lowercase : np.ndarray , __lowercase : Union[int, Iterable[int]] , __lowercase : bool , __lowercase : int ) -> Tuple[int, int]: '''simple docstring''' def constraint_to_multiple_of(__lowercase : Union[str, Any] , __lowercase : List[str] , __lowercase : List[str]=0 , __lowercase : Any=None ): _UpperCAmelCase = round(val / multiple ) * multiple if max_val is not None and x > max_val: _UpperCAmelCase = math.floor(val / multiple ) * multiple if x < min_val: _UpperCAmelCase = math.ceil(val / multiple ) * multiple return x _UpperCAmelCase = (output_size, output_size) if isinstance(__lowercase , __lowercase ) else output_size _UpperCAmelCase , _UpperCAmelCase = get_image_size(__lowercase ) _UpperCAmelCase , _UpperCAmelCase = output_size # determine new height and width _UpperCAmelCase = output_height / input_height _UpperCAmelCase = output_width / input_width if keep_aspect_ratio: # scale as little as possible if abs(1 - scale_width ) < abs(1 - scale_height ): # fit width _UpperCAmelCase = scale_width else: # fit height _UpperCAmelCase = scale_height _UpperCAmelCase = constraint_to_multiple_of(scale_height * input_height , multiple=__lowercase ) _UpperCAmelCase = constraint_to_multiple_of(scale_width * input_width , multiple=__lowercase ) return (new_height, new_width) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : List[Any] = ["""pixel_values"""] def __init__( self : int , snake_case_ : bool = True , snake_case_ : Dict[str, int] = None , snake_case_ : PILImageResampling = PILImageResampling.BILINEAR , snake_case_ : bool = False , snake_case_ : int = 1 , snake_case_ : bool = True , snake_case_ : Union[int, float] = 1 / 2_5_5 , snake_case_ : bool = True , snake_case_ : Optional[Union[float, List[float]]] = None , snake_case_ : Optional[Union[float, List[float]]] = None , **snake_case_ : Dict , ): super().__init__(**snake_case_ ) _UpperCAmelCase = size if size is not None else {"height": 3_8_4, "width": 3_8_4} _UpperCAmelCase = get_size_dict(snake_case_ ) _UpperCAmelCase = do_resize _UpperCAmelCase = size _UpperCAmelCase = keep_aspect_ratio _UpperCAmelCase = ensure_multiple_of _UpperCAmelCase = resample _UpperCAmelCase = do_rescale _UpperCAmelCase = rescale_factor _UpperCAmelCase = do_normalize _UpperCAmelCase = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN _UpperCAmelCase = image_std if image_std is not None else IMAGENET_STANDARD_STD def lowercase ( self : Any , snake_case_ : np.ndarray , snake_case_ : Dict[str, int] , snake_case_ : bool = False , snake_case_ : int = 1 , snake_case_ : PILImageResampling = PILImageResampling.BICUBIC , snake_case_ : Optional[Union[str, ChannelDimension]] = None , **snake_case_ : int , ): _UpperCAmelCase = get_size_dict(snake_case_ ) if "height" not in size or "width" not in size: raise ValueError(f'The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}' ) _UpperCAmelCase = get_resize_output_image_size( snake_case_ , output_size=(size["height"], size["width"]) , keep_aspect_ratio=snake_case_ , multiple=snake_case_ , ) return resize(snake_case_ , size=snake_case_ , resample=snake_case_ , data_format=snake_case_ , **snake_case_ ) def lowercase ( self : List[str] , snake_case_ : np.ndarray , snake_case_ : Union[int, float] , snake_case_ : Optional[Union[str, ChannelDimension]] = None , **snake_case_ : Tuple , ): return rescale(snake_case_ , scale=snake_case_ , data_format=snake_case_ , **snake_case_ ) def lowercase ( self : List[Any] , snake_case_ : np.ndarray , snake_case_ : Union[float, List[float]] , snake_case_ : Union[float, List[float]] , snake_case_ : Optional[Union[str, ChannelDimension]] = None , **snake_case_ : List[str] , ): return normalize(snake_case_ , mean=snake_case_ , std=snake_case_ , data_format=snake_case_ , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : ImageInput , snake_case_ : bool = None , snake_case_ : int = None , snake_case_ : bool = None , snake_case_ : int = None , snake_case_ : PILImageResampling = None , snake_case_ : bool = None , snake_case_ : float = None , snake_case_ : bool = None , snake_case_ : Optional[Union[float, List[float]]] = None , snake_case_ : Optional[Union[float, List[float]]] = None , snake_case_ : Optional[Union[str, TensorType]] = None , snake_case_ : ChannelDimension = ChannelDimension.FIRST , **snake_case_ : List[str] , ): _UpperCAmelCase = do_resize if do_resize is not None else self.do_resize _UpperCAmelCase = size if size is not None else self.size _UpperCAmelCase = get_size_dict(snake_case_ ) _UpperCAmelCase = keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio _UpperCAmelCase = ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of _UpperCAmelCase = resample if resample is not None else self.resample _UpperCAmelCase = do_rescale if do_rescale is not None else self.do_rescale _UpperCAmelCase = rescale_factor if rescale_factor is not None else self.rescale_factor _UpperCAmelCase = do_normalize if do_normalize is not None else self.do_normalize _UpperCAmelCase = image_mean if image_mean is not None else self.image_mean _UpperCAmelCase = image_std if image_std is not None else self.image_std _UpperCAmelCase = make_list_of_images(snake_case_ ) if not valid_images(snake_case_ ): raise ValueError( "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, " "torch.Tensor, tf.Tensor or jax.ndarray." ) 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_rescale and rescale_factor is None: raise ValueError("Rescale factor must be specified if do_rescale is True." ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("Image mean and std must be specified if do_normalize is True." ) # All transformations expect numpy arrays. _UpperCAmelCase = [to_numpy_array(snake_case_ ) for image in images] if do_resize: _UpperCAmelCase = [self.resize(image=snake_case_ , size=snake_case_ , resample=snake_case_ ) for image in images] if do_rescale: _UpperCAmelCase = [self.rescale(image=snake_case_ , scale=snake_case_ ) for image in images] if do_normalize: _UpperCAmelCase = [self.normalize(image=snake_case_ , mean=snake_case_ , std=snake_case_ ) for image in images] _UpperCAmelCase = [to_channel_dimension_format(snake_case_ , snake_case_ ) for image in images] _UpperCAmelCase = {"pixel_values": images} return BatchFeature(data=snake_case_ , tensor_type=snake_case_ ) def lowercase ( self : Optional[int] , snake_case_ : Any , snake_case_ : List[Tuple] = None ): _UpperCAmelCase = outputs.logits # Resize logits and compute semantic segmentation maps if target_sizes is not None: if len(snake_case_ ) != len(snake_case_ ): raise ValueError( "Make sure that you pass in as many target sizes as the batch dimension of the logits" ) if is_torch_tensor(snake_case_ ): _UpperCAmelCase = target_sizes.numpy() _UpperCAmelCase = [] for idx in range(len(snake_case_ ) ): _UpperCAmelCase = torch.nn.functional.interpolate( logits[idx].unsqueeze(dim=0 ) , size=target_sizes[idx] , mode="bilinear" , align_corners=snake_case_ ) _UpperCAmelCase = resized_logits[0].argmax(dim=0 ) semantic_segmentation.append(snake_case_ ) else: _UpperCAmelCase = logits.argmax(dim=1 ) _UpperCAmelCase = [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0] )] return semantic_segmentation
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' import os from typing import Optional import fsspec from fsspec.archive import AbstractArchiveFileSystem from fsspec.utils import DEFAULT_BLOCK_SIZE class A_ ( lowerCAmelCase_ ): _lowerCamelCase : List[str] = """""" _lowerCamelCase : str = ( None # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz ) _lowerCamelCase : str = None # compression type in fsspec. ex: "gzip" _lowerCamelCase : str = None # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz def __init__( self : Any , snake_case_ : str = "" , snake_case_ : Optional[str] = None , snake_case_ : Optional[dict] = None , **snake_case_ : str ): super().__init__(self , **snake_case_ ) # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode _UpperCAmelCase = fsspec.open( snake_case_ , mode="rb" , protocol=snake_case_ , compression=self.compression , client_kwargs={ "requote_redirect_url": False, # see https://github.com/huggingface/datasets/pull/5459 "trust_env": True, # Enable reading proxy env variables. **(target_options or {}).pop("client_kwargs" , {} ), # To avoid issues if it was already passed. } , **(target_options or {}) , ) _UpperCAmelCase = os.path.basename(self.file.path.split("::" )[0] ) _UpperCAmelCase = ( self.compressed_name[: self.compressed_name.rindex("." )] if "." in self.compressed_name else self.compressed_name ) _UpperCAmelCase = None @classmethod def lowercase ( cls : int , snake_case_ : str ): # compressed file paths are always relative to the archive root return super()._strip_protocol(snake_case_ ).lstrip("/" ) def lowercase ( self : Union[str, Any] ): if self.dir_cache is None: _UpperCAmelCase = {**self.file.fs.info(self.file.path ), "name": self.uncompressed_name} _UpperCAmelCase = {f["name"]: f} def lowercase ( self : Any , snake_case_ : str ): return self.file.open().read() def lowercase ( self : Optional[int] , snake_case_ : str , snake_case_ : str = "rb" , snake_case_ : Tuple=None , snake_case_ : Dict=True , snake_case_ : Optional[int]=None , **snake_case_ : Tuple , ): _UpperCAmelCase = self._strip_protocol(snake_case_ ) if mode != "rb": raise ValueError(f'Tried to read with mode {mode} on file {self.file.path} opened with mode \'rb\'' ) return self.file.open() class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = """bz2""" _lowerCamelCase : Tuple = """bz2""" _lowerCamelCase : Union[str, Any] = """.bz2""" class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Dict = """gzip""" _lowerCamelCase : Optional[Any] = """gzip""" _lowerCamelCase : str = """.gz""" class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = """lz4""" _lowerCamelCase : Any = """lz4""" _lowerCamelCase : List[Any] = """.lz4""" class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Union[str, Any] = """xz""" _lowerCamelCase : Optional[int] = """xz""" _lowerCamelCase : Optional[Any] = """.xz""" class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """zstd""" _lowerCamelCase : Optional[Any] = """zstd""" _lowerCamelCase : Optional[int] = """.zst""" def __init__( self : List[str] , snake_case_ : str , snake_case_ : str = "rb" , snake_case_ : Optional[str] = None , snake_case_ : Optional[dict] = None , snake_case_ : int = DEFAULT_BLOCK_SIZE , **snake_case_ : Tuple , ): super().__init__( fo=snake_case_ , mode=snake_case_ , target_protocol=snake_case_ , target_options=snake_case_ , block_size=snake_case_ , **snake_case_ , ) # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2: # # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open # out.close = close # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only # # see https://github.com/intake/filesystem_spec/issues/725 _UpperCAmelCase = self.file.__enter__ class A_ : def __init__( self : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = file_ def __enter__( self : Optional[Any] ): self._file.__enter__() return self def __exit__( self : List[str] , *snake_case_ : Optional[Any] , **snake_case_ : List[Any] ): self._file.__exit__(*snake_case_ , **snake_case_ ) def __iter__( self : Dict ): return iter(self._file ) def lowercase ( self : Optional[Any] ): return next(self._file ) def __getattr__( self : List[Any] , snake_case_ : Any ): return getattr(self._file , snake_case_ ) def fixed_enter(*snake_case_ : List[str] , **snake_case_ : int ): return WrappedFile(_enter(*snake_case_ , **snake_case_ ) ) _UpperCAmelCase = fixed_enter
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import torch from torch import nn from ...configuration_utils import ConfigMixin, register_to_config from ...models import ModelMixin class A_ ( lowerCAmelCase_ , lowerCAmelCase_ ): @register_to_config def __init__( self : Union[str, Any] , *, snake_case_ : int = 4 , snake_case_ : int = 7_6_8 , snake_case_ : int , snake_case_ : List[Any] , ): super().__init__() _UpperCAmelCase = nn.Parameter(torch.zeros(snake_case_ ) ) # parameters for additional clip time embeddings _UpperCAmelCase = nn.Linear(snake_case_ , snake_case_ ) _UpperCAmelCase = nn.Linear(snake_case_ , snake_case_ ) # parameters for encoder hidden states _UpperCAmelCase = clip_extra_context_tokens _UpperCAmelCase = nn.Linear( snake_case_ , self.clip_extra_context_tokens * cross_attention_dim ) _UpperCAmelCase = nn.Linear(snake_case_ , snake_case_ ) _UpperCAmelCase = nn.LayerNorm(snake_case_ ) def lowercase ( self : Union[str, Any] , *, snake_case_ : Dict , snake_case_ : int , snake_case_ : List[Any] , snake_case_ : Tuple ): if do_classifier_free_guidance: # Add the classifier free guidance embeddings to the image embeddings _UpperCAmelCase = image_embeddings.shape[0] _UpperCAmelCase = self.learned_classifier_free_guidance_embeddings.unsqueeze(0 ) _UpperCAmelCase = classifier_free_guidance_embeddings.expand( snake_case_ , -1 ) _UpperCAmelCase = torch.cat([classifier_free_guidance_embeddings, image_embeddings] , dim=0 ) # The image embeddings batch size and the text embeddings batch size are equal assert image_embeddings.shape[0] == prompt_embeds.shape[0] _UpperCAmelCase = prompt_embeds.shape[0] # "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and # adding CLIP embeddings to the existing timestep embedding, ... _UpperCAmelCase = self.embedding_proj(snake_case_ ) _UpperCAmelCase = self.clip_image_embeddings_project_to_time_embeddings(snake_case_ ) _UpperCAmelCase = time_projected_image_embeddings + time_projected_prompt_embeds # ... and by projecting CLIP embeddings into four # extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder" _UpperCAmelCase = self.clip_extra_context_tokens_proj(snake_case_ ) _UpperCAmelCase = clip_extra_context_tokens.reshape(snake_case_ , -1 , self.clip_extra_context_tokens ) _UpperCAmelCase = clip_extra_context_tokens.permute(0 , 2 , 1 ) _UpperCAmelCase = self.encoder_hidden_states_proj(snake_case_ ) _UpperCAmelCase = self.text_encoder_hidden_states_norm(snake_case_ ) _UpperCAmelCase = torch.cat([clip_extra_context_tokens, text_encoder_hidden_states] , dim=1 ) return text_encoder_hidden_states, additive_clip_time_embeddings
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :Optional[int] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :str = { '''facebook/encodec_24khz''': '''https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json''', '''facebook/encodec_48khz''': '''https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json''', } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = """encodec""" def __init__( self : Tuple , snake_case_ : Optional[int]=[1.5, 3.0, 6.0, 1_2.0, 2_4.0] , snake_case_ : Union[str, Any]=2_4_0_0_0 , snake_case_ : List[Any]=1 , snake_case_ : Optional[int]=False , snake_case_ : Any=None , snake_case_ : Dict=None , snake_case_ : str=1_2_8 , snake_case_ : Union[str, Any]=3_2 , snake_case_ : Optional[int]=1 , snake_case_ : Optional[int]=[8, 5, 4, 2] , snake_case_ : Dict="weight_norm" , snake_case_ : List[str]=7 , snake_case_ : Optional[Any]=7 , snake_case_ : Dict=3 , snake_case_ : Dict=2 , snake_case_ : Tuple=True , snake_case_ : Tuple="reflect" , snake_case_ : Tuple=2 , snake_case_ : Tuple=2 , snake_case_ : Union[str, Any]=1.0 , snake_case_ : List[str]=1_0_2_4 , snake_case_ : Union[str, Any]=None , snake_case_ : List[Any]=True , **snake_case_ : List[Any] , ): _UpperCAmelCase = target_bandwidths _UpperCAmelCase = sampling_rate _UpperCAmelCase = audio_channels _UpperCAmelCase = normalize _UpperCAmelCase = chunk_length_s _UpperCAmelCase = overlap _UpperCAmelCase = hidden_size _UpperCAmelCase = num_filters _UpperCAmelCase = num_residual_layers _UpperCAmelCase = upsampling_ratios _UpperCAmelCase = norm_type _UpperCAmelCase = kernel_size _UpperCAmelCase = last_kernel_size _UpperCAmelCase = residual_kernel_size _UpperCAmelCase = dilation_growth_rate _UpperCAmelCase = use_causal_conv _UpperCAmelCase = pad_mode _UpperCAmelCase = compress _UpperCAmelCase = num_lstm_layers _UpperCAmelCase = trim_right_ratio _UpperCAmelCase = codebook_size _UpperCAmelCase = codebook_dim if codebook_dim is not None else hidden_size _UpperCAmelCase = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}' ) super().__init__(**snake_case_ ) @property def lowercase ( self : Optional[int] ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def lowercase ( self : Tuple ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def lowercase ( self : Dict ): _UpperCAmelCase = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def lowercase ( self : Union[str, Any] ): return int(1_0_0_0 * self.target_bandwidths[-1] // (self.frame_rate * 1_0) )
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : float , __lowercase : float ) -> float: '''simple docstring''' return math.pow(__lowercase , 2 ) - a def UpperCAmelCase_ ( __lowercase : float ) -> float: '''simple docstring''' return 2 * x def UpperCAmelCase_ ( __lowercase : float ) -> float: '''simple docstring''' _UpperCAmelCase = 2.0 while start <= a: _UpperCAmelCase = math.pow(__lowercase , 2 ) return start def UpperCAmelCase_ ( __lowercase : float , __lowercase : int = 9999 , __lowercase : float = 0.00_0000_0000_0001 ) -> float: '''simple docstring''' if a < 0: raise ValueError("math domain error" ) _UpperCAmelCase = get_initial_point(__lowercase ) for _ in range(__lowercase ): _UpperCAmelCase = value _UpperCAmelCase = value - fx(__lowercase , __lowercase ) / fx_derivative(__lowercase ) if abs(prev_value - value ) < tolerance: return value return value if __name__ == "__main__": from doctest import testmod testmod()
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...file_utils import _LazyModule, is_torch_available from ...utils import OptionalDependencyNotAvailable __SCREAMING_SNAKE_CASE :Union[str, Any] = { '''configuration_gpt_neox_japanese''': ['''GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTNeoXJapaneseConfig'''], '''tokenization_gpt_neox_japanese''': ['''GPTNeoXJapaneseTokenizer'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Union[str, Any] = [ '''GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST''', '''GPTNeoXJapaneseForCausalLM''', '''GPTNeoXJapaneseLayer''', '''GPTNeoXJapaneseModel''', '''GPTNeoXJapanesePreTrainedModel''', ] if TYPE_CHECKING: from .configuration_gpt_neox_japanese import GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXJapaneseConfig from .tokenization_gpt_neox_japanese import GPTNeoXJapaneseTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_neox_japanese import ( GPT_NEOX_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST, GPTNeoXJapaneseForCausalLM, GPTNeoXJapaneseLayer, GPTNeoXJapaneseModel, GPTNeoXJapanesePreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Optional[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' from collections.abc import Sequence def UpperCAmelCase_ ( __lowercase : Sequence[float] , __lowercase : bool = False ) -> float: '''simple docstring''' if not arr: return 0 _UpperCAmelCase = 0 if allow_empty_subarrays else float("-inf" ) _UpperCAmelCase = 0.0 for num in arr: _UpperCAmelCase = max(0 if allow_empty_subarrays else num , curr_sum + num ) _UpperCAmelCase = max(__lowercase , __lowercase ) return max_sum if __name__ == "__main__": from doctest import testmod testmod() __SCREAMING_SNAKE_CASE :Optional[int] = [-2, 1, -3, 4, -1, 2, 1, -5, 4] print(F"{max_subarray_sum(nums) = }")
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' from heapq import heappop, heappush import numpy as np def UpperCAmelCase_ ( __lowercase : np.ndarray , __lowercase : tuple[int, int] , __lowercase : tuple[int, int] , __lowercase : bool , ) -> tuple[float | int, list[tuple[int, int]]]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = grid.shape _UpperCAmelCase = [-1, 1, 0, 0] _UpperCAmelCase = [0, 0, -1, 1] if allow_diagonal: dx += [-1, -1, 1, 1] dy += [-1, 1, -1, 1] _UpperCAmelCase , _UpperCAmelCase = [(0, source)], set() _UpperCAmelCase = np.full((rows, cols) , np.inf ) _UpperCAmelCase = 0 _UpperCAmelCase = np.empty((rows, cols) , dtype=__lowercase ) _UpperCAmelCase = None while queue: ((_UpperCAmelCase) , (_UpperCAmelCase)) = heappop(__lowercase ) if (x, y) in visited: continue visited.add((x, y) ) if (x, y) == destination: _UpperCAmelCase = [] while (x, y) != source: path.append((x, y) ) _UpperCAmelCase , _UpperCAmelCase = predecessors[x, y] path.append(__lowercase ) # add the source manually path.reverse() return matrix[destination], path for i in range(len(__lowercase ) ): _UpperCAmelCase , _UpperCAmelCase = x + dx[i], y + dy[i] if 0 <= nx < rows and 0 <= ny < cols: _UpperCAmelCase = grid[nx][ny] if next_node == 1 and matrix[nx, ny] > dist + 1: heappush(__lowercase , (dist + 1, (nx, ny)) ) _UpperCAmelCase = dist + 1 _UpperCAmelCase = (x, y) return np.inf, [] if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' import warnings from typing import Dict import numpy as np from ..utils import ExplicitEnum, add_end_docstrings, is_tf_available, is_torch_available from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' return 1.0 / (1.0 + np.exp(-_outputs )) def UpperCAmelCase_ ( __lowercase : List[str] ) -> Tuple: '''simple docstring''' _UpperCAmelCase = np.max(_outputs , axis=-1 , keepdims=__lowercase ) _UpperCAmelCase = np.exp(_outputs - maxes ) return shifted_exp / shifted_exp.sum(axis=-1 , keepdims=__lowercase ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigmoid""" _lowerCamelCase : str = """softmax""" _lowerCamelCase : List[Any] = """none""" @add_end_docstrings( lowerCAmelCase_ , R""" return_all_scores (`bool`, *optional*, defaults to `False`): Whether to return all prediction scores or just the one of the predicted class. function_to_apply (`str`, *optional*, defaults to `\"default\"`): The function to apply to the model outputs in order to retrieve the scores. Accepts four different values: - `\"default\"`: if the model has a single label, will apply the sigmoid function on the output. If the model has several labels, will apply the softmax function on the output. - `\"sigmoid\"`: Applies the sigmoid function on the output. - `\"softmax\"`: Applies the softmax function on the output. - `\"none\"`: Does not apply any function on the output. """ , ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = False _lowerCamelCase : List[Any] = ClassificationFunction.NONE def __init__( self : Any , **snake_case_ : int ): super().__init__(**snake_case_ ) self.check_model_type( TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if self.framework == "tf" else MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING ) def lowercase ( self : str , snake_case_ : List[str]=None , snake_case_ : Dict=None , snake_case_ : Any="" , **snake_case_ : List[Any] ): # Using "" as default argument because we're going to use `top_k=None` in user code to declare # "No top_k" _UpperCAmelCase = tokenizer_kwargs _UpperCAmelCase = {} if hasattr(self.model.config , "return_all_scores" ) and return_all_scores is None: _UpperCAmelCase = self.model.config.return_all_scores if isinstance(snake_case_ , snake_case_ ) or top_k is None: _UpperCAmelCase = top_k _UpperCAmelCase = False elif return_all_scores is not None: warnings.warn( "`return_all_scores` is now deprecated, if want a similar functionality use `top_k=None` instead of" " `return_all_scores=True` or `top_k=1` instead of `return_all_scores=False`." , snake_case_ , ) if return_all_scores: _UpperCAmelCase = None else: _UpperCAmelCase = 1 if isinstance(snake_case_ , snake_case_ ): _UpperCAmelCase = ClassificationFunction[function_to_apply.upper()] if function_to_apply is not None: _UpperCAmelCase = function_to_apply return preprocess_params, {}, postprocess_params def __call__( self : Optional[int] , *snake_case_ : Optional[Any] , **snake_case_ : int ): _UpperCAmelCase = super().__call__(*snake_case_ , **snake_case_ ) # TODO try and retrieve it in a nicer way from _sanitize_parameters. _UpperCAmelCase = "top_k" not in kwargs if isinstance(args[0] , snake_case_ ) and _legacy: # This pipeline is odd, and return a list when single item is run return [result] else: return result def lowercase ( self : Any , snake_case_ : Union[str, Any] , **snake_case_ : str ): _UpperCAmelCase = self.framework if isinstance(snake_case_ , snake_case_ ): return self.tokenizer(**snake_case_ , return_tensors=snake_case_ , **snake_case_ ) elif isinstance(snake_case_ , snake_case_ ) and len(snake_case_ ) == 1 and isinstance(inputs[0] , snake_case_ ) and len(inputs[0] ) == 2: # It used to be valid to use a list of list of list for text pairs, keeping this path for BC return self.tokenizer( text=inputs[0][0] , text_pair=inputs[0][1] , return_tensors=snake_case_ , **snake_case_ ) elif isinstance(snake_case_ , snake_case_ ): # This is likely an invalid usage of the pipeline attempting to pass text pairs. raise ValueError( "The pipeline received invalid inputs, if you are trying to send text pairs, you can try to send a" " dictionary `{\"text\": \"My text\", \"text_pair\": \"My pair\"}` in order to send a text pair." ) return self.tokenizer(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return self.model(**snake_case_ ) def lowercase ( self : List[Any] , snake_case_ : int , snake_case_ : Optional[int]=None , snake_case_ : Optional[int]=1 , snake_case_ : List[Any]=True ): # `_legacy` is used to determine if we're running the naked pipeline and in backward # compatibility mode, or if running the pipeline with `pipeline(..., top_k=1)` we're running # the more natural result containing the list. # Default value before `set_parameters` if function_to_apply is None: if self.model.config.problem_type == "multi_label_classification" or self.model.config.num_labels == 1: _UpperCAmelCase = ClassificationFunction.SIGMOID elif self.model.config.problem_type == "single_label_classification" or self.model.config.num_labels > 1: _UpperCAmelCase = ClassificationFunction.SOFTMAX elif hasattr(self.model.config , "function_to_apply" ) and function_to_apply is None: _UpperCAmelCase = self.model.config.function_to_apply else: _UpperCAmelCase = ClassificationFunction.NONE _UpperCAmelCase = model_outputs["logits"][0] _UpperCAmelCase = outputs.numpy() if function_to_apply == ClassificationFunction.SIGMOID: _UpperCAmelCase = sigmoid(snake_case_ ) elif function_to_apply == ClassificationFunction.SOFTMAX: _UpperCAmelCase = softmax(snake_case_ ) elif function_to_apply == ClassificationFunction.NONE: _UpperCAmelCase = outputs else: raise ValueError(f'Unrecognized `function_to_apply` argument: {function_to_apply}' ) if top_k == 1 and _legacy: return {"label": self.model.config.idalabel[scores.argmax().item()], "score": scores.max().item()} _UpperCAmelCase = [ {"label": self.model.config.idalabel[i], "score": score.item()} for i, score in enumerate(snake_case_ ) ] if not _legacy: dict_scores.sort(key=lambda snake_case_ : x["score"] , reverse=snake_case_ ) if top_k is not None: _UpperCAmelCase = dict_scores[:top_k] return dict_scores
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__lowercase ) )
22
1
'''simple docstring''' import argparse import json from collections import OrderedDict from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import PoolFormerConfig, PoolFormerForImageClassification, PoolFormerImageProcessor from transformers.utils import logging logging.set_verbosity_info() __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : Tuple , __lowercase : Tuple ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = original_name.split("." )[0] _UpperCAmelCase = key.split("." ) _UpperCAmelCase = int(key_list[key_list.index(__lowercase ) - 2] ) _UpperCAmelCase = int(key_list[key_list.index(__lowercase ) - 1] ) _UpperCAmelCase = orig_block_num - offset _UpperCAmelCase = key.replace(f'{orig_block_num}.{layer_num}.{original_name}' , f'block.{new_block_num}.{layer_num}.{new_name}' ) return key def UpperCAmelCase_ ( __lowercase : List[str] ) -> Any: '''simple docstring''' _UpperCAmelCase = OrderedDict() _UpperCAmelCase , _UpperCAmelCase = 0, 0 for key, value in state_dict.items(): if key.startswith("network" ): _UpperCAmelCase = key.replace("network" , "poolformer.encoder" ) if "proj" in key: # Works for the first embedding as well as the internal embedding layers if key.endswith("bias" ) and "patch_embed" not in key: patch_emb_offset += 1 _UpperCAmelCase = key[: key.find("proj" )] _UpperCAmelCase = key.replace(__lowercase , f'patch_embeddings.{total_embed_found}.' ) _UpperCAmelCase = key.replace("proj" , "projection" ) if key.endswith("bias" ): total_embed_found += 1 if "patch_embeddings" in key: _UpperCAmelCase = "poolformer.encoder." + key if "mlp.fc1" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "mlp.fc1" , "output.conv1" ) if "mlp.fc2" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "mlp.fc2" , "output.conv2" ) if "norm1" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "norm1" , "before_norm" ) if "norm2" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "norm2" , "after_norm" ) if "layer_scale_1" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "layer_scale_1" , "layer_scale_1" ) if "layer_scale_2" in key: _UpperCAmelCase = replace_key_with_offset(__lowercase , __lowercase , "layer_scale_2" , "layer_scale_2" ) if "head" in key: _UpperCAmelCase = key.replace("head" , "classifier" ) _UpperCAmelCase = value return new_state_dict def UpperCAmelCase_ ( ) -> Any: '''simple docstring''' _UpperCAmelCase = "http://images.cocodataset.org/val2017/000000039769.jpg" _UpperCAmelCase = Image.open(requests.get(__lowercase , stream=__lowercase ).raw ) return image @torch.no_grad() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : Dict ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = PoolFormerConfig() # set attributes based on model_name _UpperCAmelCase = "huggingface/label-files" _UpperCAmelCase = model_name[-3:] _UpperCAmelCase = 1000 _UpperCAmelCase = "imagenet-1k-id2label.json" _UpperCAmelCase = (1, 1000) # set config attributes _UpperCAmelCase = json.load(open(hf_hub_download(__lowercase , __lowercase , repo_type="dataset" ) , "r" ) ) _UpperCAmelCase = {int(__lowercase ): v for k, v in idalabel.items()} _UpperCAmelCase = idalabel _UpperCAmelCase = {v: k for k, v in idalabel.items()} if size == "s12": _UpperCAmelCase = [2, 2, 6, 2] _UpperCAmelCase = [64, 128, 320, 512] _UpperCAmelCase = 4.0 _UpperCAmelCase = 0.9 elif size == "s24": _UpperCAmelCase = [4, 4, 12, 4] _UpperCAmelCase = [64, 128, 320, 512] _UpperCAmelCase = 4.0 _UpperCAmelCase = 0.9 elif size == "s36": _UpperCAmelCase = [6, 6, 18, 6] _UpperCAmelCase = [64, 128, 320, 512] _UpperCAmelCase = 4.0 _UpperCAmelCase = 1E-6 _UpperCAmelCase = 0.9 elif size == "m36": _UpperCAmelCase = [6, 6, 18, 6] _UpperCAmelCase = [96, 192, 384, 768] _UpperCAmelCase = 4.0 _UpperCAmelCase = 1E-6 _UpperCAmelCase = 0.95 elif size == "m48": _UpperCAmelCase = [8, 8, 24, 8] _UpperCAmelCase = [96, 192, 384, 768] _UpperCAmelCase = 4.0 _UpperCAmelCase = 1E-6 _UpperCAmelCase = 0.95 else: raise ValueError(f'Size {size} not supported' ) # load image processor _UpperCAmelCase = PoolFormerImageProcessor(crop_pct=__lowercase ) # Prepare image _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=__lowercase , return_tensors="pt" ).pixel_values logger.info(f'Converting model {model_name}...' ) # load original state dict _UpperCAmelCase = torch.load(__lowercase , map_location=torch.device("cpu" ) ) # rename keys _UpperCAmelCase = rename_keys(__lowercase ) # create HuggingFace model and load state dict _UpperCAmelCase = PoolFormerForImageClassification(__lowercase ) model.load_state_dict(__lowercase ) model.eval() # Define image processor _UpperCAmelCase = PoolFormerImageProcessor(crop_pct=__lowercase ) _UpperCAmelCase = image_processor(images=prepare_img() , return_tensors="pt" ).pixel_values # forward pass _UpperCAmelCase = model(__lowercase ) _UpperCAmelCase = outputs.logits # define expected logit slices for different models if size == "s12": _UpperCAmelCase = torch.tensor([-0.3045, -0.6758, -0.4869] ) elif size == "s24": _UpperCAmelCase = torch.tensor([0.4402, -0.1374, -0.8045] ) elif size == "s36": _UpperCAmelCase = torch.tensor([-0.6080, -0.5133, -0.5898] ) elif size == "m36": _UpperCAmelCase = torch.tensor([0.3952, 0.2263, -1.2668] ) elif size == "m48": _UpperCAmelCase = torch.tensor([0.1167, -0.0656, -0.3423] ) else: raise ValueError(f'Size {size} not supported' ) # verify logits assert logits.shape == expected_shape assert torch.allclose(logits[0, :3] , __lowercase , atol=1E-2 ) # finally, save model and image processor logger.info(f'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...' ) Path(__lowercase ).mkdir(exist_ok=__lowercase ) model.save_pretrained(__lowercase ) print(f'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(__lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :int = argparse.ArgumentParser() parser.add_argument( '''--model_name''', default='''poolformer_s12''', type=str, help='''Name of the model you\'d like to convert.''', ) parser.add_argument( '''--checkpoint_path''', default=None, type=str, help='''Path 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.''' ) __SCREAMING_SNAKE_CASE :Optional[Any] = parser.parse_args() convert_poolformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1
'''simple docstring''' import warnings from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = ["""image_processor""", """tokenizer"""] _lowerCamelCase : Optional[Any] = """ViTImageProcessor""" _lowerCamelCase : Optional[int] = ("""CLIPTokenizer""", """CLIPTokenizerFast""") def __init__( self : Optional[int] , snake_case_ : Optional[Any]=None , snake_case_ : str=None , **snake_case_ : Optional[int] ): _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`" " instead." , snake_case_ , ) _UpperCAmelCase = kwargs.pop("feature_extractor" ) _UpperCAmelCase = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError("You need to specify an `image_processor`." ) if tokenizer is None: raise ValueError("You need to specify a `tokenizer`." ) super().__init__(snake_case_ , snake_case_ ) def __call__( self : Optional[Any] , snake_case_ : List[Any]=None , snake_case_ : Tuple=None , snake_case_ : Optional[int]=None , snake_case_ : int=None , **snake_case_ : List[Any] ): if text is None and visual_prompt is None and images is None: raise ValueError("You have to specify either text, visual prompt or images." ) if text is not None and visual_prompt is not None: raise ValueError("You have to specify exactly one type of prompt. Either text or visual prompt." ) if text is not None: _UpperCAmelCase = self.tokenizer(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) if visual_prompt is not None: _UpperCAmelCase = self.image_processor(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) if images is not None: _UpperCAmelCase = self.image_processor(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) if visual_prompt is not None and images is not None: _UpperCAmelCase = { "pixel_values": image_features.pixel_values, "conditional_pixel_values": prompt_features.pixel_values, } return encoding elif text is not None and images is not None: _UpperCAmelCase = image_features.pixel_values return encoding elif text is not None: return encoding elif visual_prompt is not None: _UpperCAmelCase = { "conditional_pixel_values": prompt_features.pixel_values, } return encoding else: return BatchEncoding(data=dict(**snake_case_ ) , tensor_type=snake_case_ ) def lowercase ( self : int , *snake_case_ : Optional[Any] , **snake_case_ : Optional[Any] ): return self.tokenizer.batch_decode(*snake_case_ , **snake_case_ ) def lowercase ( self : Dict , *snake_case_ : Dict , **snake_case_ : Any ): return self.tokenizer.decode(*snake_case_ , **snake_case_ ) @property def lowercase ( self : Dict ): warnings.warn( "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead." , snake_case_ , ) return self.image_processor_class @property def lowercase ( self : str ): warnings.warn( "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead." , snake_case_ , ) return self.image_processor
22
'''simple docstring''' 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: __SCREAMING_SNAKE_CASE :List[Any] = None __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''', }, } __SCREAMING_SNAKE_CASE :Optional[Any] = { '''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, } __SCREAMING_SNAKE_CASE :Optional[int] = '''▁''' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = VOCAB_FILES_NAMES _lowerCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : int = AlbertTokenizer def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=True , snake_case_ : str=True , snake_case_ : Tuple=False , snake_case_ : List[Any]="[CLS]" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : str="<unk>" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : List[Any]="<pad>" , snake_case_ : List[str]="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. _UpperCAmelCase = ( AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ , normalized=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token ) super().__init__( snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
1
'''simple docstring''' import torch from diffusers import KDPMaDiscreteScheduler from diffusers.utils import torch_device from .test_schedulers import SchedulerCommonTest class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Dict = (KDPMaDiscreteScheduler,) _lowerCamelCase : str = 10 def lowercase ( self : Tuple , **snake_case_ : int ): _UpperCAmelCase = { "num_train_timesteps": 1_1_0_0, "beta_start": 0.0_0_0_1, "beta_end": 0.0_2, "beta_schedule": "linear", } config.update(**snake_case_ ) return config def lowercase ( self : Any ): for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]: self.check_over_configs(num_train_timesteps=snake_case_ ) def lowercase ( self : Optional[Any] ): for beta_start, beta_end in zip([0.0_0_0_0_1, 0.0_0_0_1, 0.0_0_1] , [0.0_0_0_2, 0.0_0_2, 0.0_2] ): self.check_over_configs(beta_start=snake_case_ , beta_end=snake_case_ ) def lowercase ( self : Union[str, Any] ): for schedule in ["linear", "scaled_linear"]: self.check_over_configs(beta_schedule=snake_case_ ) def lowercase ( self : Tuple ): for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config(prediction_type="v_prediction" ) _UpperCAmelCase = scheduler_class(**snake_case_ ) scheduler.set_timesteps(self.num_inference_steps ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter * scheduler.init_noise_sigma _UpperCAmelCase = sample.to(snake_case_ ) for i, t in enumerate(scheduler.timesteps ): _UpperCAmelCase = scheduler.scale_model_input(snake_case_ , snake_case_ ) _UpperCAmelCase = model(snake_case_ , snake_case_ ) _UpperCAmelCase = scheduler.step(snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(snake_case_ ) ) _UpperCAmelCase = torch.mean(torch.abs(snake_case_ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 4.6_934e-07 ) < 1e-2 assert abs(result_mean.item() - 6.1_112e-10 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 4.693_428_650_170_972e-07 ) < 1e-2 assert abs(result_mean.item() - 0.0_0_0_2 ) < 1e-3 def lowercase ( self : str ): if torch_device == "mps": return _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**snake_case_ ) scheduler.set_timesteps(self.num_inference_steps ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter * scheduler.init_noise_sigma _UpperCAmelCase = sample.to(snake_case_ ) for i, t in enumerate(scheduler.timesteps ): _UpperCAmelCase = scheduler.scale_model_input(snake_case_ , snake_case_ ) _UpperCAmelCase = model(snake_case_ , snake_case_ ) _UpperCAmelCase = scheduler.step(snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(snake_case_ ) ) _UpperCAmelCase = torch.mean(torch.abs(snake_case_ ) ) if torch_device in ["cpu", "mps"]: assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 def lowercase ( self : Union[str, Any] ): if torch_device == "mps": return _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**snake_case_ ) scheduler.set_timesteps(self.num_inference_steps , device=snake_case_ ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter.to(snake_case_ ) * scheduler.init_noise_sigma for t in scheduler.timesteps: _UpperCAmelCase = scheduler.scale_model_input(snake_case_ , snake_case_ ) _UpperCAmelCase = model(snake_case_ , snake_case_ ) _UpperCAmelCase = scheduler.step(snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(snake_case_ ) ) _UpperCAmelCase = torch.mean(torch.abs(snake_case_ ) ) if str(snake_case_ ).startswith("cpu" ): # The following sum varies between 148 and 156 on mps. Why? assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3 else: # CUDA assert abs(result_sum.item() - 2_0.4_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.0_2_6_6 ) < 1e-3
22
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
1
'''simple docstring''' # flake8: noqa # Lint as: python3 __SCREAMING_SNAKE_CASE :Optional[Any] = [ '''VerificationMode''', '''Version''', '''disable_progress_bar''', '''enable_progress_bar''', '''is_progress_bar_enabled''', '''experimental''', ] from .info_utils import VerificationMode from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled from .version import Version from .experimental import experimental
22
'''simple docstring''' import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef __SCREAMING_SNAKE_CASE :List[str] = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : Tuple ) -> int: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase_ ( __lowercase : int , __lowercase : str ) -> Optional[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = simple_accuracy(__lowercase , __lowercase ) _UpperCAmelCase = fa_score(y_true=__lowercase , y_pred=__lowercase ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : List[str] ) -> List[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = pearsonr(__lowercase , __lowercase )[0] _UpperCAmelCase = spearmanr(__lowercase , __lowercase )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) assert len(__lowercase ) == len(__lowercase ), f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' if task_name == "cola": return {"mcc": matthews_corrcoef(__lowercase , __lowercase )} elif task_name == "sst-2": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mrpc": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "sts-b": return pearson_and_spearman(__lowercase , __lowercase ) elif task_name == "qqp": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "qnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "rte": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "wnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "hans": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : Dict , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) if len(__lowercase ) != len(__lowercase ): raise ValueError(f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' ) if task_name == "xnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) __SCREAMING_SNAKE_CASE :List[str] = { '''configuration_encodec''': [ '''ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''EncodecConfig''', ], '''feature_extraction_encodec''': ['''EncodecFeatureExtractor'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :List[Any] = [ '''ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST''', '''EncodecModel''', '''EncodecPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_encodec import ( ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP, EncodecConfig, ) from .feature_extraction_encodec import EncodecFeatureExtractor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encodec import ( ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST, EncodecModel, EncodecPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
1
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
'''simple docstring''' import os from datetime import datetime as dt from github import Github __SCREAMING_SNAKE_CASE :str = [ '''good first issue''', '''feature request''', '''wip''', ] def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = Github(os.environ["GITHUB_TOKEN"] ) _UpperCAmelCase = g.get_repo("huggingface/accelerate" ) _UpperCAmelCase = repo.get_issues(state="open" ) for issue in open_issues: _UpperCAmelCase = sorted([comment for comment in issue.get_comments()] , key=lambda __lowercase : i.created_at , reverse=__lowercase ) _UpperCAmelCase = comments[0] if len(__lowercase ) > 0 else None _UpperCAmelCase = dt.utcnow() _UpperCAmelCase = (current_time - issue.updated_at).days _UpperCAmelCase = (current_time - issue.created_at).days if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and days_since_updated > 7 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Close issue since it has been 7 days of inactivity since bot mention. issue.edit(state="closed" ) elif ( days_since_updated > 23 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Add stale comment issue.create_comment( "This issue has been automatically marked as stale because it has not had " "recent activity. If you think this still needs to be addressed " "please comment on this thread.\n\nPlease note that issues that do not follow the " "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) " "are likely to be ignored." ) if __name__ == "__main__": main()
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) __SCREAMING_SNAKE_CASE :Optional[Any] = {'''configuration_fnet''': ['''FNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FNetConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :int = ['''FNetTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Any = ['''FNetTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :List[str] = [ '''FNET_PRETRAINED_MODEL_ARCHIVE_LIST''', '''FNetForMaskedLM''', '''FNetForMultipleChoice''', '''FNetForNextSentencePrediction''', '''FNetForPreTraining''', '''FNetForQuestionAnswering''', '''FNetForSequenceClassification''', '''FNetForTokenClassification''', '''FNetLayer''', '''FNetModel''', '''FNetPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_fnet import FNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FNetConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_fnet import FNetTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_fnet_fast import FNetTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_fnet import ( FNET_PRETRAINED_MODEL_ARCHIVE_LIST, FNetForMaskedLM, FNetForMultipleChoice, FNetForNextSentencePrediction, FNetForPreTraining, FNetForQuestionAnswering, FNetForSequenceClassification, FNetForTokenClassification, FNetLayer, FNetModel, FNetPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Optional[int] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( "files" , [ ["full:README.md", "dataset_infos.json"], ["empty:README.md", "dataset_infos.json"], ["dataset_infos.json"], ["full:README.md"], ] , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : int ) -> int: '''simple docstring''' _UpperCAmelCase = tmp_path_factory.mktemp("dset_infos_dir" ) if "full:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("---\ndataset_info:\n dataset_size: 42\n---" ) if "empty:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("" ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / "dataset_infos.json" , "w" ) as f: f.write("{\"default\": {\"dataset_size\": 42}}" ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( "dataset_info" , [ DatasetInfo(), DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ), ] , ) def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : DatasetInfo ) -> Any: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_info.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfo.from_directory(__lowercase ) assert dataset_info == reloaded assert os.path.exists(os.path.join(__lowercase , "dataset_info.json" ) ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = DatasetInfo( description="foo" , citation="bar" , homepage="https://foo.bar" , license="CC0" , features=Features({"a": Value("int32" )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train", "num_examples": 42}] , download_checksums={} , download_size=1337 , post_processing_size=442 , dataset_size=1234 , size_in_bytes=1337 + 442 + 1234 , ) _UpperCAmelCase = dataset_info._to_yaml_dict() assert sorted(__lowercase ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _UpperCAmelCase = yaml.safe_dump(__lowercase ) _UpperCAmelCase = yaml.safe_load(__lowercase ) assert dataset_info_yaml_dict == reloaded def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = DatasetInfo() _UpperCAmelCase = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( "dataset_infos_dict" , [ DatasetInfosDict(), DatasetInfosDict({"default": DatasetInfo()} ), DatasetInfosDict({"my_config_name": DatasetInfo()} ), DatasetInfosDict( { "default": DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ) } ), DatasetInfosDict( { "v1": DatasetInfo(dataset_size=42 ), "v2": DatasetInfo(dataset_size=1337 ), } ), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : DatasetInfosDict ) -> Dict: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_infos_dict.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _UpperCAmelCase = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _UpperCAmelCase = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(__lowercase , "README.md" ) )
22
1
'''simple docstring''' import gc import random import tempfile import unittest import numpy as np import torch from PIL import Image from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMInverseScheduler, DDIMScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, StableDiffusionDiffEditPipeline, UNetaDConditionModel, ) from diffusers.utils import load_image, slow from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = StableDiffusionDiffEditPipeline _lowerCamelCase : Any = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""height""", """width""", """image"""} | {"""image_latents"""} _lowerCamelCase : str = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"""image"""} | {"""image_latents"""} _lowerCamelCase : List[Any] = frozenset( [] ) # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess _lowerCamelCase : Optional[Any] = frozenset([] ) def lowercase ( self : Optional[int] ): torch.manual_seed(0 ) _UpperCAmelCase = UNetaDConditionModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=4 , out_channels=4 , down_block_types=("DownBlock2D", "CrossAttnDownBlock2D") , up_block_types=("CrossAttnUpBlock2D", "UpBlock2D") , cross_attention_dim=3_2 , attention_head_dim=(2, 4) , use_linear_projection=snake_case_ , ) _UpperCAmelCase = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="scaled_linear" , clip_sample=snake_case_ , set_alpha_to_one=snake_case_ , ) _UpperCAmelCase = DDIMInverseScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule="scaled_linear" , clip_sample=snake_case_ , set_alpha_to_zero=snake_case_ , ) torch.manual_seed(0 ) _UpperCAmelCase = AutoencoderKL( block_out_channels=[3_2, 6_4] , in_channels=3 , out_channels=3 , down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"] , up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"] , latent_channels=4 , sample_size=1_2_8 , ) torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=3_2 , intermediate_size=3_7 , layer_norm_eps=1e-05 , 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 , ) _UpperCAmelCase = CLIPTextModel(snake_case_ ) _UpperCAmelCase = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" ) _UpperCAmelCase = { "unet": unet, "scheduler": scheduler, "inverse_scheduler": inverse_scheduler, "vae": vae, "text_encoder": text_encoder, "tokenizer": tokenizer, "safety_checker": None, "feature_extractor": None, } return components def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : List[Any]=0 ): _UpperCAmelCase = floats_tensor((1, 1_6, 1_6) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = floats_tensor((1, 2, 4, 1_6, 1_6) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = { "prompt": "a dog and a newt", "mask_image": mask, "image_latents": latents, "generator": generator, "num_inference_steps": 2, "inpaint_strength": 1.0, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def lowercase ( self : Dict , snake_case_ : Union[str, Any] , snake_case_ : Union[str, Any]=0 ): _UpperCAmelCase = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 )[0] _UpperCAmelCase = Image.fromarray(np.uinta(snake_case_ ) ).convert("RGB" ) if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = { "image": image, "source_prompt": "a cat and a frog", "target_prompt": "a dog and a newt", "generator": generator, "num_inference_steps": 2, "num_maps_per_mask": 2, "mask_encode_strength": 1.0, "guidance_scale": 6.0, "output_type": "numpy", } return inputs def lowercase ( self : List[Any] , snake_case_ : List[str] , snake_case_ : Any=0 ): _UpperCAmelCase = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 )[0] _UpperCAmelCase = Image.fromarray(np.uinta(snake_case_ ) ).convert("RGB" ) if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = { "image": image, "prompt": "a cat and a frog", "generator": generator, "num_inference_steps": 2, "inpaint_strength": 1.0, "guidance_scale": 6.0, "decode_latents": True, "output_type": "numpy", } return inputs def lowercase ( self : Tuple ): if not hasattr(self.pipeline_class , "_optional_components" ): return _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) # set all optional components to None and update pipeline config accordingly for optional_component in pipe._optional_components: setattr(snake_case_ , snake_case_ , snake_case_ ) pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components} ) _UpperCAmelCase = self.get_dummy_inputs(snake_case_ ) _UpperCAmelCase = pipe(**snake_case_ )[0] with tempfile.TemporaryDirectory() as tmpdir: pipe.save_pretrained(snake_case_ ) _UpperCAmelCase = self.pipeline_class.from_pretrained(snake_case_ ) pipe_loaded.to(snake_case_ ) pipe_loaded.set_progress_bar_config(disable=snake_case_ ) for optional_component in pipe._optional_components: self.assertTrue( getattr(snake_case_ , snake_case_ ) is None , f'`{optional_component}` did not stay set to None after loading.' , ) _UpperCAmelCase = self.get_dummy_inputs(snake_case_ ) _UpperCAmelCase = pipe_loaded(**snake_case_ )[0] _UpperCAmelCase = np.abs(output - output_loaded ).max() self.assertLess(snake_case_ , 1e-4 ) def lowercase ( self : Any ): _UpperCAmelCase = "cpu" _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_dummy_mask_inputs(snake_case_ ) _UpperCAmelCase = pipe.generate_mask(**snake_case_ ) _UpperCAmelCase = mask[0, -3:, -3:] self.assertEqual(mask.shape , (1, 1_6, 1_6) ) _UpperCAmelCase = np.array([0] * 9 ) _UpperCAmelCase = np.abs(mask_slice.flatten() - expected_slice ).max() self.assertLessEqual(snake_case_ , 1e-3 ) self.assertEqual(mask[0, -3, -4] , 0 ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = "cpu" _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_dummy_inversion_inputs(snake_case_ ) _UpperCAmelCase = pipe.invert(**snake_case_ ).images _UpperCAmelCase = image[0, -1, -3:, -3:] self.assertEqual(image.shape , (2, 3_2, 3_2, 3) ) _UpperCAmelCase = np.array( [0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9] , ) _UpperCAmelCase = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(snake_case_ , 1e-3 ) def lowercase ( self : List[Any] ): super().test_inference_batch_single_identical(expected_max_diff=5e-3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = "cpu" _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = {"beta_start": 0.0_0_0_8_5, "beta_end": 0.0_1_2, "beta_schedule": "scaled_linear"} _UpperCAmelCase = DPMSolverMultistepScheduler(**snake_case_ ) _UpperCAmelCase = DPMSolverMultistepInverseScheduler(**snake_case_ ) _UpperCAmelCase = self.pipeline_class(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_dummy_inversion_inputs(snake_case_ ) _UpperCAmelCase = pipe.invert(**snake_case_ ).images _UpperCAmelCase = image[0, -1, -3:, -3:] self.assertEqual(image.shape , (2, 3_2, 3_2, 3) ) _UpperCAmelCase = np.array( [0.5_1_5_0, 0.5_1_3_4, 0.5_0_4_3, 0.5_3_7_6, 0.4_6_9_4, 0.5_1_0_5_0, 0.5_0_1_5, 0.4_4_0_7, 0.4_7_9_9] , ) _UpperCAmelCase = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(snake_case_ , 1e-3 ) @require_torch_gpu @slow class A_ ( unittest.TestCase ): def lowercase ( self : Any ): super().tearDown() gc.collect() torch.cuda.empty_cache() @classmethod def lowercase ( cls : Dict ): _UpperCAmelCase = load_image( "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png" ) _UpperCAmelCase = raw_image.convert("RGB" ).resize((7_6_8, 7_6_8) ) _UpperCAmelCase = raw_image def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = StableDiffusionDiffEditPipeline.from_pretrained( "stabilityai/stable-diffusion-2-1" , safety_checker=snake_case_ , torch_dtype=torch.floataa ) _UpperCAmelCase = DDIMScheduler.from_config(pipe.scheduler.config ) _UpperCAmelCase = DDIMInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = "a bowl of fruit" _UpperCAmelCase = "a bowl of pears" _UpperCAmelCase = pipe.generate_mask( image=self.raw_image , source_prompt=snake_case_ , target_prompt=snake_case_ , generator=snake_case_ , ) _UpperCAmelCase = pipe.invert( prompt=snake_case_ , image=self.raw_image , inpaint_strength=0.7 , generator=snake_case_ ).latents _UpperCAmelCase = pipe( prompt=snake_case_ , mask_image=snake_case_ , image_latents=snake_case_ , generator=snake_case_ , negative_prompt=snake_case_ , inpaint_strength=0.7 , output_type="numpy" , ).images[0] _UpperCAmelCase = ( np.array( load_image( "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/diffedit/pears.png" ).resize((7_6_8, 7_6_8) ) ) / 2_5_5 ) assert np.abs((expected_image - image).max() ) < 5e-1 def lowercase ( self : Optional[int] ): _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = StableDiffusionDiffEditPipeline.from_pretrained( "stabilityai/stable-diffusion-2-1" , safety_checker=snake_case_ , torch_dtype=torch.floataa ) _UpperCAmelCase = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) _UpperCAmelCase = DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config ) pipe.enable_model_cpu_offload() pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = "a bowl of fruit" _UpperCAmelCase = "a bowl of pears" _UpperCAmelCase = pipe.generate_mask( image=self.raw_image , source_prompt=snake_case_ , target_prompt=snake_case_ , generator=snake_case_ , ) _UpperCAmelCase = pipe.invert( prompt=snake_case_ , image=self.raw_image , inpaint_strength=0.7 , generator=snake_case_ , num_inference_steps=2_5 , ).latents _UpperCAmelCase = pipe( prompt=snake_case_ , mask_image=snake_case_ , image_latents=snake_case_ , generator=snake_case_ , negative_prompt=snake_case_ , inpaint_strength=0.7 , num_inference_steps=2_5 , output_type="numpy" , ).images[0] _UpperCAmelCase = ( np.array( load_image( "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/diffedit/pears.png" ).resize((7_6_8, 7_6_8) ) ) / 2_5_5 ) assert np.abs((expected_image - image).max() ) < 5e-1
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
1
'''simple docstring''' import pytest from datasets.splits import SplitDict, SplitInfo from datasets.utils.py_utils import asdict @pytest.mark.parametrize( "split_dict" , [ SplitDict(), SplitDict({"train": SplitInfo(name="train" , num_bytes=1337 , num_examples=42 , dataset_name="my_dataset" )} ), SplitDict({"train": SplitInfo(name="train" , num_bytes=1337 , num_examples=42 )} ), SplitDict({"train": SplitInfo()} ), ] , ) def UpperCAmelCase_ ( __lowercase : SplitDict ) -> int: '''simple docstring''' _UpperCAmelCase = split_dict._to_yaml_list() assert len(__lowercase ) == len(__lowercase ) _UpperCAmelCase = SplitDict._from_yaml_list(__lowercase ) for split_name, split_info in split_dict.items(): # dataset_name field is deprecated, and is therefore not part of the YAML dump _UpperCAmelCase = None # the split name of split_dict takes over the name of the split info object _UpperCAmelCase = split_name assert split_dict == reloaded @pytest.mark.parametrize( "split_info" , [SplitInfo(), SplitInfo(dataset_name=__lowercase ), SplitInfo(dataset_name="my_dataset" )] ) def UpperCAmelCase_ ( __lowercase : List[Any] ) -> Dict: '''simple docstring''' _UpperCAmelCase = asdict(SplitDict({"train": split_info} ) ) assert "dataset_name" in split_dict_asdict["train"] assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
1
'''simple docstring''' from abc import ABC, abstractmethod from typing import Optional, Union from .. import Dataset, DatasetDict, Features, IterableDataset, IterableDatasetDict, NamedSplit from ..utils.typing import NestedDataStructureLike, PathLike class A_ ( lowerCAmelCase_ ): def __init__( self : str , snake_case_ : Optional[NestedDataStructureLike[PathLike]] = None , snake_case_ : Optional[NamedSplit] = None , snake_case_ : Optional[Features] = None , snake_case_ : str = None , snake_case_ : bool = False , snake_case_ : bool = False , snake_case_ : Optional[int] = None , **snake_case_ : Any , ): _UpperCAmelCase = path_or_paths _UpperCAmelCase = split if split or isinstance(snake_case_ , snake_case_ ) else "train" _UpperCAmelCase = features _UpperCAmelCase = cache_dir _UpperCAmelCase = keep_in_memory _UpperCAmelCase = streaming _UpperCAmelCase = num_proc _UpperCAmelCase = kwargs @abstractmethod def lowercase ( self : Tuple ): pass class A_ ( lowerCAmelCase_ ): def __init__( self : Union[str, Any] , snake_case_ : Optional[Features] = None , snake_case_ : str = None , snake_case_ : bool = False , snake_case_ : bool = False , snake_case_ : Optional[int] = None , **snake_case_ : List[Any] , ): _UpperCAmelCase = features _UpperCAmelCase = cache_dir _UpperCAmelCase = keep_in_memory _UpperCAmelCase = streaming _UpperCAmelCase = num_proc _UpperCAmelCase = kwargs @abstractmethod def lowercase ( self : str ): pass
22
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class A_ ( unittest.TestCase ): def lowercase ( self : int ): _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = BlipImageProcessor() _UpperCAmelCase = BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-BertModel" ) _UpperCAmelCase = BlipProcessor(snake_case_ , snake_case_ ) processor.save_pretrained(self.tmpdirname ) def lowercase ( self : Tuple , **snake_case_ : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).tokenizer def lowercase ( self : Dict , **snake_case_ : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).image_processor def lowercase ( self : int ): shutil.rmtree(self.tmpdirname ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] _UpperCAmelCase = [Image.fromarray(np.moveaxis(snake_case_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def lowercase ( self : int ): _UpperCAmelCase = BlipProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) _UpperCAmelCase = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) _UpperCAmelCase = self.get_image_processor(do_normalize=snake_case_ , padding_value=1.0 ) _UpperCAmelCase = BlipProcessor.from_pretrained( self.tmpdirname , bos_token="(BOS)" , eos_token="(EOS)" , do_normalize=snake_case_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , snake_case_ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="np" ) _UpperCAmelCase = processor(images=snake_case_ , return_tensors="np" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = processor(text=snake_case_ ) _UpperCAmelCase = tokenizer(snake_case_ , return_token_type_ids=snake_case_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] ) # test if it raises when no input is passed with pytest.raises(snake_case_ ): processor() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(snake_case_ ) _UpperCAmelCase = tokenizer.batch_decode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] )
22
1
'''simple docstring''' def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] _UpperCAmelCase = 6 _UpperCAmelCase = 1 _UpperCAmelCase = 1901 _UpperCAmelCase = 0 while year < 2001: day += 7 if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): if day > days_per_month[month - 1] and month != 2: month += 1 _UpperCAmelCase = day - days_per_month[month - 2] elif day > 29 and month == 2: month += 1 _UpperCAmelCase = day - 29 else: if day > days_per_month[month - 1]: month += 1 _UpperCAmelCase = day - days_per_month[month - 2] if month > 12: year += 1 _UpperCAmelCase = 1 if year < 2001 and day == 1: sundays += 1 return sundays if __name__ == "__main__": print(solution())
22
'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def UpperCAmelCase_ ( __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.size _UpperCAmelCase , _UpperCAmelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 _UpperCAmelCase = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) _UpperCAmelCase = np.array(__lowercase ).astype(np.floataa ) / 255.0 _UpperCAmelCase = image[None].transpose(0 , 3 , 1 , 2 ) _UpperCAmelCase = torch.from_numpy(__lowercase ) return 2.0 * image - 1.0 class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , snake_case_ : VQModel , snake_case_ : UNetaDModel , snake_case_ : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ): super().__init__() self.register_modules(vqvae=snake_case_ , unet=snake_case_ , scheduler=snake_case_ ) @torch.no_grad() def __call__( self : Any , snake_case_ : Union[torch.Tensor, PIL.Image.Image] = None , snake_case_ : Optional[int] = 1 , snake_case_ : Optional[int] = 1_0_0 , snake_case_ : Optional[float] = 0.0 , snake_case_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case_ : Optional[str] = "pil" , snake_case_ : bool = True , ): if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = 1 elif isinstance(snake_case_ , torch.Tensor ): _UpperCAmelCase = image.shape[0] else: raise ValueError(f'`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(snake_case_ )}' ) if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = preprocess(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image _UpperCAmelCase = (batch_size, self.unet.config.in_channels // 2, height, width) _UpperCAmelCase = next(self.unet.parameters() ).dtype _UpperCAmelCase = randn_tensor(snake_case_ , generator=snake_case_ , device=self.device , dtype=snake_case_ ) _UpperCAmelCase = image.to(device=self.device , dtype=snake_case_ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(snake_case_ , device=self.device ) _UpperCAmelCase = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler _UpperCAmelCase = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _UpperCAmelCase = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) _UpperCAmelCase = {} if accepts_eta: _UpperCAmelCase = eta for t in self.progress_bar(snake_case_ ): # concat latents and low resolution image in the channel dimension. _UpperCAmelCase = torch.cat([latents, image] , dim=1 ) _UpperCAmelCase = self.scheduler.scale_model_input(snake_case_ , snake_case_ ) # predict the noise residual _UpperCAmelCase = self.unet(snake_case_ , snake_case_ ).sample # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ).prev_sample # decode the image latents with the VQVAE _UpperCAmelCase = self.vqvae.decode(snake_case_ ).sample _UpperCAmelCase = torch.clamp(snake_case_ , -1.0 , 1.0 ) _UpperCAmelCase = image / 2 + 0.5 _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _UpperCAmelCase = self.numpy_to_pil(snake_case_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case_ )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __SCREAMING_SNAKE_CASE :str = { '''configuration_time_series_transformer''': [ '''TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TimeSeriesTransformerConfig''', ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Optional[int] = [ '''TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TimeSeriesTransformerForPrediction''', '''TimeSeriesTransformerModel''', '''TimeSeriesTransformerPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimeSeriesTransformerConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_time_series_transformer import ( TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimeSeriesTransformerForPrediction, TimeSeriesTransformerModel, TimeSeriesTransformerPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :List[str] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
1
'''simple docstring''' import random import unittest import torch from diffusers import IFInpaintingSuperResolutionPipeline from diffusers.utils import floats_tensor from diffusers.utils.import_utils import is_xformers_available from diffusers.utils.testing_utils import skip_mps, torch_device from ..pipeline_params import ( TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS, ) from ..test_pipelines_common import PipelineTesterMixin from . import IFPipelineTesterMixin @skip_mps class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : int = IFInpaintingSuperResolutionPipeline _lowerCamelCase : Optional[Any] = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""} _lowerCamelCase : Optional[int] = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""} ) _lowerCamelCase : Optional[Any] = PipelineTesterMixin.required_optional_params - {"""latents"""} def lowercase ( self : Union[str, Any] ): return self._get_superresolution_dummy_components() def lowercase ( self : Optional[int] , snake_case_ : Optional[Any] , snake_case_ : str=0 ): if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = floats_tensor((1, 3, 1_6, 1_6) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = floats_tensor((1, 3, 3_2, 3_2) , rng=random.Random(snake_case_ ) ).to(snake_case_ ) _UpperCAmelCase = { "prompt": "A painting of a squirrel eating a burger", "image": image, "original_image": original_image, "mask_image": mask_image, "generator": generator, "num_inference_steps": 2, "output_type": "numpy", } return inputs @unittest.skipIf( torch_device != "cuda" or not is_xformers_available() , reason="XFormers attention is only available with CUDA and `xformers` installed" , ) def lowercase ( self : List[str] ): self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3 ) def lowercase ( self : List[Any] ): self._test_save_load_optional_components() @unittest.skipIf(torch_device != "cuda" , reason="float16 requires CUDA" ) def lowercase ( self : Any ): # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder super().test_save_load_floataa(expected_max_diff=1e-1 ) def lowercase ( self : Any ): self._test_attention_slicing_forward_pass(expected_max_diff=1e-2 ) def lowercase ( self : Tuple ): self._test_save_load_local() def lowercase ( self : Tuple ): self._test_inference_batch_single_identical( expected_max_diff=1e-2 , )
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' import os from pathlib import Path import numpy as np import pytest from pack_dataset import pack_data_dir from parameterized import parameterized from save_len_file import save_len_file from torch.utils.data import DataLoader from transformers import AutoTokenizer from transformers.models.mbart.modeling_mbart import shift_tokens_right from transformers.testing_utils import TestCasePlus, slow from utils import FAIRSEQ_AVAILABLE, DistributedSortishSampler, LegacySeqaSeqDataset, SeqaSeqDataset __SCREAMING_SNAKE_CASE :int = '''bert-base-cased''' __SCREAMING_SNAKE_CASE :Any = '''google/pegasus-xsum''' __SCREAMING_SNAKE_CASE :Optional[int] = [''' Sam ate lunch today.''', '''Sams lunch ingredients.'''] __SCREAMING_SNAKE_CASE :Union[str, Any] = ['''A very interesting story about what I ate for lunch.''', '''Avocado, celery, turkey, coffee'''] __SCREAMING_SNAKE_CASE :str = '''patrickvonplaten/t5-tiny-random''' __SCREAMING_SNAKE_CASE :List[Any] = '''sshleifer/bart-tiny-random''' __SCREAMING_SNAKE_CASE :List[str] = '''sshleifer/tiny-mbart''' __SCREAMING_SNAKE_CASE :Dict = '''sshleifer/tiny-marian-en-de''' def UpperCAmelCase_ ( __lowercase : Path , __lowercase : list ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = "\n".join(__lowercase ) Path(__lowercase ).open("w" ).writelines(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[str] ) -> Any: '''simple docstring''' for split in ["train", "val", "test"]: _dump_articles(os.path.join(__lowercase , f'{split}.source' ) , __lowercase ) _dump_articles(os.path.join(__lowercase , f'{split}.target' ) , __lowercase ) return tmp_dir class A_ ( lowerCAmelCase_ ): @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) @slow def lowercase ( self : str , snake_case_ : str ): _UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ ) _UpperCAmelCase = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) _UpperCAmelCase = max(len(tokenizer.encode(snake_case_ ) ) for a in ARTICLES ) _UpperCAmelCase = max(len(tokenizer.encode(snake_case_ ) ) for a in SUMMARIES ) _UpperCAmelCase = 4 _UpperCAmelCase = 8 assert max_len_target > max_src_len # Will be truncated assert max_len_source > max_src_len # Will be truncated _UpperCAmelCase , _UpperCAmelCase = "ro_RO", "de_DE" # ignored for all but mbart, but never causes error. _UpperCAmelCase = SeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path="train" , max_source_length=snake_case_ , max_target_length=snake_case_ , src_lang=snake_case_ , tgt_lang=snake_case_ , ) _UpperCAmelCase = DataLoader(snake_case_ , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert isinstance(snake_case_ , snake_case_ ) assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_src_len # show that targets are the same len assert batch["labels"].shape[1] == max_tgt_len if tok_name != MBART_TINY: continue # check language codes in correct place _UpperCAmelCase = shift_tokens_right(batch["labels"] , tokenizer.pad_token_id ) assert batch["decoder_input_ids"][0, 0].item() == tokenizer.lang_code_to_id[tgt_lang] assert batch["decoder_input_ids"][0, -1].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -2].item() == tokenizer.eos_token_id assert batch["input_ids"][0, -1].item() == tokenizer.lang_code_to_id[src_lang] break # No need to test every batch @parameterized.expand([BART_TINY, BERT_BASE_CASED] ) def lowercase ( self : Union[str, Any] , snake_case_ : List[Any] ): _UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ ) _UpperCAmelCase = make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) _UpperCAmelCase = max(len(tokenizer.encode(snake_case_ ) ) for a in ARTICLES ) _UpperCAmelCase = max(len(tokenizer.encode(snake_case_ ) ) for a in SUMMARIES ) _UpperCAmelCase = 4 _UpperCAmelCase = LegacySeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path="train" , max_source_length=2_0 , max_target_length=snake_case_ , ) _UpperCAmelCase = DataLoader(snake_case_ , batch_size=2 , collate_fn=train_dataset.collate_fn ) for batch in dataloader: assert batch["attention_mask"].shape == batch["input_ids"].shape # show that articles were trimmed. assert batch["input_ids"].shape[1] == max_len_source assert 2_0 >= batch["input_ids"].shape[1] # trimmed significantly # show that targets were truncated assert batch["labels"].shape[1] == trunc_target # Truncated assert max_len_target > trunc_target # Truncated break # No need to test every batch def lowercase ( self : Any ): _UpperCAmelCase = AutoTokenizer.from_pretrained("facebook/mbart-large-cc25" ) _UpperCAmelCase = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) _UpperCAmelCase = tmp_dir.joinpath("train.source" ).open().readlines() _UpperCAmelCase = Path(make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) ) pack_data_dir(snake_case_ , snake_case_ , 1_2_8 , snake_case_ ) _UpperCAmelCase = {x.name for x in tmp_dir.iterdir()} _UpperCAmelCase = {x.name for x in save_dir.iterdir()} _UpperCAmelCase = save_dir.joinpath("train.source" ).open().readlines() # orig: [' Sam ate lunch today.\n', 'Sams lunch ingredients.'] # desired_packed: [' Sam ate lunch today.\n Sams lunch ingredients.'] assert len(snake_case_ ) < len(snake_case_ ) assert len(snake_case_ ) == 1 assert len(packed_examples[0] ) == sum(len(snake_case_ ) for x in orig_examples ) assert orig_paths == new_paths @pytest.mark.skipif(not FAIRSEQ_AVAILABLE , reason="This test requires fairseq" ) def lowercase ( self : Optional[int] ): if not FAIRSEQ_AVAILABLE: return _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self._get_dataset(max_len=6_4 ) _UpperCAmelCase = 6_4 _UpperCAmelCase = ds.make_dynamic_sampler(snake_case_ , required_batch_size_multiple=snake_case_ ) _UpperCAmelCase = [len(snake_case_ ) for x in batch_sampler] assert len(set(snake_case_ ) ) > 1 # it's not dynamic batch size if every batch is the same length assert sum(snake_case_ ) == len(snake_case_ ) # no dropped or added examples _UpperCAmelCase = DataLoader(snake_case_ , batch_sampler=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 ) _UpperCAmelCase = [] _UpperCAmelCase = [] for batch in data_loader: _UpperCAmelCase = batch["input_ids"].shape _UpperCAmelCase = src_shape[0] assert bs % required_batch_size_multiple == 0 or bs < required_batch_size_multiple _UpperCAmelCase = np.product(batch["input_ids"].shape ) num_src_per_batch.append(snake_case_ ) if num_src_tokens > (max_tokens * 1.1): failures.append(snake_case_ ) assert num_src_per_batch[0] == max(snake_case_ ) if failures: raise AssertionError(f'too many tokens in {len(snake_case_ )} batches' ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self._get_dataset(max_len=5_1_2 ) _UpperCAmelCase = 2 _UpperCAmelCase = ds.make_sortish_sampler(snake_case_ , shuffle=snake_case_ ) _UpperCAmelCase = DataLoader(snake_case_ , batch_size=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 ) _UpperCAmelCase = DataLoader(snake_case_ , batch_size=snake_case_ , collate_fn=ds.collate_fn , num_workers=2 , sampler=snake_case_ ) _UpperCAmelCase = tokenizer.pad_token_id def count_pad_tokens(snake_case_ : List[Any] , snake_case_ : Dict="input_ids" ): return [batch[k].eq(snake_case_ ).sum().item() for batch in data_loader] assert sum(count_pad_tokens(snake_case_ , k="labels" ) ) < sum(count_pad_tokens(snake_case_ , k="labels" ) ) assert sum(count_pad_tokens(snake_case_ ) ) < sum(count_pad_tokens(snake_case_ ) ) assert len(snake_case_ ) == len(snake_case_ ) def lowercase ( self : List[Any] , snake_case_ : List[str]=1_0_0_0 , snake_case_ : List[Any]=1_2_8 ): if os.getenv("USE_REAL_DATA" , snake_case_ ): _UpperCAmelCase = "examples/seq2seq/wmt_en_ro" _UpperCAmelCase = max_len * 2 * 6_4 if not Path(snake_case_ ).joinpath("train.len" ).exists(): save_len_file(snake_case_ , snake_case_ ) else: _UpperCAmelCase = "examples/seq2seq/test_data/wmt_en_ro" _UpperCAmelCase = max_len * 4 save_len_file(snake_case_ , snake_case_ ) _UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ ) _UpperCAmelCase = SeqaSeqDataset( snake_case_ , data_dir=snake_case_ , type_path="train" , max_source_length=snake_case_ , max_target_length=snake_case_ , n_obs=snake_case_ , ) return ds, max_tokens, tokenizer def lowercase ( self : List[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self._get_dataset() _UpperCAmelCase = set(DistributedSortishSampler(snake_case_ , 2_5_6 , num_replicas=2 , rank=0 , add_extra_examples=snake_case_ ) ) _UpperCAmelCase = set(DistributedSortishSampler(snake_case_ , 2_5_6 , num_replicas=2 , rank=1 , add_extra_examples=snake_case_ ) ) assert idsa.intersection(snake_case_ ) == set() @parameterized.expand( [ MBART_TINY, MARIAN_TINY, T5_TINY, BART_TINY, PEGASUS_XSUM, ] , ) def lowercase ( self : str , snake_case_ : Union[str, Any] ): _UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ , use_fast=snake_case_ ) if tok_name == MBART_TINY: _UpperCAmelCase = SeqaSeqDataset( snake_case_ , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path="train" , max_source_length=4 , max_target_length=8 , src_lang="EN" , tgt_lang="FR" , ) _UpperCAmelCase = train_dataset.dataset_kwargs assert "src_lang" in kwargs and "tgt_lang" in kwargs else: _UpperCAmelCase = SeqaSeqDataset( snake_case_ , data_dir=make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir() ) , type_path="train" , max_source_length=4 , max_target_length=8 , ) _UpperCAmelCase = train_dataset.dataset_kwargs assert "add_prefix_space" not in kwargs if tok_name != BART_TINY else "add_prefix_space" in kwargs assert len(snake_case_ ) == 1 if tok_name == BART_TINY else len(snake_case_ ) == 0
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import subprocess import sys from transformers import BertConfig, BertModel, BertTokenizer, pipeline from transformers.testing_utils import TestCasePlus, require_torch class A_ ( lowerCAmelCase_ ): @require_torch def lowercase ( self : str ): # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before # `transformers` is loaded, and it's too late for inside pytest - so we are changing it # while running an external program # python one-liner segments # this must be loaded before socket.socket is monkey-patched _UpperCAmelCase = "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n " _UpperCAmelCase = "\nmname = \"hf-internal-testing/tiny-random-bert\"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task=\"fill-mask\", model=mname)\nprint(\"success\")\n " _UpperCAmelCase = "\nimport socket\ndef offline_socket(*args, **kwargs): raise RuntimeError(\"Offline mode is enabled, we shouldn't access internet\")\nsocket.socket = offline_socket\n " # Force fetching the files so that we can use the cache _UpperCAmelCase = "hf-internal-testing/tiny-random-bert" BertConfig.from_pretrained(snake_case_ ) BertModel.from_pretrained(snake_case_ ) BertTokenizer.from_pretrained(snake_case_ ) pipeline(task="fill-mask" , model=snake_case_ ) # baseline - just load from_pretrained with normal network _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, run, mock] )] # should succeed _UpperCAmelCase = self.get_env() # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files _UpperCAmelCase = "1" _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() ) @require_torch def lowercase ( self : List[Any] ): # python one-liner segments # this must be loaded before socket.socket is monkey-patched _UpperCAmelCase = "\nfrom transformers import BertConfig, BertModel, BertTokenizer, pipeline\n " _UpperCAmelCase = "\nmname = \"hf-internal-testing/tiny-random-bert\"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nBertTokenizer.from_pretrained(mname)\npipe = pipeline(task=\"fill-mask\", model=mname)\nprint(\"success\")\n " _UpperCAmelCase = "\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error(\"Faking flaky internet\")\nsocket.socket = offline_socket\n " # Force fetching the files so that we can use the cache _UpperCAmelCase = "hf-internal-testing/tiny-random-bert" BertConfig.from_pretrained(snake_case_ ) BertModel.from_pretrained(snake_case_ ) BertTokenizer.from_pretrained(snake_case_ ) pipeline(task="fill-mask" , model=snake_case_ ) # baseline - just load from_pretrained with normal network _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, run, mock] )] # should succeed _UpperCAmelCase = self.get_env() _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() ) @require_torch def lowercase ( self : Tuple ): # this test is a bit tricky since TRANSFORMERS_OFFLINE can only be changed before # `transformers` is loaded, and it's too late for inside pytest - so we are changing it # while running an external program # python one-liner segments # this must be loaded before socket.socket is monkey-patched _UpperCAmelCase = "\nfrom transformers import BertConfig, BertModel, BertTokenizer\n " _UpperCAmelCase = "\nmname = \"hf-internal-testing/tiny-random-bert-sharded\"\nBertConfig.from_pretrained(mname)\nBertModel.from_pretrained(mname)\nprint(\"success\")\n " _UpperCAmelCase = "\nimport socket\ndef offline_socket(*args, **kwargs): raise ValueError(\"Offline mode is enabled\")\nsocket.socket = offline_socket\n " # baseline - just load from_pretrained with normal network _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, run] )] # should succeed _UpperCAmelCase = self.get_env() _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() ) # next emulate no network _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, mock, run] )] # Doesn't fail anymore since the model is in the cache due to other tests, so commenting this. # env["TRANSFORMERS_OFFLINE"] = "0" # result = subprocess.run(cmd, env=env, check=False, capture_output=True) # self.assertEqual(result.returncode, 1, result.stderr) # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files _UpperCAmelCase = "1" _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() ) @require_torch def lowercase ( self : Optional[Any] ): _UpperCAmelCase = "\nfrom transformers import pipeline\n " _UpperCAmelCase = "\nmname = \"hf-internal-testing/tiny-random-bert\"\npipe = pipeline(model=mname)\n " _UpperCAmelCase = "\nimport socket\ndef offline_socket(*args, **kwargs): raise socket.error(\"Offline mode is enabled\")\nsocket.socket = offline_socket\n " _UpperCAmelCase = self.get_env() _UpperCAmelCase = "1" _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, mock, run] )] _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 1 , result.stderr ) self.assertIn( "You cannot infer task automatically within `pipeline` when using offline mode" , result.stderr.decode().replace("\n" , "" ) , ) @require_torch def lowercase ( self : Optional[int] ): _UpperCAmelCase = "\nfrom transformers import AutoModel\n " _UpperCAmelCase = "\nmname = \"hf-internal-testing/test_dynamic_model\"\nAutoModel.from_pretrained(mname, trust_remote_code=True)\nprint(\"success\")\n " # baseline - just load from_pretrained with normal network _UpperCAmelCase = [sys.executable, "-c", "\n".join([load, run] )] # should succeed _UpperCAmelCase = self.get_env() _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() ) # should succeed as TRANSFORMERS_OFFLINE=1 tells it to use local files _UpperCAmelCase = "1" _UpperCAmelCase = subprocess.run(snake_case_ , env=snake_case_ , check=snake_case_ , capture_output=snake_case_ ) self.assertEqual(result.returncode , 0 , result.stderr ) self.assertIn("success" , result.stdout.decode() )
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' import inspect import unittest from transformers import MobileViTVaConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel from transformers.models.mobilevitva.modeling_mobilevitva import ( MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST, make_divisible, ) if is_vision_available(): from PIL import Image from transformers import MobileViTImageProcessor class A_ ( lowerCAmelCase_ ): def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(snake_case_ , "width_multiplier" ) ) class A_ : def __init__( self : Any , snake_case_ : Dict , snake_case_ : Optional[int]=1_3 , snake_case_ : Tuple=6_4 , snake_case_ : Optional[int]=2 , snake_case_ : Any=3 , snake_case_ : List[Any]="swish" , snake_case_ : List[str]=3 , snake_case_ : Any=3_2 , snake_case_ : Dict=0.1 , snake_case_ : str=0.0_2 , snake_case_ : str=True , snake_case_ : Optional[Any]=True , snake_case_ : Dict=1_0 , snake_case_ : str=None , snake_case_ : int=0.2_5 , snake_case_ : Optional[int]=0.0 , snake_case_ : str=0.0 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = patch_size _UpperCAmelCase = num_channels _UpperCAmelCase = make_divisible(5_1_2 * width_multiplier , divisor=8 ) _UpperCAmelCase = hidden_act _UpperCAmelCase = conv_kernel_size _UpperCAmelCase = output_stride _UpperCAmelCase = classifier_dropout_prob _UpperCAmelCase = use_labels _UpperCAmelCase = is_training _UpperCAmelCase = num_labels _UpperCAmelCase = initializer_range _UpperCAmelCase = scope _UpperCAmelCase = width_multiplier _UpperCAmelCase = ffn_dropout _UpperCAmelCase = attn_dropout def lowercase ( self : str ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size, self.image_size, self.image_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels, pixel_labels def lowercase ( self : List[Any] ): return MobileViTVaConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_act=self.hidden_act , conv_kernel_size=self.conv_kernel_size , output_stride=self.output_stride , classifier_dropout_prob=self.classifier_dropout_prob , initializer_range=self.initializer_range , width_multiplier=self.width_multiplier , ffn_dropout=self.ffn_dropout_prob , attn_dropout=self.attn_dropout_prob , ) def lowercase ( self : List[str] , snake_case_ : Dict , snake_case_ : Optional[int] , snake_case_ : List[Any] , snake_case_ : Optional[int] ): _UpperCAmelCase = MobileViTVaModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) self.parent.assertEqual( result.last_hidden_state.shape , ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) def lowercase ( self : Tuple , snake_case_ : Tuple , snake_case_ : Tuple , snake_case_ : List[Any] , snake_case_ : List[Any] ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = MobileViTVaForImageClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def lowercase ( self : int , snake_case_ : int , snake_case_ : Any , snake_case_ : Optional[int] , snake_case_ : Dict ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = MobileViTVaForSemanticSegmentation(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) _UpperCAmelCase = model(snake_case_ , labels=snake_case_ ) self.parent.assertEqual( result.logits.shape , ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ) , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Union[str, Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) _lowerCamelCase : List[str] = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) _lowerCamelCase : List[Any] = False _lowerCamelCase : Optional[int] = False _lowerCamelCase : List[str] = False _lowerCamelCase : str = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MobileViTVaModelTester(self ) _UpperCAmelCase = MobileViTVaConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : List[Any] ): self.config_tester.run_common_tests() @unittest.skip(reason="MobileViTV2 does not use inputs_embeds" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MobileViTV2 does not support input and output embeddings" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MobileViTV2 does not output attentions" ) def lowercase ( self : Optional[Any] ): pass @require_torch_multi_gpu @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run." ) def lowercase ( self : Union[str, Any] ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : str ): pass def lowercase ( self : List[Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : List[Any] ): def check_hidden_states_output(snake_case_ : Union[str, Any] , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.hidden_states _UpperCAmelCase = 5 self.assertEqual(len(snake_case_ ) , snake_case_ ) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _UpperCAmelCase = 2 for i in range(len(snake_case_ ) ): self.assertListEqual( list(hidden_states[i].shape[-2:] ) , [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor] , ) divisor *= 2 self.assertEqual(self.model_tester.output_stride , divisor // 2 ) _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = True check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _UpperCAmelCase = True check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*snake_case_ ) @slow def lowercase ( self : List[Any] ): for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = MobileViTVaModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def UpperCAmelCase_ ( ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_torch @require_vision class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Tuple ): return ( MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256" ) if is_vision_available() else None ) @slow def lowercase ( self : Dict ): _UpperCAmelCase = MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256" ).to( snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=snake_case_ , return_tensors="pt" ).to(snake_case_ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # verify the logits _UpperCAmelCase = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case_ , atol=1e-4 ) ) @slow def lowercase ( self : Dict ): _UpperCAmelCase = MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3" ) _UpperCAmelCase = model.to(snake_case_ ) _UpperCAmelCase = MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3" ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=snake_case_ , return_tensors="pt" ).to(snake_case_ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.logits # verify the logits _UpperCAmelCase = torch.Size((1, 2_1, 3_2, 3_2) ) self.assertEqual(logits.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [ [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]], [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]], [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]], ] , device=snake_case_ , ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3] , snake_case_ , atol=1e-4 ) ) @slow def lowercase ( self : Dict ): _UpperCAmelCase = MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3" ) _UpperCAmelCase = model.to(snake_case_ ) _UpperCAmelCase = MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3" ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=snake_case_ , return_tensors="pt" ).to(snake_case_ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.logits.detach().cpu() _UpperCAmelCase = image_processor.post_process_semantic_segmentation(outputs=snake_case_ , target_sizes=[(5_0, 6_0)] ) _UpperCAmelCase = torch.Size((5_0, 6_0) ) self.assertEqual(segmentation[0].shape , snake_case_ ) _UpperCAmelCase = image_processor.post_process_semantic_segmentation(outputs=snake_case_ ) _UpperCAmelCase = torch.Size((3_2, 3_2) ) self.assertEqual(segmentation[0].shape , snake_case_ )
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import unittest import numpy as np from transformers import RoFormerConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.roformer.modeling_flax_roformer import ( FlaxRoFormerForMaskedLM, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerModel, ) class A_ ( unittest.TestCase ): def __init__( self : Any , snake_case_ : List[Any] , snake_case_ : List[str]=1_3 , snake_case_ : Union[str, Any]=7 , snake_case_ : List[str]=True , snake_case_ : Optional[int]=True , snake_case_ : Tuple=True , snake_case_ : Tuple=True , snake_case_ : Optional[int]=9_9 , snake_case_ : Dict=3_2 , snake_case_ : Tuple=5 , snake_case_ : Union[str, Any]=4 , snake_case_ : Union[str, Any]=3_7 , snake_case_ : Dict="gelu" , snake_case_ : Tuple=0.1 , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=5_1_2 , snake_case_ : str=1_6 , snake_case_ : Dict=2 , snake_case_ : Optional[Any]=0.0_2 , snake_case_ : Dict=4 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_choices def lowercase ( self : Optional[Any] ): _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_attention_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = RoFormerConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=snake_case_ , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask} return config, inputs_dict @require_flax class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = True _lowerCamelCase : int = ( ( FlaxRoFormerModel, FlaxRoFormerForMaskedLM, FlaxRoFormerForSequenceClassification, FlaxRoFormerForTokenClassification, FlaxRoFormerForMultipleChoice, FlaxRoFormerForQuestionAnswering, ) if is_flax_available() else () ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = FlaxRoFormerModelTester(self ) @slow def lowercase ( self : Tuple ): for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("junnyu/roformer_chinese_small" , from_pt=snake_case_ ) _UpperCAmelCase = model(np.ones((1, 1) ) ) self.assertIsNotNone(snake_case_ ) @require_flax class A_ ( unittest.TestCase ): @slow def lowercase ( self : Optional[Any] ): _UpperCAmelCase = FlaxRoFormerForMaskedLM.from_pretrained("junnyu/roformer_chinese_base" ) _UpperCAmelCase = jnp.array([[0, 1, 2, 3, 4, 5]] ) _UpperCAmelCase = model(snake_case_ )[0] _UpperCAmelCase = 5_0_0_0_0 _UpperCAmelCase = (1, 6, vocab_size) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = jnp.array( [[[-0.1_2_0_5, -1.0_2_6_5, 0.2_9_2_2], [-1.5_1_3_4, 0.1_9_7_4, 0.1_5_1_9], [-5.0_1_3_5, -3.9_0_0_3, -0.8_4_0_4]]] ) self.assertTrue(jnp.allclose(output[:, :3, :3] , snake_case_ , atol=1e-4 ) )
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :Optional[Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :str = { '''google/pegasus-large''': '''https://huggingface.co/google/pegasus-large/resolve/main/config.json''', # See all PEGASUS models at https://huggingface.co/models?filter=pegasus } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Union[str, Any] = """pegasus""" _lowerCamelCase : str = ["""past_key_values"""] _lowerCamelCase : str = {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""} def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=5_0_2_6_5 , snake_case_ : str=1_0_2_4 , snake_case_ : Any=1_2 , snake_case_ : Optional[int]=4_0_9_6 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=1_2 , snake_case_ : Optional[int]=4_0_9_6 , snake_case_ : Any=1_6 , snake_case_ : Tuple=0.0 , snake_case_ : List[Any]=0.0 , snake_case_ : Optional[int]=True , snake_case_ : Optional[Any]=True , snake_case_ : List[Any]="gelu" , snake_case_ : Dict=1_0_2_4 , snake_case_ : str=0.1 , snake_case_ : Tuple=0.0 , snake_case_ : Optional[int]=0.0 , snake_case_ : List[Any]=0.0_2 , snake_case_ : Optional[int]=0 , snake_case_ : str=False , snake_case_ : Dict=0 , snake_case_ : Dict=1 , snake_case_ : List[str]=1 , **snake_case_ : str , ): _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = d_model _UpperCAmelCase = encoder_ffn_dim _UpperCAmelCase = encoder_layers _UpperCAmelCase = encoder_attention_heads _UpperCAmelCase = decoder_ffn_dim _UpperCAmelCase = decoder_layers _UpperCAmelCase = decoder_attention_heads _UpperCAmelCase = dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = activation_function _UpperCAmelCase = init_std _UpperCAmelCase = encoder_layerdrop _UpperCAmelCase = decoder_layerdrop _UpperCAmelCase = use_cache _UpperCAmelCase = encoder_layers _UpperCAmelCase = scale_embedding # scale factor will be sqrt(d_model) if True super().__init__( pad_token_id=snake_case_ , eos_token_id=snake_case_ , is_encoder_decoder=snake_case_ , decoder_start_token_id=snake_case_ , forced_eos_token_id=snake_case_ , **snake_case_ , ) @property def lowercase ( self : List[Any] ): return self.encoder_attention_heads @property def lowercase ( self : Any ): return self.d_model
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' import argparse import json from tqdm import tqdm def UpperCAmelCase_ ( ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( "--src_path" , type=__lowercase , default="biencoder-nq-dev.json" , help="Path to raw DPR training data" , ) parser.add_argument( "--evaluation_set" , type=__lowercase , help="where to store parsed evaluation_set file" , ) parser.add_argument( "--gold_data_path" , type=__lowercase , help="where to store parsed gold_data_path file" , ) _UpperCAmelCase = parser.parse_args() with open(args.src_path , "r" ) as src_file, open(args.evaluation_set , "w" ) as eval_file, open( args.gold_data_path , "w" ) as gold_file: _UpperCAmelCase = json.load(__lowercase ) for dpr_record in tqdm(__lowercase ): _UpperCAmelCase = dpr_record["question"] _UpperCAmelCase = [context["title"] for context in dpr_record["positive_ctxs"]] eval_file.write(question + "\n" ) gold_file.write("\t".join(__lowercase ) + "\n" ) if __name__ == "__main__": main()
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' import json import os from typing import Optional import numpy as np from ...feature_extraction_utils import BatchFeature from ...processing_utils import ProcessorMixin from ...utils import logging from ...utils.hub import get_file_from_repo from ..auto import AutoTokenizer __SCREAMING_SNAKE_CASE :str = logging.get_logger(__name__) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[Any] = """AutoTokenizer""" _lowerCamelCase : int = ["""tokenizer"""] _lowerCamelCase : Dict = { """semantic_prompt""": 1, """coarse_prompt""": 2, """fine_prompt""": 2, } def __init__( self : List[str] , snake_case_ : int , snake_case_ : Optional[Any]=None ): super().__init__(snake_case_ ) _UpperCAmelCase = speaker_embeddings @classmethod def lowercase ( cls : int , snake_case_ : Optional[int] , snake_case_ : List[Any]="speaker_embeddings_path.json" , **snake_case_ : Dict ): if speaker_embeddings_dict_path is not None: _UpperCAmelCase = get_file_from_repo( snake_case_ , snake_case_ , subfolder=kwargs.pop("subfolder" , snake_case_ ) , cache_dir=kwargs.pop("cache_dir" , snake_case_ ) , force_download=kwargs.pop("force_download" , snake_case_ ) , proxies=kwargs.pop("proxies" , snake_case_ ) , resume_download=kwargs.pop("resume_download" , snake_case_ ) , local_files_only=kwargs.pop("local_files_only" , snake_case_ ) , use_auth_token=kwargs.pop("use_auth_token" , snake_case_ ) , revision=kwargs.pop("revision" , snake_case_ ) , ) if speaker_embeddings_path is None: logger.warning( f'`{os.path.join(snake_case_ , snake_case_ )}` does not exists\n , no preloaded speaker embeddings will be used - Make sure to provide a correct path to the json\n dictionnary if wanted, otherwise set `speaker_embeddings_dict_path=None`.' ) _UpperCAmelCase = None else: with open(snake_case_ ) as speaker_embeddings_json: _UpperCAmelCase = json.load(snake_case_ ) else: _UpperCAmelCase = None _UpperCAmelCase = AutoTokenizer.from_pretrained(snake_case_ , **snake_case_ ) return cls(tokenizer=snake_case_ , speaker_embeddings=snake_case_ ) def lowercase ( self : Tuple , snake_case_ : List[Any] , snake_case_ : Dict="speaker_embeddings_path.json" , snake_case_ : List[str]="speaker_embeddings" , snake_case_ : bool = False , **snake_case_ : Any , ): if self.speaker_embeddings is not None: os.makedirs(os.path.join(snake_case_ , snake_case_ , "v2" ) , exist_ok=snake_case_ ) _UpperCAmelCase = {} _UpperCAmelCase = save_directory for prompt_key in self.speaker_embeddings: if prompt_key != "repo_or_path": _UpperCAmelCase = self._load_voice_preset(snake_case_ ) _UpperCAmelCase = {} for key in self.speaker_embeddings[prompt_key]: np.save( os.path.join( embeddings_dict["repo_or_path"] , snake_case_ , f'{prompt_key}_{key}' ) , voice_preset[key] , allow_pickle=snake_case_ , ) _UpperCAmelCase = os.path.join(snake_case_ , f'{prompt_key}_{key}.npy' ) _UpperCAmelCase = tmp_dict with open(os.path.join(snake_case_ , snake_case_ ) , "w" ) as fp: json.dump(snake_case_ , snake_case_ ) super().save_pretrained(snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : str , snake_case_ : str = None , **snake_case_ : Tuple ): _UpperCAmelCase = self.speaker_embeddings[voice_preset] _UpperCAmelCase = {} for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]: if key not in voice_preset_paths: raise ValueError( f'Voice preset unrecognized, missing {key} as a key in self.speaker_embeddings[{voice_preset}].' ) _UpperCAmelCase = get_file_from_repo( self.speaker_embeddings.get("repo_or_path" , "/" ) , voice_preset_paths[key] , subfolder=kwargs.pop("subfolder" , snake_case_ ) , cache_dir=kwargs.pop("cache_dir" , snake_case_ ) , force_download=kwargs.pop("force_download" , snake_case_ ) , proxies=kwargs.pop("proxies" , snake_case_ ) , resume_download=kwargs.pop("resume_download" , snake_case_ ) , local_files_only=kwargs.pop("local_files_only" , snake_case_ ) , use_auth_token=kwargs.pop("use_auth_token" , snake_case_ ) , revision=kwargs.pop("revision" , snake_case_ ) , ) if path is None: raise ValueError( f'`{os.path.join(self.speaker_embeddings.get("repo_or_path" , "/" ) , voice_preset_paths[key] )}` does not exists\n , no preloaded voice preset will be used - Make sure to provide correct paths to the {voice_preset}\n embeddings.' ) _UpperCAmelCase = np.load(snake_case_ ) return voice_preset_dict def lowercase ( self : List[Any] , snake_case_ : Optional[dict] = None ): for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]: if key not in voice_preset: raise ValueError(f'Voice preset unrecognized, missing {key} as a key.' ) if not isinstance(voice_preset[key] , np.ndarray ): raise ValueError(f'{key} voice preset must be a {str(self.preset_shape[key] )}D ndarray.' ) if len(voice_preset[key].shape ) != self.preset_shape[key]: raise ValueError(f'{key} voice preset must be a {str(self.preset_shape[key] )}D ndarray.' ) def __call__( self : List[Any] , snake_case_ : Tuple=None , snake_case_ : Any=None , snake_case_ : Any="pt" , snake_case_ : List[str]=2_5_6 , snake_case_ : str=False , snake_case_ : Dict=True , snake_case_ : str=False , **snake_case_ : Optional[int] , ): if voice_preset is not None and not isinstance(snake_case_ , snake_case_ ): if ( isinstance(snake_case_ , snake_case_ ) and self.speaker_embeddings is not None and voice_preset in self.speaker_embeddings ): _UpperCAmelCase = self._load_voice_preset(snake_case_ ) else: if isinstance(snake_case_ , snake_case_ ) and not voice_preset.endswith(".npz" ): _UpperCAmelCase = voice_preset + ".npz" _UpperCAmelCase = np.load(snake_case_ ) if voice_preset is not None: self._validate_voice_preset_dict(snake_case_ , **snake_case_ ) _UpperCAmelCase = BatchFeature(data=snake_case_ , tensor_type=snake_case_ ) _UpperCAmelCase = self.tokenizer( snake_case_ , return_tensors=snake_case_ , padding="max_length" , max_length=snake_case_ , return_attention_mask=snake_case_ , return_token_type_ids=snake_case_ , add_special_tokens=snake_case_ , **snake_case_ , ) if voice_preset is not None: _UpperCAmelCase = voice_preset return encoded_text
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__lowercase ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : list , __lowercase : int , __lowercase : int = 0 , __lowercase : int = 0 ) -> int: '''simple docstring''' _UpperCAmelCase = right or len(__lowercase ) - 1 if left > right: return -1 elif list_data[left] == key: return left elif list_data[right] == key: return right else: return search(__lowercase , __lowercase , left + 1 , right - 1 ) if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1
'''simple docstring''' import argparse import dataclasses import json import logging import os import shutil from typing import List, Optional import datasets from accelerate import Accelerator from datasets import load_dataset from finetuning import finetune from tqdm.auto import tqdm import transformers from transformers import AutoConfig, set_seed from transformers.trainer_utils import IntervalStrategy __SCREAMING_SNAKE_CASE :int = logging.getLogger(__name__) __SCREAMING_SNAKE_CASE :Optional[int] = '''pytorch_model.bin''' @dataclasses.dataclass class A_ : _lowerCamelCase : str = dataclasses.field( metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models."""} ) _lowerCamelCase : Optional[str] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co."""} , ) @dataclasses.dataclass class A_ : _lowerCamelCase : str = dataclasses.field(metadata={"""help""": """A csv or a json file containing the training data."""} ) _lowerCamelCase : str = dataclasses.field(metadata={"""help""": """A csv or a json file containing the data to predict on."""} ) _lowerCamelCase : Optional[str] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """A csv or a json file containing the validation data."""} ) _lowerCamelCase : Optional[str] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """The name of the task to train on."""} , ) _lowerCamelCase : Optional[List[str]] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """The list of labels for the task."""} ) @dataclasses.dataclass class A_ : _lowerCamelCase : str = dataclasses.field( metadata={"""help""": """The output directory where the model predictions and checkpoints will be written."""} ) _lowerCamelCase : Optional[str] = dataclasses.field( default="""accuracy""" , metadata={"""help""": """The evaluation metric used for the task."""} ) _lowerCamelCase : Optional[str] = dataclasses.field( default="""no""" , metadata={ """help""": """The evaluation strategy to adopt during training. Possible values are: [\"no\", \"step\", \"epoch]""" } , ) _lowerCamelCase : Optional[int] = dataclasses.field( default=10 , metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""} , ) _lowerCamelCase : Optional[float] = dataclasses.field( default=0.0 , metadata={ """help""": """How much the specified evaluation metric must improve to satisfy early stopping conditions.""" } , ) _lowerCamelCase : Optional[bool] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """Whether to filter the pseudo-labeled data based on the confidence score."""} , ) _lowerCamelCase : Optional[bool] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """Whether to filter the pseudo-labeled data based on the validation performance."""} , ) _lowerCamelCase : Optional[bool] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """Whether to fine-tune on labeled data after pseudo training."""} , ) _lowerCamelCase : Optional[float] = dataclasses.field( default=0.0 , metadata={"""help""": """Confidence threshold for pseudo-labeled data filtering."""} , ) _lowerCamelCase : Optional[int] = dataclasses.field( default=1_00 , metadata={"""help""": """Number of evaluation calls with no improvement after which training will be stopped."""} , ) _lowerCamelCase : Optional[int] = dataclasses.field( default=lowerCAmelCase_ , metadata={"""help""": """Random seed for initialization."""} , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : List[Any] , __lowercase : Optional[Any] , __lowercase : List[str] , __lowercase : str , __lowercase : str ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = datasets.concatenate_datasets([infer_input, infer_output] , axis=1 ) if args.do_filter_by_confidence: _UpperCAmelCase = dataset.filter(lambda __lowercase : example["probability"] > args.confidence_threshold ) if args.do_filter_by_val_performance: assert eval_result >= 0.0 and eval_result <= 1.0 _UpperCAmelCase = int(eval_result * len(__lowercase ) ) print(__lowercase ) _UpperCAmelCase = dataset.sort("probability" , reverse=__lowercase ) _UpperCAmelCase = dataset.select(range(__lowercase ) ) _UpperCAmelCase = dataset.remove_columns(["label", "probability"] ) _UpperCAmelCase = dataset.rename_column("prediction" , "label" ) _UpperCAmelCase = dataset.map(lambda __lowercase : {"label": idalabel[example["label"]]} ) _UpperCAmelCase = dataset.shuffle(seed=args.seed ) _UpperCAmelCase = os.path.join(__lowercase , f'train_pseudo.{args.data_file_extension}' ) if args.data_file_extension == "csv": dataset.to_csv(__lowercase , index=__lowercase ) else: dataset.to_json(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : int , __lowercase : Dict , __lowercase : List[str] , **__lowercase : Optional[int] ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = 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 , ) logger.info(accelerator.state ) # 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() _UpperCAmelCase = STModelArguments(model_name_or_path=__lowercase ) _UpperCAmelCase = STDataArguments(train_file=__lowercase , infer_file=__lowercase ) _UpperCAmelCase = STTrainingArguments(output_dir=__lowercase ) _UpperCAmelCase = argparse.Namespace() for arg_class in (model_args, data_args, training_args): for key, value in vars(__lowercase ).items(): setattr(__lowercase , __lowercase , __lowercase ) for key, value in kwargs.items(): if hasattr(__lowercase , __lowercase ): setattr(__lowercase , __lowercase , __lowercase ) # Sanity checks _UpperCAmelCase = {} _UpperCAmelCase = None # You need to provide the training data and the data to predict on assert args.train_file is not None assert args.infer_file is not None _UpperCAmelCase = args.train_file _UpperCAmelCase = args.infer_file if args.evaluation_strategy != IntervalStrategy.NO.value: assert args.eval_file is not None _UpperCAmelCase = args.eval_file for key in data_files: _UpperCAmelCase = data_files[key].split("." )[-1] assert extension in ["csv", "json"], f'`{key}_file` should be a csv or a json file.' if args.data_file_extension is None: _UpperCAmelCase = extension else: assert extension == args.data_file_extension, f'`{key}_file` should be a {args.data_file_extension} file`.' assert ( args.eval_metric in datasets.list_metrics() ), f'{args.eval_metric} not in the list of supported metrics {datasets.list_metrics()}.' # If passed along, set the training seed now. if args.seed is not None: set_seed(args.seed ) logger.info("Creating the initial data directory for self-training..." ) _UpperCAmelCase = f'{args.output_dir}/self-train_iter-{{}}'.format _UpperCAmelCase = data_dir_format(0 ) if accelerator.is_main_process: if args.output_dir is not None: os.makedirs(args.output_dir , exist_ok=__lowercase ) os.makedirs(__lowercase , exist_ok=__lowercase ) accelerator.wait_for_everyone() _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = 0 _UpperCAmelCase = False # Show the progress bar _UpperCAmelCase = tqdm(range(args.max_selftrain_iterations ) , disable=not accelerator.is_local_main_process ) # Self-train for iteration in range(0 , int(args.max_selftrain_iterations ) ): _UpperCAmelCase = data_dir_format(__lowercase ) assert os.path.exists(__lowercase ) # Stage 1: initial fine-tuning for iteration = 0 or pseudo-training for # iteration > 0 _UpperCAmelCase = os.path.join(__lowercase , "stage-1" ) _UpperCAmelCase = { "accelerator": accelerator, "model_name_or_path": args.model_name_or_path, "cache_dir": args.cache_dir, "do_train": True, "train_file": data_files["train"] if iteration == 0 else data_files["train_pseudo"], "do_eval": True if args.eval_file is not None else False, "eval_file": data_files["eval"], "do_predict": True, "infer_file": data_files["infer"], "task_name": args.task_name, "label_list": args.label_list, "output_dir": current_output_dir, "eval_metric": args.eval_metric, "evaluation_strategy": args.evaluation_strategy, "early_stopping_patience": args.early_stopping_patience, "early_stopping_threshold": args.early_stopping_threshold, "seed": args.seed, } # Add additional training arguments for key, value in kwargs.items(): if key not in arguments_dict and not hasattr(__lowercase , __lowercase ): arguments_dict.update({key: value} ) _UpperCAmelCase = os.path.join(__lowercase , "best-checkpoint" , __lowercase ) if os.path.exists(__lowercase ): logger.info( "Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 1." , __lowercase , __lowercase , ) else: logger.info("***** Running self-training: iteration: %d, stage: 1 *****" , __lowercase ) finetune(**__lowercase ) accelerator.wait_for_everyone() assert os.path.exists(__lowercase ) logger.info("Self-training job completed: iteration: %d, stage: 1." , __lowercase ) if iteration > 0 and args.finetune_on_labeled_data: # Stage 2 (optional): fine-tuning on the original labeled data _UpperCAmelCase = os.path.join(__lowercase , "best-checkpoint" ) _UpperCAmelCase = os.path.join(__lowercase , "stage-2" ) # Update arguments_dict _UpperCAmelCase = model_path _UpperCAmelCase = data_files["train"] _UpperCAmelCase = current_output_dir _UpperCAmelCase = os.path.join(__lowercase , "best-checkpoint" , __lowercase ) if os.path.exists(__lowercase ): logger.info( "Found existing model checkpoint at %s. Skipping self-training: iteration: %d, stage: 2." , __lowercase , __lowercase , ) else: logger.info("***** Running self-training: iteration: %d, stage: 2 *****" , __lowercase ) finetune(**__lowercase ) accelerator.wait_for_everyone() assert os.path.exists(__lowercase ) logger.info("Self-training job completed: iteration: %d, stage: 2." , __lowercase ) _UpperCAmelCase = iteration _UpperCAmelCase = data_dir_format(iteration + 1 ) _UpperCAmelCase = AutoConfig.from_pretrained(os.path.join(__lowercase , "best-checkpoint" ) ) _UpperCAmelCase = config.idalabel _UpperCAmelCase = os.path.join(__lowercase , "eval_results_best-checkpoint.json" ) _UpperCAmelCase = os.path.join(__lowercase , "test_results_best-checkpoint.json" ) assert os.path.exists(__lowercase ) with open(__lowercase , "r" ) as f: _UpperCAmelCase = float(json.load(__lowercase )[args.eval_metric] ) _UpperCAmelCase = os.path.join(__lowercase , "infer_output_best-checkpoint.csv" ) assert os.path.exists(__lowercase ) # Loading the dataset from local csv or json files. _UpperCAmelCase = load_dataset(args.data_file_extension , data_files={"data": data_files["infer"]} )["data"] _UpperCAmelCase = load_dataset("csv" , data_files={"data": infer_output_file} )["data"] if accelerator.is_main_process: os.makedirs(__lowercase , exist_ok=__lowercase ) shutil.copy(__lowercase , os.path.join(__lowercase , f'eval_results_iter-{iteration}.json' ) ) if os.path.exists(__lowercase ): shutil.copy(__lowercase , os.path.join(__lowercase , f'test_results_iter-{iteration}.json' ) ) create_pseudo_labeled_data(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase ) accelerator.wait_for_everyone() _UpperCAmelCase = os.path.join(__lowercase , f'train_pseudo.{args.data_file_extension}' ) if args.evaluation_strategy != IntervalStrategy.NO.value: _UpperCAmelCase = eval_result if best_iteration is None: _UpperCAmelCase = new_iteration _UpperCAmelCase = new_eval_result else: if new_eval_result - best_eval_result > args.early_stopping_threshold: _UpperCAmelCase = new_iteration _UpperCAmelCase = new_eval_result _UpperCAmelCase = 0 else: if new_eval_result == best_eval_result: _UpperCAmelCase = new_iteration _UpperCAmelCase = new_eval_result early_stopping_patience_counter += 1 if early_stopping_patience_counter >= args.early_stopping_patience: _UpperCAmelCase = True progress_bar.update(1 ) if should_training_stop: break if best_iteration is not None: # Save the best iteration logger.info("Best iteration: %d" , __lowercase ) logger.info("Best evaluation result: %s = %f" , args.eval_metric , __lowercase ) accelerator.wait_for_everyone() if accelerator.is_main_process: shutil.copy( os.path.join(__lowercase , f'eval_results_iter-{iteration}.json' ) , os.path.join(__lowercase , "eval_results_best-iteration.json" ) , ) else: # Assume that the last iteration is the best logger.info("Best iteration: %d" , args.max_selftrain_iterations - 1 ) logger.info("Best evaluation result: %s = %f" , args.eval_metric , __lowercase ) accelerator.wait_for_everyone() if accelerator.is_main_process: shutil.copy( os.path.join(__lowercase , f'eval_results_iter-{args.max_selftrain_iterations - 1}.json' ) , os.path.join(__lowercase , "eval_results_best-iteration.json" ) , )
22
'''simple docstring''' 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: __SCREAMING_SNAKE_CASE :List[Any] = None __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''', }, } __SCREAMING_SNAKE_CASE :Optional[Any] = { '''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, } __SCREAMING_SNAKE_CASE :Optional[int] = '''▁''' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = VOCAB_FILES_NAMES _lowerCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : int = AlbertTokenizer def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=True , snake_case_ : str=True , snake_case_ : Tuple=False , snake_case_ : List[Any]="[CLS]" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : str="<unk>" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : List[Any]="<pad>" , snake_case_ : List[str]="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. _UpperCAmelCase = ( AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ , normalized=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token ) super().__init__( snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
1
'''simple docstring''' from __future__ import annotations import numpy as np def UpperCAmelCase_ ( __lowercase : np.ndarray ) -> tuple[np.ndarray, np.ndarray]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = np.shape(__lowercase ) if rows != columns: _UpperCAmelCase = ( "'table' has to be of square shaped array but got a " f'{rows}x{columns} array:\n{table}' ) raise ValueError(__lowercase ) _UpperCAmelCase = np.zeros((rows, columns) ) _UpperCAmelCase = np.zeros((rows, columns) ) for i in range(__lowercase ): for j in range(__lowercase ): _UpperCAmelCase = sum(lower[i][k] * upper[k][j] for k in range(__lowercase ) ) if upper[j][j] == 0: raise ArithmeticError("No LU decomposition exists" ) _UpperCAmelCase = (table[i][j] - total) / upper[j][j] _UpperCAmelCase = 1 for j in range(__lowercase , __lowercase ): _UpperCAmelCase = sum(lower[i][k] * upper[k][j] for k in range(__lowercase ) ) _UpperCAmelCase = table[i][j] - total return lower, upper if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import _LazyModule __SCREAMING_SNAKE_CASE :Dict = {'''tokenization_bertweet''': ['''BertweetTokenizer''']} if TYPE_CHECKING: from .tokenization_bertweet import BertweetTokenizer else: import sys __SCREAMING_SNAKE_CASE :Optional[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef __SCREAMING_SNAKE_CASE :List[str] = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : Tuple ) -> int: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase_ ( __lowercase : int , __lowercase : str ) -> Optional[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = simple_accuracy(__lowercase , __lowercase ) _UpperCAmelCase = fa_score(y_true=__lowercase , y_pred=__lowercase ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : List[str] ) -> List[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = pearsonr(__lowercase , __lowercase )[0] _UpperCAmelCase = spearmanr(__lowercase , __lowercase )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) assert len(__lowercase ) == len(__lowercase ), f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' if task_name == "cola": return {"mcc": matthews_corrcoef(__lowercase , __lowercase )} elif task_name == "sst-2": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mrpc": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "sts-b": return pearson_and_spearman(__lowercase , __lowercase ) elif task_name == "qqp": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "qnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "rte": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "wnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "hans": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : Dict , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) if len(__lowercase ) != len(__lowercase ): raise ValueError(f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' ) if task_name == "xnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase )
22
1
'''simple docstring''' from argparse import ArgumentParser from . import BaseTransformersCLICommand def UpperCAmelCase_ ( __lowercase : int ) -> Tuple: '''simple docstring''' return DownloadCommand(args.model , args.cache_dir , args.force , args.trust_remote_code ) class A_ ( lowerCAmelCase_ ): @staticmethod def lowercase ( snake_case_ : ArgumentParser ): _UpperCAmelCase = parser.add_parser("download" ) download_parser.add_argument( "--cache-dir" , type=snake_case_ , default=snake_case_ , help="Path to location to store the models" ) download_parser.add_argument( "--force" , action="store_true" , help="Force the model to be download even if already in cache-dir" ) download_parser.add_argument( "--trust-remote-code" , action="store_true" , help="Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine" , ) download_parser.add_argument("model" , type=snake_case_ , help="Name of the model to download" ) download_parser.set_defaults(func=snake_case_ ) def __init__( self : Tuple , snake_case_ : str , snake_case_ : str , snake_case_ : bool , snake_case_ : bool ): _UpperCAmelCase = model _UpperCAmelCase = cache _UpperCAmelCase = force _UpperCAmelCase = trust_remote_code def lowercase ( self : Any ): from ..models.auto import AutoModel, AutoTokenizer AutoModel.from_pretrained( self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code ) AutoTokenizer.from_pretrained( self._model , cache_dir=self._cache , force_download=self._force , trust_remote_code=self._trust_remote_code )
22
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
1
'''simple docstring''' __SCREAMING_SNAKE_CASE :int = { '''meter''': '''m''', '''kilometer''': '''km''', '''megametre''': '''Mm''', '''gigametre''': '''Gm''', '''terametre''': '''Tm''', '''petametre''': '''Pm''', '''exametre''': '''Em''', '''zettametre''': '''Zm''', '''yottametre''': '''Ym''', } # Exponent of the factor(meter) __SCREAMING_SNAKE_CASE :List[Any] = { '''m''': 0, '''km''': 3, '''Mm''': 6, '''Gm''': 9, '''Tm''': 12, '''Pm''': 15, '''Em''': 18, '''Zm''': 21, '''Ym''': 24, } def UpperCAmelCase_ ( __lowercase : float , __lowercase : str , __lowercase : str ) -> float: '''simple docstring''' _UpperCAmelCase = from_type.lower().strip("s" ) _UpperCAmelCase = to_type.lower().strip("s" ) _UpperCAmelCase = UNIT_SYMBOL.get(__lowercase , __lowercase ) _UpperCAmelCase = UNIT_SYMBOL.get(__lowercase , __lowercase ) if from_sanitized not in METRIC_CONVERSION: _UpperCAmelCase = ( f'Invalid \'from_type\' value: {from_type!r}.\n' f'Conversion abbreviations are: {", ".join(__lowercase )}' ) raise ValueError(__lowercase ) if to_sanitized not in METRIC_CONVERSION: _UpperCAmelCase = ( f'Invalid \'to_type\' value: {to_type!r}.\n' f'Conversion abbreviations are: {", ".join(__lowercase )}' ) raise ValueError(__lowercase ) _UpperCAmelCase = METRIC_CONVERSION[from_sanitized] _UpperCAmelCase = METRIC_CONVERSION[to_sanitized] _UpperCAmelCase = 1 if from_exponent > to_exponent: _UpperCAmelCase = from_exponent - to_exponent else: _UpperCAmelCase = -(to_exponent - from_exponent) return value * pow(10 , __lowercase ) if __name__ == "__main__": from doctest import testmod testmod()
22
'''simple docstring''' import os from datetime import datetime as dt from github import Github __SCREAMING_SNAKE_CASE :str = [ '''good first issue''', '''feature request''', '''wip''', ] def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = Github(os.environ["GITHUB_TOKEN"] ) _UpperCAmelCase = g.get_repo("huggingface/accelerate" ) _UpperCAmelCase = repo.get_issues(state="open" ) for issue in open_issues: _UpperCAmelCase = sorted([comment for comment in issue.get_comments()] , key=lambda __lowercase : i.created_at , reverse=__lowercase ) _UpperCAmelCase = comments[0] if len(__lowercase ) > 0 else None _UpperCAmelCase = dt.utcnow() _UpperCAmelCase = (current_time - issue.updated_at).days _UpperCAmelCase = (current_time - issue.created_at).days if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and days_since_updated > 7 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Close issue since it has been 7 days of inactivity since bot mention. issue.edit(state="closed" ) elif ( days_since_updated > 23 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Add stale comment issue.create_comment( "This issue has been automatically marked as stale because it has not had " "recent activity. If you think this still needs to be addressed " "please comment on this thread.\n\nPlease note that issues that do not follow the " "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) " "are likely to be ignored." ) if __name__ == "__main__": main()
22
1
'''simple docstring''' import unittest from diffusers.models.unet_ad_blocks import * # noqa F403 from diffusers.utils import torch_device from .test_unet_blocks_common import UNetBlockTesterMixin class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = DownBlockaD # noqa F405 _lowerCamelCase : Optional[int] = """down""" def lowercase ( self : List[Any] ): _UpperCAmelCase = [-0.0_2_3_2, -0.9_8_6_9, 0.8_0_5_4, -0.0_6_3_7, -0.1_6_8_8, -1.4_2_6_4, 0.4_4_7_0, -1.3_3_9_4, 0.0_9_0_4] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = ResnetDownsampleBlockaD # noqa F405 _lowerCamelCase : Tuple = """down""" def lowercase ( self : Dict ): _UpperCAmelCase = [0.0_7_1_0, 0.2_4_1_0, -0.7_3_2_0, -1.0_7_5_7, -1.1_3_4_3, 0.3_5_4_0, -0.0_1_3_3, -0.2_5_7_6, 0.0_9_4_8] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Optional[int] = AttnDownBlockaD # noqa F405 _lowerCamelCase : Optional[int] = """down""" def lowercase ( self : Dict ): _UpperCAmelCase = [0.0_6_3_6, 0.8_9_6_4, -0.6_2_3_4, -1.0_1_3_1, 0.0_8_4_4, 0.4_9_3_5, 0.3_4_3_7, 0.0_9_1_1, -0.2_9_5_7] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Optional[Any] = CrossAttnDownBlockaD # noqa F405 _lowerCamelCase : Dict = """down""" def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase = [0.2_2_3_8, -0.7_3_9_6, -0.2_2_5_5, -0.3_8_2_9, 0.1_9_2_5, 1.1_6_6_5, 0.0_6_0_3, -0.7_2_9_5, 0.1_9_8_3] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : str = SimpleCrossAttnDownBlockaD # noqa F405 _lowerCamelCase : List[Any] = """down""" @property def lowercase ( self : Optional[Any] ): return super().get_dummy_input(include_encoder_hidden_states=snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict @unittest.skipIf(torch_device == "mps" , "MPS result is not consistent" ) def lowercase ( self : Dict ): _UpperCAmelCase = [0.7_9_2_1, -0.0_9_9_2, -0.1_9_6_2, -0.7_6_9_5, -0.4_2_4_2, 0.7_8_0_4, 0.4_7_3_7, 0.2_7_6_5, 0.3_3_3_8] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Union[str, Any] = SkipDownBlockaD # noqa F405 _lowerCamelCase : Optional[int] = """down""" @property def lowercase ( self : List[str] ): return super().get_dummy_input(include_skip_sample=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = [-0.0_8_4_5, -0.2_0_8_7, -0.2_4_6_5, 0.0_9_7_1, 0.1_9_0_0, -0.0_4_8_4, 0.2_6_6_4, 0.4_1_7_9, 0.5_0_6_9] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = AttnSkipDownBlockaD # noqa F405 _lowerCamelCase : Optional[int] = """down""" @property def lowercase ( self : Any ): return super().get_dummy_input(include_skip_sample=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = [0.5_5_3_9, 0.1_6_0_9, 0.4_9_2_4, 0.0_5_3_7, -0.1_9_9_5, 0.4_0_5_0, 0.0_9_7_9, -0.2_7_2_1, -0.0_6_4_2] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : str = DownEncoderBlockaD # noqa F405 _lowerCamelCase : Any = """down""" @property def lowercase ( self : Dict ): return super().get_dummy_input(include_temb=snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase = { "in_channels": 3_2, "out_channels": 3_2, } _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = [1.1_1_0_2, 0.5_3_0_2, 0.4_8_7_2, -0.0_0_2_3, -0.8_0_4_2, 0.0_4_8_3, -0.3_4_8_9, -0.5_6_3_2, 0.7_6_2_6] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Optional[Any] = AttnDownEncoderBlockaD # noqa F405 _lowerCamelCase : str = """down""" @property def lowercase ( self : str ): return super().get_dummy_input(include_temb=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = { "in_channels": 3_2, "out_channels": 3_2, } _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict def lowercase ( self : Tuple ): _UpperCAmelCase = [0.8_9_6_6, -0.1_4_8_6, 0.8_5_6_8, 0.8_1_4_1, -0.9_0_4_6, -0.1_3_4_2, -0.0_9_7_2, -0.7_4_1_7, 0.1_5_3_8] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = UNetMidBlockaD # noqa F405 _lowerCamelCase : Dict = """mid""" def lowercase ( self : List[str] ): _UpperCAmelCase = { "in_channels": 3_2, "temb_channels": 1_2_8, } _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = [-0.1_0_6_2, 1.7_2_4_8, 0.3_4_9_4, 1.4_5_6_9, -0.0_9_1_0, -1.2_4_2_1, -0.9_9_8_4, 0.6_7_3_6, 1.0_0_2_8] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = UNetMidBlockaDCrossAttn # noqa F405 _lowerCamelCase : Any = """mid""" def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict def lowercase ( self : str ): _UpperCAmelCase = [0.0_1_8_7, 2.4_2_2_0, 0.4_4_8_4, 1.1_2_0_3, -0.6_1_2_1, -1.5_1_2_2, -0.8_2_7_0, 0.7_8_5_1, 1.8_3_3_5] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = UNetMidBlockaDSimpleCrossAttn # noqa F405 _lowerCamelCase : List[Any] = """mid""" @property def lowercase ( self : Tuple ): return super().get_dummy_input(include_encoder_hidden_states=snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict def lowercase ( self : Dict ): _UpperCAmelCase = [0.7_1_4_3, 1.9_9_7_4, 0.5_4_4_8, 1.3_9_7_7, 0.1_2_8_2, -1.1_2_3_7, -1.4_2_3_8, 0.5_5_3_0, 0.8_8_8_0] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : int = UpBlockaD # noqa F405 _lowerCamelCase : Optional[int] = """up""" @property def lowercase ( self : List[str] ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase = [-0.2_0_4_1, -0.4_1_6_5, -0.3_0_2_2, 0.0_0_4_1, -0.6_6_2_8, -0.7_0_5_3, 0.1_9_2_8, -0.0_3_2_5, 0.0_5_2_3] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Any = ResnetUpsampleBlockaD # noqa F405 _lowerCamelCase : Union[str, Any] = """up""" @property def lowercase ( self : List[str] ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase = [0.2_2_8_7, 0.3_5_4_9, -0.1_3_4_6, 0.4_7_9_7, -0.1_7_1_5, -0.9_6_4_9, 0.7_3_0_5, -0.5_8_6_4, -0.6_2_4_4] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Any = CrossAttnUpBlockaD # noqa F405 _lowerCamelCase : Any = """up""" @property def lowercase ( self : List[str] ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict def lowercase ( self : int ): _UpperCAmelCase = [-0.1_4_0_3, -0.3_5_1_5, -0.0_4_2_0, -0.1_4_2_5, 0.3_1_6_7, 0.5_0_9_4, -0.2_1_8_1, 0.5_9_3_1, 0.5_5_8_2] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = SimpleCrossAttnUpBlockaD # noqa F405 _lowerCamelCase : Tuple = """up""" @property def lowercase ( self : Any ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ , include_encoder_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase , _UpperCAmelCase = super().prepare_init_args_and_inputs_for_common() _UpperCAmelCase = 3_2 return init_dict, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase = [0.2_6_4_5, 0.1_4_8_0, 0.0_9_0_9, 0.8_0_4_4, -0.9_7_5_8, -0.9_0_8_3, 0.0_9_9_4, -1.1_4_5_3, -0.7_4_0_2] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = AttnUpBlockaD # noqa F405 _lowerCamelCase : str = """up""" @property def lowercase ( self : Optional[int] ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) @unittest.skipIf(torch_device == "mps" , "MPS result is not consistent" ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = [0.0_9_7_9, 0.1_3_2_6, 0.0_0_2_1, 0.0_6_5_9, 0.2_2_4_9, 0.0_0_5_9, 0.1_1_3_2, 0.5_9_5_2, 0.1_0_3_3] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = SkipUpBlockaD # noqa F405 _lowerCamelCase : Union[str, Any] = """up""" @property def lowercase ( self : Tuple ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = [-0.0_8_9_3, -0.1_2_3_4, -0.1_5_0_6, -0.0_3_3_2, 0.0_1_2_3, -0.0_2_1_1, 0.0_5_6_6, 0.0_1_4_3, 0.0_3_6_2] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Optional[Any] = AttnSkipUpBlockaD # noqa F405 _lowerCamelCase : int = """up""" @property def lowercase ( self : List[Any] ): return super().get_dummy_input(include_res_hidden_states_tuple=snake_case_ ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [0.0_3_6_1, 0.0_6_1_7, 0.2_7_8_7, -0.0_3_5_0, 0.0_3_4_2, 0.3_4_2_1, -0.0_8_4_3, 0.0_9_1_3, 0.3_0_1_5] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = UpDecoderBlockaD # noqa F405 _lowerCamelCase : Tuple = """up""" @property def lowercase ( self : Optional[Any] ): return super().get_dummy_input(include_temb=snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = {"in_channels": 3_2, "out_channels": 3_2} _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict def lowercase ( self : Optional[int] ): _UpperCAmelCase = [0.4_4_0_4, 0.1_9_9_8, -0.9_8_8_6, -0.3_3_2_0, -0.3_1_2_8, -0.7_0_3_4, -0.6_9_5_5, -0.2_3_3_8, -0.3_1_3_7] super().test_output(snake_case_ ) class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Union[str, Any] = AttnUpDecoderBlockaD # noqa F405 _lowerCamelCase : int = """up""" @property def lowercase ( self : Optional[int] ): return super().get_dummy_input(include_temb=snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = {"in_channels": 3_2, "out_channels": 3_2} _UpperCAmelCase = self.dummy_input return init_dict, inputs_dict def lowercase ( self : Optional[int] ): _UpperCAmelCase = [0.6_7_3_8, 0.4_4_9_1, 0.1_0_5_5, 1.0_7_1_0, 0.7_3_1_6, 0.3_3_3_9, 0.3_3_5_2, 0.1_0_2_3, 0.3_5_6_8] super().test_output(snake_case_ )
22
'''simple docstring''' import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( "files" , [ ["full:README.md", "dataset_infos.json"], ["empty:README.md", "dataset_infos.json"], ["dataset_infos.json"], ["full:README.md"], ] , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : int ) -> int: '''simple docstring''' _UpperCAmelCase = tmp_path_factory.mktemp("dset_infos_dir" ) if "full:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("---\ndataset_info:\n dataset_size: 42\n---" ) if "empty:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("" ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / "dataset_infos.json" , "w" ) as f: f.write("{\"default\": {\"dataset_size\": 42}}" ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( "dataset_info" , [ DatasetInfo(), DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ), ] , ) def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : DatasetInfo ) -> Any: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_info.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfo.from_directory(__lowercase ) assert dataset_info == reloaded assert os.path.exists(os.path.join(__lowercase , "dataset_info.json" ) ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = DatasetInfo( description="foo" , citation="bar" , homepage="https://foo.bar" , license="CC0" , features=Features({"a": Value("int32" )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train", "num_examples": 42}] , download_checksums={} , download_size=1337 , post_processing_size=442 , dataset_size=1234 , size_in_bytes=1337 + 442 + 1234 , ) _UpperCAmelCase = dataset_info._to_yaml_dict() assert sorted(__lowercase ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _UpperCAmelCase = yaml.safe_dump(__lowercase ) _UpperCAmelCase = yaml.safe_load(__lowercase ) assert dataset_info_yaml_dict == reloaded def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = DatasetInfo() _UpperCAmelCase = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( "dataset_infos_dict" , [ DatasetInfosDict(), DatasetInfosDict({"default": DatasetInfo()} ), DatasetInfosDict({"my_config_name": DatasetInfo()} ), DatasetInfosDict( { "default": DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ) } ), DatasetInfosDict( { "v1": DatasetInfo(dataset_size=42 ), "v2": DatasetInfo(dataset_size=1337 ), } ), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : DatasetInfosDict ) -> Dict: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_infos_dict.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _UpperCAmelCase = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _UpperCAmelCase = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(__lowercase , "README.md" ) )
22
1
'''simple docstring''' import json import os import unittest from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer from ...test_tokenization_common import TokenizerTesterMixin class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : str = CTRLTokenizer _lowerCamelCase : str = False _lowerCamelCase : str = False def lowercase ( self : List[Any] ): super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt _UpperCAmelCase = ["adapt", "re@@", "a@@", "apt", "c@@", "t", "<unk>"] _UpperCAmelCase = dict(zip(snake_case_ , range(len(snake_case_ ) ) ) ) _UpperCAmelCase = ["#version: 0.2", "a p", "ap t</w>", "r e", "a d", "ad apt</w>", ""] _UpperCAmelCase = {"unk_token": "<unk>"} _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["vocab_file"] ) _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["merges_file"] ) with open(self.vocab_file , "w" , encoding="utf-8" ) as fp: fp.write(json.dumps(snake_case_ ) + "\n" ) with open(self.merges_file , "w" , encoding="utf-8" ) as fp: fp.write("\n".join(snake_case_ ) ) def lowercase ( self : List[Any] , **snake_case_ : str ): kwargs.update(self.special_tokens_map ) return CTRLTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Dict ): _UpperCAmelCase = "adapt react readapt apt" _UpperCAmelCase = "adapt react readapt apt" return input_text, output_text def lowercase ( self : str ): _UpperCAmelCase = CTRLTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map ) _UpperCAmelCase = "adapt react readapt apt" _UpperCAmelCase = "adapt re@@ a@@ c@@ t re@@ adapt apt".split() _UpperCAmelCase = tokenizer.tokenize(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) _UpperCAmelCase = tokens + [tokenizer.unk_token] _UpperCAmelCase = [0, 1, 2, 4, 5, 1, 0, 3, 6] self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_ ) , snake_case_ )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> str: '''simple docstring''' if isinstance(__lowercase , __lowercase ): raise TypeError("'float' object cannot be interpreted as an integer" ) if isinstance(__lowercase , __lowercase ): raise TypeError("'str' object cannot be interpreted as an integer" ) if num == 0: return "0b0" _UpperCAmelCase = False if num < 0: _UpperCAmelCase = True _UpperCAmelCase = -num _UpperCAmelCase = [] while num > 0: binary.insert(0 , num % 2 ) num >>= 1 if negative: return "-0b" + "".join(str(__lowercase ) for e in binary ) return "0b" + "".join(str(__lowercase ) for e in binary ) if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
1
'''simple docstring''' import numpy as np import qiskit def UpperCAmelCase_ ( __lowercase : int = 8 , __lowercase : int | None = None ) -> str: '''simple docstring''' _UpperCAmelCase = np.random.default_rng(seed=__lowercase ) # Roughly 25% of the qubits will contribute to the key. # So we take more than we need. _UpperCAmelCase = 6 * key_len # Measurement basis for Alice's qubits. _UpperCAmelCase = rng.integers(2 , size=__lowercase ) # The set of states Alice will prepare. _UpperCAmelCase = rng.integers(2 , size=__lowercase ) # Measurement basis for Bob's qubits. _UpperCAmelCase = rng.integers(2 , size=__lowercase ) # Quantum Circuit to simulate BB84 _UpperCAmelCase = qiskit.QuantumCircuit(__lowercase , name="BB84" ) # Alice prepares her qubits according to rules above. for index, _ in enumerate(__lowercase ): if alice_state[index] == 1: bbaa_circ.x(__lowercase ) if alice_basis[index] == 1: bbaa_circ.h(__lowercase ) bbaa_circ.barrier() # Bob measures the received qubits according to rules above. for index, _ in enumerate(__lowercase ): if bob_basis[index] == 1: bbaa_circ.h(__lowercase ) bbaa_circ.barrier() bbaa_circ.measure_all() # Simulate the quantum circuit. _UpperCAmelCase = qiskit.Aer.get_backend("aer_simulator" ) # We only need to run one shot because the key is unique. # Multiple shots will produce the same key. _UpperCAmelCase = qiskit.execute(__lowercase , __lowercase , shots=1 , seed_simulator=__lowercase ) # Returns the result of measurement. _UpperCAmelCase = job.result().get_counts(__lowercase ).most_frequent() # Extracting the generated key from the simulation results. # Only keep measurement results where Alice and Bob chose the same basis. _UpperCAmelCase = "".join( [ result_bit for alice_basis_bit, bob_basis_bit, result_bit in zip( __lowercase , __lowercase , __lowercase ) if alice_basis_bit == bob_basis_bit ] ) # Get final key. Pad with 0 if too short, otherwise truncate. _UpperCAmelCase = gen_key[:key_len] if len(__lowercase ) >= key_len else gen_key.ljust(__lowercase , "0" ) return key if __name__ == "__main__": print(F"The generated key is : {bbaa(8, seed=0)}") from doctest import testmod testmod()
22
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
1
'''simple docstring''' from typing import List, Optional, TypeVar from .arrow_dataset import Dataset, _concatenate_map_style_datasets, _interleave_map_style_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .info import DatasetInfo from .iterable_dataset import IterableDataset, _concatenate_iterable_datasets, _interleave_iterable_datasets from .splits import NamedSplit from .utils import logging from .utils.py_utils import Literal __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Union[str, Any] = TypeVar('''DatasetType''', Dataset, IterableDataset) def UpperCAmelCase_ ( __lowercase : List[DatasetType] , __lowercase : Optional[List[float]] = None , __lowercase : Optional[int] = None , __lowercase : Optional[DatasetInfo] = None , __lowercase : Optional[NamedSplit] = None , __lowercase : Literal["first_exhausted", "all_exhausted"] = "first_exhausted" , ) -> DatasetType: '''simple docstring''' from .arrow_dataset import Dataset from .iterable_dataset import IterableDataset if not datasets: raise ValueError("Unable to interleave an empty list of datasets." ) for i, dataset in enumerate(__lowercase ): if not isinstance(__lowercase , (Dataset, IterableDataset) ): if isinstance(__lowercase , (DatasetDict, IterableDatasetDict) ): if not dataset: raise ValueError( f'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} ' "is an empty dataset dictionary." ) raise ValueError( f'Dataset at position {i} has at least one split: {list(__lowercase )}\n' f'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(__lowercase ) )}\']' ) raise ValueError( f'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(__lowercase ).__name__}.' ) if i == 0: _UpperCAmelCase , _UpperCAmelCase = ( (Dataset, IterableDataset) if isinstance(__lowercase , __lowercase ) else (IterableDataset, Dataset) ) elif not isinstance(__lowercase , __lowercase ): raise ValueError( f'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.' ) if stopping_strategy not in ["first_exhausted", "all_exhausted"]: raise ValueError(f'{stopping_strategy} is not supported. Please enter a valid stopping_strategy.' ) if dataset_type is Dataset: return _interleave_map_style_datasets( __lowercase , __lowercase , __lowercase , info=__lowercase , split=__lowercase , stopping_strategy=__lowercase ) else: return _interleave_iterable_datasets( __lowercase , __lowercase , __lowercase , info=__lowercase , split=__lowercase , stopping_strategy=__lowercase ) def UpperCAmelCase_ ( __lowercase : List[DatasetType] , __lowercase : Optional[DatasetInfo] = None , __lowercase : Optional[NamedSplit] = None , __lowercase : int = 0 , ) -> DatasetType: '''simple docstring''' if not dsets: raise ValueError("Unable to concatenate an empty list of datasets." ) for i, dataset in enumerate(__lowercase ): if not isinstance(__lowercase , (Dataset, IterableDataset) ): if isinstance(__lowercase , (DatasetDict, IterableDatasetDict) ): if not dataset: raise ValueError( f'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} ' "is an empty dataset dictionary." ) raise ValueError( f'Dataset at position {i} has at least one split: {list(__lowercase )}\n' f'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(__lowercase ) )}\']' ) raise ValueError( f'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(__lowercase ).__name__}.' ) if i == 0: _UpperCAmelCase , _UpperCAmelCase = ( (Dataset, IterableDataset) if isinstance(__lowercase , __lowercase ) else (IterableDataset, Dataset) ) elif not isinstance(__lowercase , __lowercase ): raise ValueError( f'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.' ) if dataset_type is Dataset: return _concatenate_map_style_datasets(__lowercase , info=__lowercase , split=__lowercase , axis=__lowercase ) else: return _concatenate_iterable_datasets(__lowercase , info=__lowercase , split=__lowercase , axis=__lowercase )
22
'''simple docstring''' import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class A_ ( unittest.TestCase ): def lowercase ( self : int ): _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = BlipImageProcessor() _UpperCAmelCase = BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-BertModel" ) _UpperCAmelCase = BlipProcessor(snake_case_ , snake_case_ ) processor.save_pretrained(self.tmpdirname ) def lowercase ( self : Tuple , **snake_case_ : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).tokenizer def lowercase ( self : Dict , **snake_case_ : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).image_processor def lowercase ( self : int ): shutil.rmtree(self.tmpdirname ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] _UpperCAmelCase = [Image.fromarray(np.moveaxis(snake_case_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def lowercase ( self : int ): _UpperCAmelCase = BlipProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) _UpperCAmelCase = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) _UpperCAmelCase = self.get_image_processor(do_normalize=snake_case_ , padding_value=1.0 ) _UpperCAmelCase = BlipProcessor.from_pretrained( self.tmpdirname , bos_token="(BOS)" , eos_token="(EOS)" , do_normalize=snake_case_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , snake_case_ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="np" ) _UpperCAmelCase = processor(images=snake_case_ , return_tensors="np" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = processor(text=snake_case_ ) _UpperCAmelCase = tokenizer(snake_case_ , return_token_type_ids=snake_case_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] ) # test if it raises when no input is passed with pytest.raises(snake_case_ ): processor() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(snake_case_ ) _UpperCAmelCase = tokenizer.batch_decode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] )
22
1
'''simple docstring''' import pickle import unittest import torch from accelerate import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils import require_cpu @require_cpu class A_ ( unittest.TestCase ): def lowercase ( self : Tuple ): _UpperCAmelCase = torch.nn.Linear(1_0 , 1_0 ) _UpperCAmelCase = torch.optim.SGD(model.parameters() , 0.1 ) _UpperCAmelCase = Accelerator() _UpperCAmelCase = accelerator.prepare(snake_case_ ) try: pickle.loads(pickle.dumps(snake_case_ ) ) except Exception as e: self.fail(f'Accelerated optimizer pickling failed with {e}' ) AcceleratorState._reset_state()
22
'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def UpperCAmelCase_ ( __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.size _UpperCAmelCase , _UpperCAmelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 _UpperCAmelCase = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) _UpperCAmelCase = np.array(__lowercase ).astype(np.floataa ) / 255.0 _UpperCAmelCase = image[None].transpose(0 , 3 , 1 , 2 ) _UpperCAmelCase = torch.from_numpy(__lowercase ) return 2.0 * image - 1.0 class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , snake_case_ : VQModel , snake_case_ : UNetaDModel , snake_case_ : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ): super().__init__() self.register_modules(vqvae=snake_case_ , unet=snake_case_ , scheduler=snake_case_ ) @torch.no_grad() def __call__( self : Any , snake_case_ : Union[torch.Tensor, PIL.Image.Image] = None , snake_case_ : Optional[int] = 1 , snake_case_ : Optional[int] = 1_0_0 , snake_case_ : Optional[float] = 0.0 , snake_case_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case_ : Optional[str] = "pil" , snake_case_ : bool = True , ): if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = 1 elif isinstance(snake_case_ , torch.Tensor ): _UpperCAmelCase = image.shape[0] else: raise ValueError(f'`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(snake_case_ )}' ) if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = preprocess(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image _UpperCAmelCase = (batch_size, self.unet.config.in_channels // 2, height, width) _UpperCAmelCase = next(self.unet.parameters() ).dtype _UpperCAmelCase = randn_tensor(snake_case_ , generator=snake_case_ , device=self.device , dtype=snake_case_ ) _UpperCAmelCase = image.to(device=self.device , dtype=snake_case_ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(snake_case_ , device=self.device ) _UpperCAmelCase = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler _UpperCAmelCase = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _UpperCAmelCase = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) _UpperCAmelCase = {} if accepts_eta: _UpperCAmelCase = eta for t in self.progress_bar(snake_case_ ): # concat latents and low resolution image in the channel dimension. _UpperCAmelCase = torch.cat([latents, image] , dim=1 ) _UpperCAmelCase = self.scheduler.scale_model_input(snake_case_ , snake_case_ ) # predict the noise residual _UpperCAmelCase = self.unet(snake_case_ , snake_case_ ).sample # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ).prev_sample # decode the image latents with the VQVAE _UpperCAmelCase = self.vqvae.decode(snake_case_ ).sample _UpperCAmelCase = torch.clamp(snake_case_ , -1.0 , 1.0 ) _UpperCAmelCase = image / 2 + 0.5 _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _UpperCAmelCase = self.numpy_to_pil(snake_case_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case_ )
22
1
'''simple docstring''' import warnings from ...utils import logging from .image_processing_deit import DeiTImageProcessor __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) class A_ ( lowerCAmelCase_ ): def __init__( self : Tuple , *snake_case_ : str , **snake_case_ : Union[str, Any] ): warnings.warn( "The class DeiTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please" " use DeiTImageProcessor instead." , snake_case_ , ) super().__init__(*snake_case_ , **snake_case_ )
22
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
1
'''simple docstring''' from sklearn.metrics import mean_squared_error import datasets __SCREAMING_SNAKE_CASE :int = '''\ @article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011} } ''' __SCREAMING_SNAKE_CASE :str = '''\ Mean Squared Error(MSE) is the average of the square of difference between the predicted and actual values. ''' __SCREAMING_SNAKE_CASE :List[Any] = ''' Args: predictions: array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. references: array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. sample_weight: array-like of shape (n_samples,), default=None Sample weights. multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average" Defines aggregating of multiple output values. Array-like value defines weights used to average errors. "raw_values" : Returns a full set of errors in case of multioutput input. "uniform_average" : Errors of all outputs are averaged with uniform weight. squared : bool, default=True If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value. Returns: mse : mean squared error. Examples: >>> mse_metric = datasets.load_metric("mse") >>> predictions = [2.5, 0.0, 2, 8] >>> references = [3, -0.5, 2, 7] >>> results = mse_metric.compute(predictions=predictions, references=references) >>> print(results) {\'mse\': 0.375} >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False) >>> print(rmse_result) {\'mse\': 0.6123724356957945} If you\'re using multi-dimensional lists, then set the config as follows : >>> mse_metric = datasets.load_metric("mse", "multilist") >>> predictions = [[0.5, 1], [-1, 1], [7, -6]] >>> references = [[0, 2], [-1, 2], [8, -5]] >>> results = mse_metric.compute(predictions=predictions, references=references) >>> print(results) {\'mse\': 0.7083333333333334} >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\') >>> print(results) # doctest: +NORMALIZE_WHITESPACE {\'mse\': array([0.41666667, 1. ])} ''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class A_ ( datasets.Metric ): def lowercase ( self : Any ): return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , reference_urls=[ "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html" ] , ) def lowercase ( self : Union[str, Any] ): if self.config_name == "multilist": return { "predictions": datasets.Sequence(datasets.Value("float" ) ), "references": datasets.Sequence(datasets.Value("float" ) ), } else: return { "predictions": datasets.Value("float" ), "references": datasets.Value("float" ), } def lowercase ( self : Dict , snake_case_ : List[Any] , snake_case_ : Any , snake_case_ : Optional[int]=None , snake_case_ : List[str]="uniform_average" , snake_case_ : Dict=True ): _UpperCAmelCase = mean_squared_error( snake_case_ , snake_case_ , sample_weight=snake_case_ , multioutput=snake_case_ , squared=snake_case_ ) return {"mse": mse}
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' import numpy as np import torch import torch.nn as nn from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel from ...utils import logging __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[Any] = CLIPConfig _lowerCamelCase : Optional[Any] = ["""CLIPEncoderLayer"""] def __init__( self : Dict , snake_case_ : CLIPConfig ): super().__init__(snake_case_ ) _UpperCAmelCase = CLIPVisionModelWithProjection(config.vision_config ) _UpperCAmelCase = nn.Linear(config.vision_config.projection_dim , 1 ) _UpperCAmelCase = nn.Linear(config.vision_config.projection_dim , 1 ) @torch.no_grad() def lowercase ( self : List[Any] , snake_case_ : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : Optional[int]=0.5 , snake_case_ : List[str]=0.5 ): _UpperCAmelCase = self.vision_model(snake_case_ )[0] _UpperCAmelCase = self.p_head(snake_case_ ) _UpperCAmelCase = nsfw_detected.flatten() _UpperCAmelCase = nsfw_detected > p_threshold _UpperCAmelCase = nsfw_detected.tolist() if any(snake_case_ ): logger.warning( "Potential NSFW content was detected in one or more images. A black image will be returned instead." " Try again with a different prompt and/or seed." ) for idx, nsfw_detected_ in enumerate(snake_case_ ): if nsfw_detected_: _UpperCAmelCase = np.zeros(images[idx].shape ) _UpperCAmelCase = self.w_head(snake_case_ ) _UpperCAmelCase = watermark_detected.flatten() _UpperCAmelCase = watermark_detected > w_threshold _UpperCAmelCase = watermark_detected.tolist() if any(snake_case_ ): logger.warning( "Potential watermarked content was detected in one or more images. A black image will be returned instead." " Try again with a different prompt and/or seed." ) for idx, watermark_detected_ in enumerate(snake_case_ ): if watermark_detected_: _UpperCAmelCase = np.zeros(images[idx].shape ) return images, nsfw_detected, watermark_detected
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import inspect import unittest from math import floor from transformers import CvtConfig from transformers.file_utils import cached_property, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_vision, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import CvtForImageClassification, CvtModel from transformers.models.cvt.modeling_cvt import CVT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class A_ ( lowerCAmelCase_ ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(snake_case_ , "embed_dim" ) ) self.parent.assertTrue(hasattr(snake_case_ , "num_heads" ) ) class A_ : def __init__( self : Any , snake_case_ : Tuple , snake_case_ : List[Any]=1_3 , snake_case_ : Any=6_4 , snake_case_ : str=3 , snake_case_ : List[str]=[1_6, 4_8, 9_6] , snake_case_ : Union[str, Any]=[1, 3, 6] , snake_case_ : List[Any]=[1, 2, 1_0] , snake_case_ : Union[str, Any]=[7, 3, 3] , snake_case_ : Optional[Any]=[4, 2, 2] , snake_case_ : str=[2, 1, 1] , snake_case_ : List[Any]=[2, 2, 2] , snake_case_ : str=[False, False, True] , snake_case_ : Union[str, Any]=[0.0, 0.0, 0.0] , snake_case_ : List[str]=0.0_2 , snake_case_ : List[Any]=1e-12 , snake_case_ : Any=True , snake_case_ : Tuple=True , snake_case_ : str=2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = patch_sizes _UpperCAmelCase = patch_stride _UpperCAmelCase = patch_padding _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = num_labels _UpperCAmelCase = num_channels _UpperCAmelCase = embed_dim _UpperCAmelCase = num_heads _UpperCAmelCase = stride_kv _UpperCAmelCase = depth _UpperCAmelCase = cls_token _UpperCAmelCase = attention_drop_rate _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps def lowercase ( self : List[str] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def lowercase ( self : Any ): return CvtConfig( image_size=self.image_size , num_labels=self.num_labels , num_channels=self.num_channels , embed_dim=self.embed_dim , num_heads=self.num_heads , patch_sizes=self.patch_sizes , patch_padding=self.patch_padding , patch_stride=self.patch_stride , stride_kv=self.stride_kv , depth=self.depth , cls_token=self.cls_token , attention_drop_rate=self.attention_drop_rate , initializer_range=self.initializer_range , ) def lowercase ( self : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : int , snake_case_ : Tuple ): _UpperCAmelCase = CvtModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ ) _UpperCAmelCase = (self.image_size, self.image_size) _UpperCAmelCase , _UpperCAmelCase = image_size[0], image_size[1] for i in range(len(self.depth ) ): _UpperCAmelCase = floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1 ) _UpperCAmelCase = floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1 ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.embed_dim[-1], height, width) ) def lowercase ( self : List[Any] , snake_case_ : Union[str, Any] , snake_case_ : Any , snake_case_ : int ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = CvtForImageClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def lowercase ( self : Any ): _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = config_and_inputs _UpperCAmelCase = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Any = (CvtModel, CvtForImageClassification) if is_torch_available() else () _lowerCamelCase : str = ( {"""feature-extraction""": CvtModel, """image-classification""": CvtForImageClassification} if is_torch_available() else {} ) _lowerCamelCase : int = False _lowerCamelCase : Dict = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[int] = False _lowerCamelCase : Union[str, Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = CvtModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ , hidden_size=3_7 ) def lowercase ( self : Any ): self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def lowercase ( self : Optional[Any] ): return @unittest.skip(reason="Cvt does not output attentions" ) def lowercase ( self : Tuple ): pass @unittest.skip(reason="Cvt does not use inputs_embeds" ) def lowercase ( self : Optional[Any] ): pass @unittest.skip(reason="Cvt does not support input and output embeddings" ) def lowercase ( self : int ): pass def lowercase ( self : str ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : Optional[int] ): def check_hidden_states_output(snake_case_ : List[str] , snake_case_ : Dict , snake_case_ : int ): _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.hidden_states _UpperCAmelCase = len(self.model_tester.depth ) self.assertEqual(len(snake_case_ ) , snake_case_ ) # verify the first hidden states (first block) self.assertListEqual( list(hidden_states[0].shape[-3:] ) , [ self.model_tester.embed_dim[0], self.model_tester.image_size // 4, self.model_tester.image_size // 4, ] , ) _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = True check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _UpperCAmelCase = True check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ ) def lowercase ( self : Dict ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case_ ) @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Dict ): pass @slow def lowercase ( self : Optional[int] ): for model_name in CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = CvtModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_torch @require_vision class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Any ): return AutoImageProcessor.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) @slow def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = CvtForImageClassification.from_pretrained(CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=snake_case_ , return_tensors="pt" ).to(snake_case_ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # verify the logits _UpperCAmelCase = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([0.9_2_8_5, 0.9_0_1_5, -0.3_1_5_0] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case_ , atol=1e-4 ) )
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' from torch import nn def UpperCAmelCase_ ( __lowercase : Optional[int] ) -> int: '''simple docstring''' if act_fn in ["swish", "silu"]: return nn.SiLU() elif act_fn == "mish": return nn.Mish() elif act_fn == "gelu": return nn.GELU() else: raise ValueError(f'Unsupported activation function: {act_fn}' )
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' import pytest from datasets import inspect_metric, list_metrics, load_metric @pytest.fixture def UpperCAmelCase_ ( __lowercase : List[str] ) -> List[str]: '''simple docstring''' monkeypatch.setattr("datasets.utils.deprecation_utils._emitted_deprecation_warnings" , set() ) @pytest.fixture def UpperCAmelCase_ ( __lowercase : Optional[Any] ) -> Any: '''simple docstring''' class A_ : def __init__( self : Optional[int] , snake_case_ : str ): _UpperCAmelCase = metric_id class A_ : _lowerCamelCase : Any = [MetricMock(lowerCAmelCase_ ) for metric_id in ["""accuracy""", """mse""", """precision""", """codeparrot/apps_metric"""]] def lowercase ( self : Tuple ): return self._metrics monkeypatch.setattr("datasets.inspect.huggingface_hub" , HfhMock() ) @pytest.mark.parametrize( "func, args" , [(load_metric, ("metrics/mse",)), (list_metrics, ()), (inspect_metric, ("metrics/mse", "tmp_path"))] ) def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : Dict , __lowercase : Optional[int] , __lowercase : List[Any] , __lowercase : List[str] ) -> int: '''simple docstring''' if "tmp_path" in args: _UpperCAmelCase = tuple(arg if arg != "tmp_path" else tmp_path for arg in args ) with pytest.warns(__lowercase , match="https://huggingface.co/docs/evaluate" ): func(*__lowercase )
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import argparse import hashlib # hashlib is only used inside the Test class import struct class A_ : def __init__( self : int , snake_case_ : str ): _UpperCAmelCase = data _UpperCAmelCase = [0X67_45_23_01, 0Xef_cd_ab_89, 0X98_ba_dc_fe, 0X10_32_54_76, 0Xc3_d2_e1_f0] @staticmethod def lowercase ( snake_case_ : List[str] , snake_case_ : Optional[Any] ): return ((n << b) | (n >> (3_2 - b))) & 0Xff_ff_ff_ff def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = b"\x80" + b"\x00" * (6_3 - (len(self.data ) + 8) % 6_4) _UpperCAmelCase = self.data + padding + struct.pack(">Q" , 8 * len(self.data ) ) return padded_data def lowercase ( self : Optional[int] ): return [ self.padded_data[i : i + 6_4] for i in range(0 , len(self.padded_data ) , 6_4 ) ] def lowercase ( self : Tuple , snake_case_ : List[str] ): _UpperCAmelCase = list(struct.unpack(">16L" , snake_case_ ) ) + [0] * 6_4 for i in range(1_6 , 8_0 ): _UpperCAmelCase = self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 1_4] ^ w[i - 1_6]) , 1 ) return w def lowercase ( self : List[Any] ): _UpperCAmelCase = self.padding() _UpperCAmelCase = self.split_blocks() for block in self.blocks: _UpperCAmelCase = self.expand_block(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.h for i in range(0 , 8_0 ): if 0 <= i < 2_0: _UpperCAmelCase = (b & c) | ((~b) & d) _UpperCAmelCase = 0X5a_82_79_99 elif 2_0 <= i < 4_0: _UpperCAmelCase = b ^ c ^ d _UpperCAmelCase = 0X6e_d9_eb_a1 elif 4_0 <= i < 6_0: _UpperCAmelCase = (b & c) | (b & d) | (c & d) _UpperCAmelCase = 0X8f_1b_bc_dc elif 6_0 <= i < 8_0: _UpperCAmelCase = b ^ c ^ d _UpperCAmelCase = 0Xca_62_c1_d6 _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = ( self.rotate(snake_case_ , 5 ) + f + e + k + expanded_block[i] & 0Xff_ff_ff_ff, a, self.rotate(snake_case_ , 3_0 ), c, d, ) _UpperCAmelCase = ( self.h[0] + a & 0Xff_ff_ff_ff, self.h[1] + b & 0Xff_ff_ff_ff, self.h[2] + c & 0Xff_ff_ff_ff, self.h[3] + d & 0Xff_ff_ff_ff, self.h[4] + e & 0Xff_ff_ff_ff, ) return ("{:08x}" * 5).format(*self.h ) def UpperCAmelCase_ ( ) -> Tuple: '''simple docstring''' _UpperCAmelCase = b"Test String" assert SHAaHash(__lowercase ).final_hash() == hashlib.shaa(__lowercase ).hexdigest() # noqa: S324 def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = argparse.ArgumentParser(description="Process some strings or files" ) parser.add_argument( "--string" , dest="input_string" , default="Hello World!! Welcome to Cryptography" , help="Hash the string" , ) parser.add_argument("--file" , dest="input_file" , help="Hash contents of a file" ) _UpperCAmelCase = parser.parse_args() _UpperCAmelCase = args.input_string # In any case hash input should be a bytestring if args.input_file: with open(args.input_file , "rb" ) as f: _UpperCAmelCase = f.read() else: _UpperCAmelCase = bytes(__lowercase , "utf-8" ) print(SHAaHash(__lowercase ).final_hash() ) if __name__ == "__main__": main() import doctest doctest.testmod()
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' import argparse import re from flax.traverse_util import flatten_dict, unflatten_dict from tax import checkpoints from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model from transformers.utils import logging logging.set_verbosity_info() # should not include what is already done by the `from_pt` argument __SCREAMING_SNAKE_CASE :Any = { '''/attention/''': '''/0/SelfAttention/''', '''/self_attention/''': '''/0/SelfAttention/''', '''/encoder_decoder_attention/''': '''/1/EncDecAttention/''', '''value''': '''v''', '''query''': '''q''', '''key''': '''k''', '''out''': '''o''', '''pre_self_attention_layer_norm''': '''0/layer_norm''', '''pre_cross_attention_layer_norm''': '''1/layer_norm''', '''pre_attention_layer_norm''': '''0/layer_norm''', # previously 1, but seems wrong '''token_embedder''': '''shared''', '''encoder_norm''': '''final_layer_norm''', '''decoder_norm''': '''final_layer_norm''', '''relpos_bias/rel_embedding''': '''block/0/layer/0/SelfAttention/relative_attention_bias/weight''', '''router/router_weights/w/''': '''router/classifier/''', '''roer/roer_weights/w/''': '''router/classifier/''', '''logits_dense''': '''lm_head''', } def UpperCAmelCase_ ( __lowercase : Dict ) -> Tuple: '''simple docstring''' _UpperCAmelCase = list(s_dict.keys() ) for key in keys: _UpperCAmelCase = r".*/layers_(\d+)" _UpperCAmelCase = key if re.match(__lowercase , __lowercase ): _UpperCAmelCase = re.sub(r"layers_(\d+)" , r"block/\1/layer" , __lowercase ) _UpperCAmelCase = r"(encoder|decoder)\/" if re.match(__lowercase , __lowercase ): _UpperCAmelCase = re.match(__lowercase , __lowercase ).groups() if groups[0] == "encoder": _UpperCAmelCase = re.sub(r"/mlp/" , r"/1/mlp/" , __lowercase ) _UpperCAmelCase = re.sub(r"/pre_mlp_layer_norm/" , r"/1/layer_norm/" , __lowercase ) elif groups[0] == "decoder": _UpperCAmelCase = re.sub(r"/mlp/" , r"/2/mlp/" , __lowercase ) _UpperCAmelCase = re.sub(r"/pre_mlp_layer_norm/" , r"/2/layer_norm/" , __lowercase ) # 2. Convert other classic mappings for old_key, temp_key in MOE_LAYER_NAME_MAPPING.items(): if old_key in new_key: _UpperCAmelCase = new_key.replace(__lowercase , __lowercase ) print(f'{key} -> {new_key}' ) _UpperCAmelCase = s_dict.pop(__lowercase ) if "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict: _UpperCAmelCase = s_dict[ "encoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" ].T if "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" in s_dict: _UpperCAmelCase = s_dict[ "decoder/block/0/layer/0/SelfAttention/relative_attention_bias/weight" ].T # 3. Take extra care of the EXPERTS layer for key in list(s_dict.keys() ): if "expert" in key: _UpperCAmelCase = s_dict[key].shape[0] _UpperCAmelCase = s_dict[key] for idx in range(__lowercase ): _UpperCAmelCase = expert_weihts[idx] print(f'{key} -> {key.replace("expert/" , "nested fstring" )}' ) s_dict.pop(__lowercase ) return s_dict __SCREAMING_SNAKE_CASE :Any = { '''NUM_ENCODER_LAYERS''': '''num_layers''', '''NUM_DECODER_LAYERS''': '''num_decoder_layers''', '''NUM_HEADS''': '''num_heads''', '''HEAD_DIM''': '''d_kv''', '''EMBED_DIM''': '''d_model''', '''MLP_DIM''': '''d_ff''', '''NUM_SELECTED_EXPERTS''': '''num_selected_experts''', '''NUM_ENCODER_SPARSE_LAYERS''': '''num_sparse_encoder_layers''', '''NUM_DECODER_SPARSE_LAYERS''': '''num_sparse_decoder_layers''', '''dense.MlpBlock.activations''': '''feed_forward_proj''', } def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : List[str] ) -> Dict: '''simple docstring''' import regex as re with open(__lowercase , "r" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = re.findall(r"(.*) = ([0-9.]*)" , __lowercase ) _UpperCAmelCase = {} for param, value in regex_match: if param in GIN_TO_CONFIG_MAPPING and value != "": _UpperCAmelCase = float(__lowercase ) if "." in value else int(__lowercase ) _UpperCAmelCase = re.findall(r"(.*activations) = \(\'(.*)\',\)" , __lowercase )[0] _UpperCAmelCase = str(activation[1] ) _UpperCAmelCase = num_experts _UpperCAmelCase = SwitchTransformersConfig(**__lowercase ) return config def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : List[str] , __lowercase : str=None , __lowercase : List[str]="./" , __lowercase : Optional[int]=8 ) -> Optional[int]: '''simple docstring''' print(f'Loading flax weights from : {flax_checkpoint_path}' ) _UpperCAmelCase = checkpoints.load_tax_checkpoint(__lowercase ) if gin_file is not None: _UpperCAmelCase = convert_gin_to_config(__lowercase , __lowercase ) else: _UpperCAmelCase = SwitchTransformersConfig.from_pretrained(__lowercase ) _UpperCAmelCase = SwitchTransformersForConditionalGeneration(__lowercase ) _UpperCAmelCase = flax_params["target"] _UpperCAmelCase = flatten_dict(__lowercase , sep="/" ) _UpperCAmelCase = rename_keys(__lowercase ) _UpperCAmelCase = unflatten_dict(__lowercase , sep="/" ) # Load the flax params in the PT model load_flax_weights_in_pytorch_model(__lowercase , __lowercase ) print(f'Save PyTorch model to {pytorch_dump_path}' ) pt_model.save_pretrained(__lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--switch_t5x_checkpoint_path''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained SwitchTransformers model. \nThis specifies the''' ''' model architecture. If not provided, a `gin_file` has to be provided.''' ), ) parser.add_argument( '''--gin_file''', default=None, type=str, required=False, help='''Path to the gin config file. If not provided, a `config_file` has to be passed ''', ) parser.add_argument( '''--config_name''', default=None, type=str, required=False, help='''Config name of SwitchTransformers model.''' ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output pytorch model.''' ) parser.add_argument('''--num_experts''', default=8, type=int, required=False, help='''Number of experts''') __SCREAMING_SNAKE_CASE :Tuple = parser.parse_args() convert_flax_checkpoint_to_pytorch( args.switch_tax_checkpoint_path, args.config_name, args.gin_file, args.pytorch_dump_folder_path, args.num_experts, )
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' from ..utils import DummyObject, requires_backends class A_ ( metaclass=lowerCAmelCase_ ): _lowerCamelCase : Optional[Any] = ["""note_seq"""] def __init__( self : List[str] , *snake_case_ : Any , **snake_case_ : Union[str, Any] ): requires_backends(self , ["note_seq"] ) @classmethod def lowercase ( cls : int , *snake_case_ : str , **snake_case_ : Optional[Any] ): requires_backends(cls , ["note_seq"] ) @classmethod def lowercase ( cls : List[Any] , *snake_case_ : int , **snake_case_ : Dict ): requires_backends(cls , ["note_seq"] )
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__lowercase ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : float ) -> float: '''simple docstring''' if edge <= 0 or not isinstance(__lowercase , __lowercase ): raise ValueError("Length must be a positive." ) return 3 * ((25 + 10 * (5 ** (1 / 2))) ** (1 / 2)) * (edge**2) def UpperCAmelCase_ ( __lowercase : float ) -> float: '''simple docstring''' if edge <= 0 or not isinstance(__lowercase , __lowercase ): raise ValueError("Length must be a positive." ) return ((15 + (7 * (5 ** (1 / 2)))) / 4) * (edge**3) if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available __SCREAMING_SNAKE_CASE :Dict = {'''configuration_yolos''': ['''YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''YolosConfig''', '''YolosOnnxConfig''']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Optional[Any] = ['''YolosFeatureExtractor'''] __SCREAMING_SNAKE_CASE :List[str] = ['''YolosImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :int = [ '''YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST''', '''YolosForObjectDetection''', '''YolosModel''', '''YolosPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Tuple = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' 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: __SCREAMING_SNAKE_CASE :List[Any] = None __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''', }, } __SCREAMING_SNAKE_CASE :Optional[Any] = { '''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, } __SCREAMING_SNAKE_CASE :Optional[int] = '''▁''' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = VOCAB_FILES_NAMES _lowerCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : int = AlbertTokenizer def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=True , snake_case_ : str=True , snake_case_ : Tuple=False , snake_case_ : List[Any]="[CLS]" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : str="<unk>" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : List[Any]="<pad>" , snake_case_ : List[str]="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. _UpperCAmelCase = ( AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ , normalized=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token ) super().__init__( snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
1
'''simple docstring''' from ...processing_utils import ProcessorMixin class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Union[str, Any] = ["""image_processor""", """feature_extractor"""] _lowerCamelCase : Tuple = """TvltImageProcessor""" _lowerCamelCase : Optional[int] = """TvltFeatureExtractor""" def __init__( self : List[Any] , snake_case_ : str , snake_case_ : List[str] ): super().__init__(image_processor=snake_case_ , feature_extractor=snake_case_ ) _UpperCAmelCase = image_processor _UpperCAmelCase = feature_extractor def __call__( self : str , snake_case_ : Dict=None , snake_case_ : List[Any]=None , snake_case_ : List[str]=None , snake_case_ : Any=None , snake_case_ : int=False , snake_case_ : List[str]=False , *snake_case_ : str , **snake_case_ : Tuple , ): if images is None and audio is None: raise ValueError("You need to specify either an `images` or `audio` input to process." ) _UpperCAmelCase = None if images is not None: _UpperCAmelCase = self.image_processor(snake_case_ , mask_pixel=snake_case_ , *snake_case_ , **snake_case_ ) if images_mixed is not None: _UpperCAmelCase = self.image_processor(snake_case_ , is_mixed=snake_case_ , *snake_case_ , **snake_case_ ) if audio is not None: _UpperCAmelCase = self.feature_extractor( snake_case_ , *snake_case_ , sampling_rate=snake_case_ , mask_audio=snake_case_ , **snake_case_ ) _UpperCAmelCase = {} if audio is not None: output_dict.update(snake_case_ ) if images is not None: output_dict.update(snake_case_ ) if images_mixed_dict is not None: output_dict.update(snake_case_ ) return output_dict @property def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.image_processor.model_input_names _UpperCAmelCase = self.feature_extractor.model_input_names return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names ) )
22
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
1
'''simple docstring''' import os from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils import AddedToken from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_xlnet import XLNetTokenizer else: __SCREAMING_SNAKE_CASE :Any = None __SCREAMING_SNAKE_CASE :Tuple = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Dict = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :Optional[Any] = { '''vocab_file''': { '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''', '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''', }, '''tokenizer_file''': { '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/tokenizer.json''', '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/tokenizer.json''', }, } __SCREAMING_SNAKE_CASE :str = { '''xlnet-base-cased''': None, '''xlnet-large-cased''': None, } __SCREAMING_SNAKE_CASE :str = '''▁''' # Segments (not really needed) __SCREAMING_SNAKE_CASE :Union[str, Any] = 0 __SCREAMING_SNAKE_CASE :List[str] = 1 __SCREAMING_SNAKE_CASE :Tuple = 2 __SCREAMING_SNAKE_CASE :Any = 3 __SCREAMING_SNAKE_CASE :Union[str, Any] = 4 class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Union[str, Any] = VOCAB_FILES_NAMES _lowerCamelCase : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : Optional[Any] = """left""" _lowerCamelCase : Any = XLNetTokenizer def __init__( self : List[str] , snake_case_ : Union[str, Any]=None , snake_case_ : str=None , snake_case_ : Optional[Any]=False , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str="<s>" , snake_case_ : Any="</s>" , snake_case_ : int="<unk>" , snake_case_ : str="<sep>" , snake_case_ : Tuple="<pad>" , snake_case_ : Any="<cls>" , snake_case_ : Union[str, Any]="<mask>" , snake_case_ : int=["<eop>", "<eod>"] , **snake_case_ : List[Any] , ): # Mask token behave like a normal word, i.e. include the space before it _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token super().__init__( vocab_file=snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , additional_special_tokens=snake_case_ , **snake_case_ , ) _UpperCAmelCase = 3 _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Optional[int] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return token_ids_a + sep + cls return token_ids_a + sep + token_ids_a + sep + cls def lowercase ( self : Tuple , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [2] if token_ids_a is None: return len(token_ids_a + sep ) * [0] + cls_segment_id return len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] + cls_segment_id def lowercase ( self : str , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
'''simple docstring''' import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef __SCREAMING_SNAKE_CASE :List[str] = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : Tuple ) -> int: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase_ ( __lowercase : int , __lowercase : str ) -> Optional[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = simple_accuracy(__lowercase , __lowercase ) _UpperCAmelCase = fa_score(y_true=__lowercase , y_pred=__lowercase ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : List[str] ) -> List[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = pearsonr(__lowercase , __lowercase )[0] _UpperCAmelCase = spearmanr(__lowercase , __lowercase )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) assert len(__lowercase ) == len(__lowercase ), f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' if task_name == "cola": return {"mcc": matthews_corrcoef(__lowercase , __lowercase )} elif task_name == "sst-2": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mrpc": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "sts-b": return pearson_and_spearman(__lowercase , __lowercase ) elif task_name == "qqp": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "qnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "rte": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "wnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "hans": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : Dict , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) if len(__lowercase ) != len(__lowercase ): raise ValueError(f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' ) if task_name == "xnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase )
22
1
'''simple docstring''' 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 __SCREAMING_SNAKE_CASE :List[str] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''' ), }, } __SCREAMING_SNAKE_CASE :str = { '''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_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = ( list(range(ord("!" ) , ord("~" ) + 1 ) ) + list(range(ord("¡" ) , ord("¬" ) + 1 ) ) + list(range(ord("®" ) , ord("ÿ" ) + 1 ) ) ) _UpperCAmelCase = bs[:] _UpperCAmelCase = 0 for b in range(2**8 ): if b not in bs: bs.append(__lowercase ) cs.append(2**8 + n ) n += 1 _UpperCAmelCase = [chr(__lowercase ) for n in cs] return dict(zip(__lowercase , __lowercase ) ) def UpperCAmelCase_ ( __lowercase : List[Any] ) -> Any: '''simple docstring''' _UpperCAmelCase = set() _UpperCAmelCase = word[0] for char in word[1:]: pairs.add((prev_char, char) ) _UpperCAmelCase = char return pairs class A_ ( lowerCAmelCase_ ): _lowerCamelCase : List[Any] = VOCAB_FILES_NAMES _lowerCamelCase : int = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Dict = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : List[Any] = ["""input_ids""", """attention_mask"""] def __init__( self : str , snake_case_ : Tuple , snake_case_ : List[Any] , snake_case_ : Any="replace" , snake_case_ : Any="<s>" , snake_case_ : Any="</s>" , snake_case_ : Optional[Any]="</s>" , snake_case_ : Any="<s>" , snake_case_ : Any="<unk>" , snake_case_ : Dict="<pad>" , snake_case_ : Any="<mask>" , snake_case_ : List[Any]=False , **snake_case_ : Optional[int] , ): _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else bos_token _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else eos_token _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else sep_token _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else cls_token _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else unk_token _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else pad_token # Mask token behave like a normal word, i.e. include the space before it _UpperCAmelCase = AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token super().__init__( errors=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , cls_token=snake_case_ , pad_token=snake_case_ , mask_token=snake_case_ , add_prefix_space=snake_case_ , **snake_case_ , ) with open(snake_case_ , encoding="utf-8" ) as vocab_handle: _UpperCAmelCase = json.load(snake_case_ ) _UpperCAmelCase = {v: k for k, v in self.encoder.items()} _UpperCAmelCase = errors # how to handle errors in decoding _UpperCAmelCase = bytes_to_unicode() _UpperCAmelCase = {v: k for k, v in self.byte_encoder.items()} with open(snake_case_ , encoding="utf-8" ) as merges_handle: _UpperCAmelCase = merges_handle.read().split("\n" )[1:-1] _UpperCAmelCase = [tuple(merge.split() ) for merge in bpe_merges] _UpperCAmelCase = dict(zip(snake_case_ , range(len(snake_case_ ) ) ) ) _UpperCAmelCase = {} _UpperCAmelCase = add_prefix_space # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions _UpperCAmelCase = re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" ) @property def lowercase ( self : Optional[int] ): return len(self.encoder ) def lowercase ( self : Dict ): return dict(self.encoder , **self.added_tokens_encoder ) def lowercase ( self : Optional[int] , snake_case_ : Dict ): if token in self.cache: return self.cache[token] _UpperCAmelCase = tuple(snake_case_ ) _UpperCAmelCase = get_pairs(snake_case_ ) if not pairs: return token while True: _UpperCAmelCase = min(snake_case_ , key=lambda snake_case_ : self.bpe_ranks.get(snake_case_ , float("inf" ) ) ) if bigram not in self.bpe_ranks: break _UpperCAmelCase , _UpperCAmelCase = bigram _UpperCAmelCase = [] _UpperCAmelCase = 0 while i < len(snake_case_ ): try: _UpperCAmelCase = word.index(snake_case_ , snake_case_ ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) _UpperCAmelCase = j if word[i] == first and i < len(snake_case_ ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 _UpperCAmelCase = tuple(snake_case_ ) _UpperCAmelCase = new_word if len(snake_case_ ) == 1: break else: _UpperCAmelCase = get_pairs(snake_case_ ) _UpperCAmelCase = " ".join(snake_case_ ) _UpperCAmelCase = word return word def lowercase ( self : List[str] , snake_case_ : Dict ): _UpperCAmelCase = [] for token in re.findall(self.pat , snake_case_ ): _UpperCAmelCase = "".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(snake_case_ ).split(" " ) ) return bpe_tokens def lowercase ( self : List[str] , snake_case_ : List[str] ): return self.encoder.get(snake_case_ , self.encoder.get(self.unk_token ) ) def lowercase ( self : Union[str, Any] , snake_case_ : Union[str, Any] ): return self.decoder.get(snake_case_ ) def lowercase ( self : Optional[Any] , snake_case_ : List[str] ): _UpperCAmelCase = "".join(snake_case_ ) _UpperCAmelCase = bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8" , errors=self.errors ) return text def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[str] = None ): if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] ) with open(snake_case_ , "w" , encoding="utf-8" ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=snake_case_ , ensure_ascii=snake_case_ ) + "\n" ) _UpperCAmelCase = 0 with open(snake_case_ , "w" , encoding="utf-8" ) as writer: writer.write("#version: 0.2\n" ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda snake_case_ : kv[1] ): if index != token_index: logger.warning( f'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.' " Please check that the tokenizer is not corrupted!" ) _UpperCAmelCase = token_index writer.write(" ".join(snake_case_ ) + "\n" ) index += 1 return vocab_file, merge_file def lowercase ( self : str , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] _UpperCAmelCase = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None , snake_case_ : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=snake_case_ , token_ids_a=snake_case_ , already_has_special_tokens=snake_case_ ) if token_ids_a is None: return [1] + ([0] * len(snake_case_ )) + [1] return [1] + ([0] * len(snake_case_ )) + [1, 1] + ([0] * len(snake_case_ )) + [1] def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def lowercase ( self : Any , snake_case_ : str , snake_case_ : int=False , **snake_case_ : Any ): _UpperCAmelCase = kwargs.pop("add_prefix_space" , self.add_prefix_space ) if (is_split_into_words or add_prefix_space) and (len(snake_case_ ) > 0 and not text[0].isspace()): _UpperCAmelCase = " " + text return (text, kwargs)
22
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
1
'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :List[Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Any = { '''facebook/timesformer''': '''https://huggingface.co/facebook/timesformer/resolve/main/config.json''', } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[Any] = """timesformer""" def __init__( self : Optional[Any] , snake_case_ : Optional[int]=2_2_4 , snake_case_ : Tuple=1_6 , snake_case_ : Optional[int]=3 , snake_case_ : Dict=8 , snake_case_ : Union[str, Any]=7_6_8 , snake_case_ : int=1_2 , snake_case_ : List[Any]=1_2 , snake_case_ : Tuple=3_0_7_2 , snake_case_ : List[str]="gelu" , snake_case_ : Union[str, Any]=0.0 , snake_case_ : Dict=0.0 , snake_case_ : Optional[int]=0.0_2 , snake_case_ : int=1e-6 , snake_case_ : List[str]=True , snake_case_ : List[Any]="divided_space_time" , snake_case_ : Optional[int]=0 , **snake_case_ : Union[str, Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = image_size _UpperCAmelCase = patch_size _UpperCAmelCase = num_channels _UpperCAmelCase = num_frames _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = qkv_bias _UpperCAmelCase = attention_type _UpperCAmelCase = drop_path_rate
22
'''simple docstring''' import os from datetime import datetime as dt from github import Github __SCREAMING_SNAKE_CASE :str = [ '''good first issue''', '''feature request''', '''wip''', ] def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = Github(os.environ["GITHUB_TOKEN"] ) _UpperCAmelCase = g.get_repo("huggingface/accelerate" ) _UpperCAmelCase = repo.get_issues(state="open" ) for issue in open_issues: _UpperCAmelCase = sorted([comment for comment in issue.get_comments()] , key=lambda __lowercase : i.created_at , reverse=__lowercase ) _UpperCAmelCase = comments[0] if len(__lowercase ) > 0 else None _UpperCAmelCase = dt.utcnow() _UpperCAmelCase = (current_time - issue.updated_at).days _UpperCAmelCase = (current_time - issue.created_at).days if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and days_since_updated > 7 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Close issue since it has been 7 days of inactivity since bot mention. issue.edit(state="closed" ) elif ( days_since_updated > 23 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Add stale comment issue.create_comment( "This issue has been automatically marked as stale because it has not had " "recent activity. If you think this still needs to be addressed " "please comment on this thread.\n\nPlease note that issues that do not follow the " "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) " "are likely to be ignored." ) if __name__ == "__main__": main()
22
1
'''simple docstring''' import math from typing import Any, Callable, List, Optional, Tuple, Union import numpy as np import torch from ...models import TaFilmDecoder from ...schedulers import DDPMScheduler from ...utils import is_onnx_available, logging, randn_tensor if is_onnx_available(): from ..onnx_utils import OnnxRuntimeModel from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline from .continous_encoder import SpectrogramContEncoder from .notes_encoder import SpectrogramNotesEncoder __SCREAMING_SNAKE_CASE :Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name __SCREAMING_SNAKE_CASE :Optional[Any] = 256 class A_ ( lowerCAmelCase_ ): _lowerCamelCase : str = ["""melgan"""] def __init__( self : Any , snake_case_ : SpectrogramNotesEncoder , snake_case_ : SpectrogramContEncoder , snake_case_ : TaFilmDecoder , snake_case_ : DDPMScheduler , snake_case_ : OnnxRuntimeModel if is_onnx_available() else Any , ): super().__init__() # From MELGAN _UpperCAmelCase = math.log(1e-5 ) # Matches MelGAN training. _UpperCAmelCase = 4.0 # Largest value for most examples _UpperCAmelCase = 1_2_8 self.register_modules( notes_encoder=snake_case_ , continuous_encoder=snake_case_ , decoder=snake_case_ , scheduler=snake_case_ , melgan=snake_case_ , ) def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int=(-1.0, 1.0) , snake_case_ : List[Any]=False ): _UpperCAmelCase , _UpperCAmelCase = output_range if clip: _UpperCAmelCase = torch.clip(snake_case_ , self.min_value , self.max_value ) # Scale to [0, 1]. _UpperCAmelCase = (features - self.min_value) / (self.max_value - self.min_value) # Scale to [min_out, max_out]. return zero_one * (max_out - min_out) + min_out def lowercase ( self : List[Any] , snake_case_ : Dict , snake_case_ : Optional[Any]=(-1.0, 1.0) , snake_case_ : Optional[Any]=False ): _UpperCAmelCase , _UpperCAmelCase = input_range _UpperCAmelCase = torch.clip(snake_case_ , snake_case_ , snake_case_ ) if clip else outputs # Scale to [0, 1]. _UpperCAmelCase = (outputs - min_out) / (max_out - min_out) # Scale to [self.min_value, self.max_value]. return zero_one * (self.max_value - self.min_value) + self.min_value def lowercase ( self : Dict , snake_case_ : Any , snake_case_ : Union[str, Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = input_tokens > 0 _UpperCAmelCase , _UpperCAmelCase = self.notes_encoder( encoder_input_tokens=snake_case_ , encoder_inputs_mask=snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = self.continuous_encoder( encoder_inputs=snake_case_ , encoder_inputs_mask=snake_case_ ) return [(tokens_encoded, tokens_mask), (continuous_encoded, continuous_mask)] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Any , snake_case_ : str ): _UpperCAmelCase = noise_time if not torch.is_tensor(snake_case_ ): _UpperCAmelCase = torch.tensor([timesteps] , dtype=torch.long , device=input_tokens.device ) elif torch.is_tensor(snake_case_ ) and len(timesteps.shape ) == 0: _UpperCAmelCase = timesteps[None].to(input_tokens.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML _UpperCAmelCase = timesteps * torch.ones(input_tokens.shape[0] , dtype=timesteps.dtype , device=timesteps.device ) _UpperCAmelCase = self.decoder( encodings_and_masks=snake_case_ , decoder_input_tokens=snake_case_ , decoder_noise_time=snake_case_ ) return logits @torch.no_grad() def __call__( self : List[str] , snake_case_ : List[List[int]] , snake_case_ : Optional[torch.Generator] = None , snake_case_ : int = 1_0_0 , snake_case_ : bool = True , snake_case_ : str = "numpy" , snake_case_ : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , snake_case_ : int = 1 , ): if (callback_steps is None) or ( callback_steps is not None and (not isinstance(snake_case_ , snake_case_ ) or callback_steps <= 0) ): raise ValueError( f'`callback_steps` has to be a positive integer but is {callback_steps} of type' f' {type(snake_case_ )}.' ) _UpperCAmelCase = np.zeros([1, TARGET_FEATURE_LENGTH, self.n_dims] , dtype=np.floataa ) _UpperCAmelCase = np.zeros([1, 0, self.n_dims] , np.floataa ) _UpperCAmelCase = torch.ones((1, TARGET_FEATURE_LENGTH) , dtype=snake_case_ , device=self.device ) for i, encoder_input_tokens in enumerate(snake_case_ ): if i == 0: _UpperCAmelCase = torch.from_numpy(pred_mel[:1].copy() ).to( device=self.device , dtype=self.decoder.dtype ) # The first chunk has no previous context. _UpperCAmelCase = torch.zeros((1, TARGET_FEATURE_LENGTH) , dtype=snake_case_ , device=self.device ) else: # The full song pipeline does not feed in a context feature, so the mask # will be all 0s after the feature converter. Because we know we're # feeding in a full context chunk from the previous prediction, set it # to all 1s. _UpperCAmelCase = ones _UpperCAmelCase = self.scale_features( snake_case_ , output_range=[-1.0, 1.0] , clip=snake_case_ ) _UpperCAmelCase = self.encode( input_tokens=torch.IntTensor([encoder_input_tokens] ).to(device=self.device ) , continuous_inputs=snake_case_ , continuous_mask=snake_case_ , ) # Sample encoder_continuous_inputs shaped gaussian noise to begin loop _UpperCAmelCase = randn_tensor( shape=encoder_continuous_inputs.shape , generator=snake_case_ , device=self.device , dtype=self.decoder.dtype , ) # set step values self.scheduler.set_timesteps(snake_case_ ) # Denoising diffusion loop for j, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): _UpperCAmelCase = self.decode( encodings_and_masks=snake_case_ , input_tokens=snake_case_ , noise_time=t / self.scheduler.config.num_train_timesteps , ) # Compute previous output: x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , generator=snake_case_ ).prev_sample _UpperCAmelCase = self.scale_to_features(snake_case_ , input_range=[-1.0, 1.0] ) _UpperCAmelCase = mel[:1] _UpperCAmelCase = mel.cpu().float().numpy() _UpperCAmelCase = np.concatenate([full_pred_mel, pred_mel[:1]] , axis=1 ) # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(snake_case_ , snake_case_ ) logger.info("Generated segment" , snake_case_ ) if output_type == "numpy" and not is_onnx_available(): raise ValueError( "Cannot return output in 'np' format if ONNX is not available. Make sure to have ONNX installed or set 'output_type' to 'mel'." ) elif output_type == "numpy" and self.melgan is None: raise ValueError( "Cannot return output in 'np' format if melgan component is not defined. Make sure to define `self.melgan` or set 'output_type' to 'mel'." ) if output_type == "numpy": _UpperCAmelCase = self.melgan(input_features=full_pred_mel.astype(np.floataa ) ) else: _UpperCAmelCase = full_pred_mel if not return_dict: return (output,) return AudioPipelineOutput(audios=snake_case_ )
22
'''simple docstring''' import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( "files" , [ ["full:README.md", "dataset_infos.json"], ["empty:README.md", "dataset_infos.json"], ["dataset_infos.json"], ["full:README.md"], ] , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : int ) -> int: '''simple docstring''' _UpperCAmelCase = tmp_path_factory.mktemp("dset_infos_dir" ) if "full:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("---\ndataset_info:\n dataset_size: 42\n---" ) if "empty:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("" ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / "dataset_infos.json" , "w" ) as f: f.write("{\"default\": {\"dataset_size\": 42}}" ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( "dataset_info" , [ DatasetInfo(), DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ), ] , ) def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : DatasetInfo ) -> Any: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_info.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfo.from_directory(__lowercase ) assert dataset_info == reloaded assert os.path.exists(os.path.join(__lowercase , "dataset_info.json" ) ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = DatasetInfo( description="foo" , citation="bar" , homepage="https://foo.bar" , license="CC0" , features=Features({"a": Value("int32" )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train", "num_examples": 42}] , download_checksums={} , download_size=1337 , post_processing_size=442 , dataset_size=1234 , size_in_bytes=1337 + 442 + 1234 , ) _UpperCAmelCase = dataset_info._to_yaml_dict() assert sorted(__lowercase ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _UpperCAmelCase = yaml.safe_dump(__lowercase ) _UpperCAmelCase = yaml.safe_load(__lowercase ) assert dataset_info_yaml_dict == reloaded def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = DatasetInfo() _UpperCAmelCase = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( "dataset_infos_dict" , [ DatasetInfosDict(), DatasetInfosDict({"default": DatasetInfo()} ), DatasetInfosDict({"my_config_name": DatasetInfo()} ), DatasetInfosDict( { "default": DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ) } ), DatasetInfosDict( { "v1": DatasetInfo(dataset_size=42 ), "v2": DatasetInfo(dataset_size=1337 ), } ), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : DatasetInfosDict ) -> Dict: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_infos_dict.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _UpperCAmelCase = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _UpperCAmelCase = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(__lowercase , "README.md" ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : dict ) -> set: '''simple docstring''' _UpperCAmelCase = set() # edges = list of graph's edges _UpperCAmelCase = get_edges(__lowercase ) # While there are still elements in edges list, take an arbitrary edge # (from_node, to_node) and add his extremity to chosen_vertices and then # remove all arcs adjacent to the from_node and to_node while edges: _UpperCAmelCase , _UpperCAmelCase = edges.pop() chosen_vertices.add(__lowercase ) chosen_vertices.add(__lowercase ) for edge in edges.copy(): if from_node in edge or to_node in edge: edges.discard(__lowercase ) return chosen_vertices def UpperCAmelCase_ ( __lowercase : dict ) -> set: '''simple docstring''' _UpperCAmelCase = set() for from_node, to_nodes in graph.items(): for to_node in to_nodes: edges.add((from_node, to_node) ) return edges if __name__ == "__main__": import doctest doctest.testmod() # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]} # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
1
'''simple docstring''' 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 A_ : def __init__( self : List[Any] , snake_case_ : Optional[int] , snake_case_ : Any=2 , snake_case_ : Optional[Any]=8 , snake_case_ : Union[str, Any]=True , snake_case_ : Optional[Any]=True , snake_case_ : Optional[Any]=True , snake_case_ : int=True , snake_case_ : int=9_9 , snake_case_ : Optional[Any]=1_6 , snake_case_ : Union[str, Any]=5 , snake_case_ : Optional[Any]=2 , snake_case_ : List[Any]=3_6 , snake_case_ : str="gelu" , snake_case_ : Optional[int]=0.0 , snake_case_ : Dict=0.0 , snake_case_ : str=5_1_2 , snake_case_ : str=1_6 , snake_case_ : Tuple=2 , snake_case_ : Optional[int]=0.0_2 , snake_case_ : Dict=3 , snake_case_ : Union[str, Any]=4 , snake_case_ : List[Any]=None , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = scope def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_input_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def lowercase ( self : str ): 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=snake_case_ , initializer_range=self.initializer_range , ) def lowercase ( self : List[str] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = 3_0_0 return config def lowercase ( self : Union[str, Any] ): ( ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ) = self.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def lowercase ( self : Optional[int] , snake_case_ : Tuple , snake_case_ : str , snake_case_ : Dict , snake_case_ : Any , snake_case_ : Union[str, Any] , snake_case_ : Optional[Any] , snake_case_ : List[Any] ): _UpperCAmelCase = MraModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ ) _UpperCAmelCase = model(snake_case_ , token_type_ids=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowercase ( self : int , snake_case_ : Optional[Any] , snake_case_ : Any , snake_case_ : Optional[Any] , snake_case_ : List[str] , snake_case_ : str , snake_case_ : Tuple , snake_case_ : Any , snake_case_ : Tuple , snake_case_ : Any , ): _UpperCAmelCase = True _UpperCAmelCase = MraModel(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , encoder_hidden_states=snake_case_ , encoder_attention_mask=snake_case_ , ) _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , encoder_hidden_states=snake_case_ , ) _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowercase ( self : str , snake_case_ : int , snake_case_ : List[str] , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : str , snake_case_ : Union[str, Any] , snake_case_ : List[str] ): _UpperCAmelCase = MraForMaskedLM(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def lowercase ( self : List[Any] , snake_case_ : Any , snake_case_ : Any , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : List[Any] , snake_case_ : Dict ): _UpperCAmelCase = MraForQuestionAnswering(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , start_positions=snake_case_ , end_positions=snake_case_ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def lowercase ( self : Dict , snake_case_ : Dict , snake_case_ : int , snake_case_ : Union[str, Any] , snake_case_ : List[Any] , snake_case_ : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Union[str, Any] ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = MraForSequenceClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def lowercase ( self : Union[str, Any] , snake_case_ : List[Any] , snake_case_ : List[str] , snake_case_ : Optional[Any] , snake_case_ : List[Any] , snake_case_ : Tuple , snake_case_ : Optional[Any] , snake_case_ : List[Any] ): _UpperCAmelCase = self.num_labels _UpperCAmelCase = MraForTokenClassification(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def lowercase ( self : Optional[int] , snake_case_ : Optional[int] , snake_case_ : Tuple , snake_case_ : Tuple , snake_case_ : Optional[Any] , snake_case_ : Tuple , snake_case_ : List[str] , snake_case_ : Optional[int] ): _UpperCAmelCase = self.num_choices _UpperCAmelCase = MraForMultipleChoice(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , token_type_ids=snake_case_ , labels=snake_case_ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask} return config, inputs_dict @require_torch class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = ( ( MraModel, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, ) if is_torch_available() else () ) _lowerCamelCase : List[Any] = False _lowerCamelCase : str = False _lowerCamelCase : List[str] = False _lowerCamelCase : Dict = False _lowerCamelCase : Dict = () def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = MraModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , hidden_size=3_7 ) def lowercase ( self : List[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Dict ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: _UpperCAmelCase = type self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*snake_case_ ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*snake_case_ ) def lowercase ( self : Dict ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = MraModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) @unittest.skip(reason="MRA does not output attentions" ) def lowercase ( self : List[str] ): return @require_torch class A_ ( unittest.TestCase ): @slow def lowercase ( self : Dict ): _UpperCAmelCase = MraModel.from_pretrained("uw-madison/mra-base-512-4" ) _UpperCAmelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): _UpperCAmelCase = model(snake_case_ )[0] _UpperCAmelCase = torch.Size((1, 2_5_6, 7_6_8) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[[-0.0_1_4_0, 0.0_8_3_0, -0.0_3_8_1], [0.1_5_4_6, 0.1_4_0_2, 0.0_2_2_0], [0.1_1_6_2, 0.0_8_5_1, 0.0_1_6_5]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case_ , atol=1e-4 ) ) @slow def lowercase ( self : str ): _UpperCAmelCase = MraForMaskedLM.from_pretrained("uw-madison/mra-base-512-4" ) _UpperCAmelCase = torch.arange(2_5_6 ).unsqueeze(0 ) with torch.no_grad(): _UpperCAmelCase = model(snake_case_ )[0] _UpperCAmelCase = 5_0_2_6_5 _UpperCAmelCase = torch.Size((1, 2_5_6, vocab_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[[9.2_5_9_5, -3.6_0_3_8, 1_1.8_8_1_9], [9.3_8_6_9, -3.2_6_9_3, 1_1.0_9_5_6], [1_1.8_5_2_4, -3.4_9_3_8, 1_3.1_2_1_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case_ , atol=1e-4 ) ) @slow def lowercase ( self : int ): _UpperCAmelCase = MraForMaskedLM.from_pretrained("uw-madison/mra-base-4096-8-d3" ) _UpperCAmelCase = torch.arange(4_0_9_6 ).unsqueeze(0 ) with torch.no_grad(): _UpperCAmelCase = model(snake_case_ )[0] _UpperCAmelCase = 5_0_2_6_5 _UpperCAmelCase = torch.Size((1, 4_0_9_6, vocab_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[[5.4_7_8_9, -2.3_5_6_4, 7.5_0_6_4], [7.9_0_6_7, -1.3_3_6_9, 9.9_6_6_8], [9.0_7_1_2, -1.8_1_0_6, 7.0_3_8_0]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , snake_case_ , atol=1e-4 ) )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : List[str] ) -> Dict: '''simple docstring''' _UpperCAmelCase = len(__lowercase ) while cur > 1: # Find the maximum number in arr _UpperCAmelCase = arr.index(max(arr[0:cur] ) ) # Reverse from 0 to mi _UpperCAmelCase = arr[mi::-1] + arr[mi + 1 : len(__lowercase )] # Reverse whole list _UpperCAmelCase = arr[cur - 1 :: -1] + arr[cur : len(__lowercase )] cur -= 1 return arr if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter numbers separated by a comma:\n''').strip() __SCREAMING_SNAKE_CASE :List[Any] = [int(item) for item in user_input.split(''',''')] print(pancake_sort(unsorted))
22
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
1
'''simple docstring''' import unittest import numpy as np import torch from diffusers import DDIMPipeline, DDIMScheduler, UNetaDModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Tuple = DDIMPipeline _lowerCamelCase : int = UNCONDITIONAL_IMAGE_GENERATION_PARAMS _lowerCamelCase : Optional[Any] = PipelineTesterMixin.required_optional_params - { """num_images_per_prompt""", """latents""", """callback""", """callback_steps""", } _lowerCamelCase : Dict = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS _lowerCamelCase : Any = False def lowercase ( self : List[Any] ): torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=3 , out_channels=3 , down_block_types=("DownBlock2D", "AttnDownBlock2D") , up_block_types=("AttnUpBlock2D", "UpBlock2D") , ) _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = {"unet": unet, "scheduler": scheduler} return components def lowercase ( self : List[str] , snake_case_ : int , snake_case_ : Tuple=0 ): if str(snake_case_ ).startswith("mps" ): _UpperCAmelCase = torch.manual_seed(snake_case_ ) else: _UpperCAmelCase = torch.Generator(device=snake_case_ ).manual_seed(snake_case_ ) _UpperCAmelCase = { "batch_size": 1, "generator": generator, "num_inference_steps": 2, "output_type": "numpy", } return inputs def lowercase ( self : Tuple ): _UpperCAmelCase = "cpu" _UpperCAmelCase = self.get_dummy_components() _UpperCAmelCase = self.pipeline_class(**snake_case_ ) pipe.to(snake_case_ ) pipe.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = self.get_dummy_inputs(snake_case_ ) _UpperCAmelCase = pipe(**snake_case_ ).images _UpperCAmelCase = image[0, -3:, -3:, -1] self.assertEqual(image.shape , (1, 3_2, 3_2, 3) ) _UpperCAmelCase = np.array( [1.000e00, 5.717e-01, 4.717e-01, 1.000e00, 0.000e00, 1.000e00, 3.000e-04, 0.000e00, 9.000e-04] ) _UpperCAmelCase = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(snake_case_ , 1e-3 ) def lowercase ( self : List[Any] ): super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 ) def lowercase ( self : str ): super().test_save_load_local(expected_max_difference=3e-3 ) def lowercase ( self : Dict ): super().test_save_load_optional_components(expected_max_difference=3e-3 ) def lowercase ( self : int ): super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = "google/ddpm-cifar10-32" _UpperCAmelCase = UNetaDModel.from_pretrained(snake_case_ ) _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = DDIMPipeline(unet=snake_case_ , scheduler=snake_case_ ) ddim.to(snake_case_ ) ddim.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ddim(generator=snake_case_ , eta=0.0 , output_type="numpy" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 3_2, 3_2, 3) _UpperCAmelCase = np.array([0.1_7_2_3, 0.1_6_1_7, 0.1_6_0_0, 0.1_6_2_6, 0.1_4_9_7, 0.1_5_1_3, 0.1_5_0_5, 0.1_4_4_2, 0.1_4_5_3] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def lowercase ( self : List[str] ): _UpperCAmelCase = "google/ddpm-ema-bedroom-256" _UpperCAmelCase = UNetaDModel.from_pretrained(snake_case_ ) _UpperCAmelCase = DDIMScheduler.from_pretrained(snake_case_ ) _UpperCAmelCase = DDIMPipeline(unet=snake_case_ , scheduler=snake_case_ ) ddpm.to(snake_case_ ) ddpm.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ddpm(generator=snake_case_ , output_type="numpy" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_5_6, 2_5_6, 3) _UpperCAmelCase = np.array([0.0_0_6_0, 0.0_2_0_1, 0.0_3_4_4, 0.0_0_2_4, 0.0_0_1_8, 0.0_0_0_2, 0.0_0_2_2, 0.0_0_0_0, 0.0_0_6_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
22
'''simple docstring''' import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class A_ ( unittest.TestCase ): def lowercase ( self : int ): _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = BlipImageProcessor() _UpperCAmelCase = BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-BertModel" ) _UpperCAmelCase = BlipProcessor(snake_case_ , snake_case_ ) processor.save_pretrained(self.tmpdirname ) def lowercase ( self : Tuple , **snake_case_ : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).tokenizer def lowercase ( self : Dict , **snake_case_ : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).image_processor def lowercase ( self : int ): shutil.rmtree(self.tmpdirname ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] _UpperCAmelCase = [Image.fromarray(np.moveaxis(snake_case_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def lowercase ( self : int ): _UpperCAmelCase = BlipProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) _UpperCAmelCase = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) _UpperCAmelCase = self.get_image_processor(do_normalize=snake_case_ , padding_value=1.0 ) _UpperCAmelCase = BlipProcessor.from_pretrained( self.tmpdirname , bos_token="(BOS)" , eos_token="(EOS)" , do_normalize=snake_case_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , snake_case_ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="np" ) _UpperCAmelCase = processor(images=snake_case_ , return_tensors="np" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = processor(text=snake_case_ ) _UpperCAmelCase = tokenizer(snake_case_ , return_token_type_ids=snake_case_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] ) # test if it raises when no input is passed with pytest.raises(snake_case_ ): processor() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(snake_case_ ) _UpperCAmelCase = tokenizer.batch_decode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] )
22
1
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def UpperCAmelCase_ ( __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.size _UpperCAmelCase , _UpperCAmelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 _UpperCAmelCase = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) _UpperCAmelCase = np.array(__lowercase ).astype(np.floataa ) / 255.0 _UpperCAmelCase = image[None].transpose(0 , 3 , 1 , 2 ) _UpperCAmelCase = torch.from_numpy(__lowercase ) return 2.0 * image - 1.0 class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , snake_case_ : VQModel , snake_case_ : UNetaDModel , snake_case_ : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ): super().__init__() self.register_modules(vqvae=snake_case_ , unet=snake_case_ , scheduler=snake_case_ ) @torch.no_grad() def __call__( self : Any , snake_case_ : Union[torch.Tensor, PIL.Image.Image] = None , snake_case_ : Optional[int] = 1 , snake_case_ : Optional[int] = 1_0_0 , snake_case_ : Optional[float] = 0.0 , snake_case_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case_ : Optional[str] = "pil" , snake_case_ : bool = True , ): if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = 1 elif isinstance(snake_case_ , torch.Tensor ): _UpperCAmelCase = image.shape[0] else: raise ValueError(f'`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(snake_case_ )}' ) if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = preprocess(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image _UpperCAmelCase = (batch_size, self.unet.config.in_channels // 2, height, width) _UpperCAmelCase = next(self.unet.parameters() ).dtype _UpperCAmelCase = randn_tensor(snake_case_ , generator=snake_case_ , device=self.device , dtype=snake_case_ ) _UpperCAmelCase = image.to(device=self.device , dtype=snake_case_ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(snake_case_ , device=self.device ) _UpperCAmelCase = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler _UpperCAmelCase = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _UpperCAmelCase = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) _UpperCAmelCase = {} if accepts_eta: _UpperCAmelCase = eta for t in self.progress_bar(snake_case_ ): # concat latents and low resolution image in the channel dimension. _UpperCAmelCase = torch.cat([latents, image] , dim=1 ) _UpperCAmelCase = self.scheduler.scale_model_input(snake_case_ , snake_case_ ) # predict the noise residual _UpperCAmelCase = self.unet(snake_case_ , snake_case_ ).sample # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ).prev_sample # decode the image latents with the VQVAE _UpperCAmelCase = self.vqvae.decode(snake_case_ ).sample _UpperCAmelCase = torch.clamp(snake_case_ , -1.0 , 1.0 ) _UpperCAmelCase = image / 2 + 0.5 _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _UpperCAmelCase = self.numpy_to_pil(snake_case_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case_ )
22
1
'''simple docstring''' from __future__ import annotations import requests __SCREAMING_SNAKE_CASE :Tuple = set( '''approved_at_utc approved_by author_flair_background_color author_flair_css_class author_flair_richtext author_flair_template_id author_fullname author_premium can_mod_post category clicked content_categories created_utc downs edited gilded gildings hidden hide_score is_created_from_ads_ui is_meta is_original_content is_reddit_media_domain is_video link_flair_css_class link_flair_richtext link_flair_text link_flair_text_color media_embed mod_reason_title name permalink pwls quarantine saved score secure_media secure_media_embed selftext subreddit subreddit_name_prefixed subreddit_type thumbnail title top_awarded_type total_awards_received ups upvote_ratio url user_reports'''.split() ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : int = 1 , __lowercase : str = "new" , __lowercase : list | None = None ) -> dict: '''simple docstring''' _UpperCAmelCase = wanted_data or [] if invalid_search_terms := ", ".join(sorted(set(__lowercase ) - valid_terms ) ): _UpperCAmelCase = f'Invalid search term: {invalid_search_terms}' raise ValueError(__lowercase ) _UpperCAmelCase = requests.get( f'https://reddit.com/r/{subreddit}/{age}.json?limit={limit}' , headers={"User-agent": "A random string"} , ) if response.status_code == 429: raise requests.HTTPError _UpperCAmelCase = response.json() if not wanted_data: return {id_: data["data"]["children"][id_] for id_ in range(__lowercase )} _UpperCAmelCase = {} for id_ in range(__lowercase ): _UpperCAmelCase = { item: data["data"]["children"][id_]["data"][item] for item in wanted_data } return data_dict if __name__ == "__main__": # If you get Error 429, that means you are rate limited.Try after some time print(get_subreddit_data('''learnpython''', wanted_data=['''title''', '''url''', '''selftext''']))
22
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
1
'''simple docstring''' import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : Union[str, Any] , __lowercase : Tuple , __lowercase : Optional[Any] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase = MobileBertConfig.from_json_file(__lowercase ) print(f'Building PyTorch model from configuration: {config}' ) _UpperCAmelCase = MobileBertForPreTraining(__lowercase ) # Load weights from tf checkpoint _UpperCAmelCase = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase ) # Save pytorch-model print(f'Save PyTorch model to {pytorch_dump_path}' ) torch.save(model.state_dict() , __lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :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( '''--mobilebert_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained MobileBERT 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.''' ) __SCREAMING_SNAKE_CASE :Optional[int] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' import argparse import os 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_task_guides.py __SCREAMING_SNAKE_CASE :Dict = '''src/transformers''' __SCREAMING_SNAKE_CASE :int = '''docs/source/en/tasks''' def UpperCAmelCase_ ( __lowercase : str , __lowercase : Union[str, Any] , __lowercase : int ) -> Optional[int]: '''simple docstring''' with open(__lowercase , "r" , encoding="utf-8" , newline="\n" ) as f: _UpperCAmelCase = f.readlines() # Find the start prompt. _UpperCAmelCase = 0 while not lines[start_index].startswith(__lowercase ): start_index += 1 start_index += 1 _UpperCAmelCase = 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 # This is to make sure the transformers module imported is the one in the repo. __SCREAMING_SNAKE_CASE :List[Any] = direct_transformers_import(TRANSFORMERS_PATH) __SCREAMING_SNAKE_CASE :Tuple = { '''asr.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_CTC_MAPPING_NAMES, '''audio_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES, '''language_modeling.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_CAUSAL_LM_MAPPING_NAMES, '''image_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES, '''masked_language_modeling.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_MASKED_LM_MAPPING_NAMES, '''multiple_choice.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES, '''object_detection.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES, '''question_answering.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES, '''semantic_segmentation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING_NAMES, '''sequence_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES, '''summarization.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES, '''token_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES, '''translation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES, '''video_classification.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES, '''document_question_answering.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES, '''monocular_depth_estimation.md''': transformers_module.models.auto.modeling_auto.MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES, } # This list contains model types used in some task guides that are not in `CONFIG_MAPPING_NAMES` (therefore not in any # `MODEL_MAPPING_NAMES` or any `MODEL_FOR_XXX_MAPPING_NAMES`). __SCREAMING_SNAKE_CASE :Optional[int] = { '''summarization.md''': ('''nllb''',), '''translation.md''': ('''nllb''',), } def UpperCAmelCase_ ( __lowercase : Optional[Any] ) -> int: '''simple docstring''' _UpperCAmelCase = TASK_GUIDE_TO_MODELS[task_guide] _UpperCAmelCase = SPECIAL_TASK_GUIDE_TO_MODEL_TYPES.get(__lowercase , set() ) _UpperCAmelCase = { code: name for code, name in transformers_module.MODEL_NAMES_MAPPING.items() if (code in model_maping_names or code in special_model_types) } return ", ".join([f'[{name}](../model_doc/{code})' for code, name in model_names.items()] ) + "\n" def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : Any=False ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = _find_text_in_file( filename=os.path.join(__lowercase , __lowercase ) , start_prompt="<!--This tip is automatically generated by `make fix-copies`, do not fill manually!-->" , end_prompt="<!--End of the generated tip-->" , ) _UpperCAmelCase = get_model_list_for_task(__lowercase ) if current_list != new_list: if overwrite: with open(os.path.join(__lowercase , __lowercase ) , "w" , encoding="utf-8" , newline="\n" ) as f: f.writelines(lines[:start_index] + [new_list] + lines[end_index:] ) else: raise ValueError( f'The list of models that can be used in the {task_guide} guide needs an update. Run `make fix-copies`' " to fix this." ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :int = argparse.ArgumentParser() parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''') __SCREAMING_SNAKE_CASE :Any = parser.parse_args() for task_guide in TASK_GUIDE_TO_MODELS.keys(): check_model_list_for_task(task_guide, args.fix_and_overwrite)
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : list[list] ) -> list[list]: '''simple docstring''' _UpperCAmelCase = current_set.copy() for row_index, row in enumerate(__lowercase ): _UpperCAmelCase = row[0] for column_index, column in enumerate(__lowercase ): if magnitude == 0: _UpperCAmelCase = column continue _UpperCAmelCase = column / magnitude # Subtract to cancel term _UpperCAmelCase = current_set[0] _UpperCAmelCase = [first_row] _UpperCAmelCase = current_set[1::] for row in current_set: _UpperCAmelCase = [] # If first term is 0, it is already in form we want, so we preserve it if row[0] == 0: final_set.append(__lowercase ) continue for column_index in range(len(__lowercase ) ): temp_row.append(first_row[column_index] - row[column_index] ) final_set.append(__lowercase ) # Create next recursion iteration set if len(final_set[0] ) != 3: _UpperCAmelCase = final_set[0] _UpperCAmelCase = [] _UpperCAmelCase = [] for row in final_set[1::]: current_first_column.append(row[0] ) next_iteration.append(row[1::] ) _UpperCAmelCase = simplify(__lowercase ) for i in range(len(__lowercase ) ): resultant[i].insert(0 , current_first_column[i] ) resultant.insert(0 , __lowercase ) _UpperCAmelCase = resultant return final_set def UpperCAmelCase_ ( __lowercase : list[list] ) -> list: '''simple docstring''' if len(__lowercase ) == 0: raise IndexError("solve_simultaneous() requires n lists of length n+1" ) _UpperCAmelCase = len(__lowercase ) + 1 if any(len(__lowercase ) != _length for item in equations ): raise IndexError("solve_simultaneous() requires n lists of length n+1" ) for row in equations: if any(not isinstance(__lowercase , (int, float) ) for column in row ): raise ValueError("solve_simultaneous() requires lists of integers" ) if len(__lowercase ) == 1: return [equations[0][-1] / equations[0][0]] _UpperCAmelCase = equations.copy() if any(0 in row for row in data_set ): _UpperCAmelCase = data_set.copy() _UpperCAmelCase = [] for row_index, row in enumerate(__lowercase ): if 0 not in row: _UpperCAmelCase = data_set.pop(__lowercase ) break if not full_row: raise ValueError("solve_simultaneous() requires at least 1 full equation" ) data_set.insert(0 , __lowercase ) _UpperCAmelCase = data_set.copy() _UpperCAmelCase = simplify(__lowercase ) _UpperCAmelCase = simplified[::-1] _UpperCAmelCase = [] for row in simplified: _UpperCAmelCase = row[-1] if not solutions: if row[-2] == 0: solutions.append(0 ) continue solutions.append(current_solution / row[-2] ) continue _UpperCAmelCase = row.copy()[: len(__lowercase ) - 1 :] while temp_row[0] == 0: temp_row.pop(0 ) if len(__lowercase ) == 0: solutions.append(0 ) continue _UpperCAmelCase = temp_row[1::] _UpperCAmelCase = temp_row[::-1] for column_index, column in enumerate(__lowercase ): current_solution -= column * solutions[column_index] solutions.append(__lowercase ) _UpperCAmelCase = [] for item in solutions: final.append(float(round(__lowercase , 5 ) ) ) return final[::-1] if __name__ == "__main__": import doctest doctest.testmod() __SCREAMING_SNAKE_CASE :Tuple = [ [2, 1, 1, 1, 1, 4], [1, 2, 1, 1, 1, 5], [1, 1, 2, 1, 1, 6], [1, 1, 1, 2, 1, 7], [1, 1, 1, 1, 2, 8], ] print(solve_simultaneous(eq)) print(solve_simultaneous([[4, 2]]))
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import unittest from parameterized import parameterized from transformers import LlamaConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer class A_ : def __init__( self : Any , snake_case_ : Tuple , snake_case_ : Optional[Any]=1_3 , snake_case_ : Optional[int]=7 , snake_case_ : Optional[Any]=True , snake_case_ : Dict=True , snake_case_ : Dict=False , snake_case_ : List[str]=True , snake_case_ : Any=9_9 , snake_case_ : int=3_2 , snake_case_ : Any=5 , snake_case_ : Any=4 , snake_case_ : Tuple=3_7 , snake_case_ : Any="gelu" , snake_case_ : List[str]=0.1 , snake_case_ : Any=0.1 , snake_case_ : int=5_1_2 , snake_case_ : Dict=1_6 , snake_case_ : int=2 , snake_case_ : str=0.0_2 , snake_case_ : str=3 , snake_case_ : Optional[Any]=4 , snake_case_ : str=None , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = scope def lowercase ( self : str ): _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_input_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def lowercase ( self : Dict ): return LlamaConfig( 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=snake_case_ , initializer_range=self.initializer_range , ) def lowercase ( self : Any , snake_case_ : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : Dict , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : Any ): _UpperCAmelCase = LlamaModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowercase ( self : List[str] , snake_case_ : Dict , snake_case_ : Tuple , snake_case_ : Union[str, Any] , snake_case_ : Optional[Any] , snake_case_ : str , snake_case_ : Optional[Any] , snake_case_ : Optional[int] , snake_case_ : Dict , snake_case_ : Optional[Any] , ): _UpperCAmelCase = True _UpperCAmelCase = LlamaModel(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , encoder_hidden_states=snake_case_ , encoder_attention_mask=snake_case_ , ) _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , encoder_hidden_states=snake_case_ , ) _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowercase ( self : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : Dict , snake_case_ : Optional[int] , snake_case_ : Optional[Any] , snake_case_ : Tuple , snake_case_ : str , snake_case_ : Union[str, Any] , ): _UpperCAmelCase = LlamaForCausalLM(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def lowercase ( self : int , snake_case_ : Dict , snake_case_ : Union[str, Any] , snake_case_ : List[Any] , snake_case_ : Any , snake_case_ : str , snake_case_ : List[Any] , snake_case_ : Union[str, Any] , snake_case_ : Tuple , snake_case_ : str , ): _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = LlamaForCausalLM(config=snake_case_ ) model.to(snake_case_ ) model.eval() # first forward pass _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , encoder_hidden_states=snake_case_ , encoder_attention_mask=snake_case_ , use_cache=snake_case_ , ) _UpperCAmelCase = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 3) , config.vocab_size ) _UpperCAmelCase = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = torch.cat([input_mask, next_mask] , dim=-1 ) _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , encoder_hidden_states=snake_case_ , encoder_attention_mask=snake_case_ , output_hidden_states=snake_case_ , )["hidden_states"][0] _UpperCAmelCase = model( snake_case_ , attention_mask=snake_case_ , encoder_hidden_states=snake_case_ , encoder_attention_mask=snake_case_ , past_key_values=snake_case_ , output_hidden_states=snake_case_ , )["hidden_states"][0] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -3:, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(snake_case_ , snake_case_ , atol=1e-3 ) ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else () _lowerCamelCase : List[Any] = (LlamaForCausalLM,) if is_torch_available() else () _lowerCamelCase : List[str] = ( { """feature-extraction""": LlamaModel, """text-classification""": LlamaForSequenceClassification, """text-generation""": LlamaForCausalLM, """zero-shot""": LlamaForSequenceClassification, } if is_torch_available() else {} ) _lowerCamelCase : Dict = False _lowerCamelCase : List[str] = False def lowercase ( self : List[Any] ): _UpperCAmelCase = LlamaModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , hidden_size=3_7 ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for type in ["absolute", "relative_key", "relative_key_query"]: _UpperCAmelCase = type self.model_tester.create_and_check_model(*snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = 3 _UpperCAmelCase = input_dict["input_ids"] _UpperCAmelCase = input_ids.ne(1 ).to(snake_case_ ) _UpperCAmelCase = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) _UpperCAmelCase = LlamaForSequenceClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , labels=snake_case_ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = 3 _UpperCAmelCase = "single_label_classification" _UpperCAmelCase = input_dict["input_ids"] _UpperCAmelCase = input_ids.ne(1 ).to(snake_case_ ) _UpperCAmelCase = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) _UpperCAmelCase = LlamaForSequenceClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , labels=snake_case_ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = 3 _UpperCAmelCase = "multi_label_classification" _UpperCAmelCase = input_dict["input_ids"] _UpperCAmelCase = input_ids.ne(1 ).to(snake_case_ ) _UpperCAmelCase = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) _UpperCAmelCase = LlamaForSequenceClassification(snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(snake_case_ , attention_mask=snake_case_ , labels=snake_case_ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) @unittest.skip("LLaMA buffers include complex numbers, which breaks this test" ) def lowercase ( self : Tuple ): pass @parameterized.expand([("linear",), ("dynamic",)] ) def lowercase ( self : Optional[int] , snake_case_ : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = ids_tensor([1, 1_0] , config.vocab_size ) _UpperCAmelCase = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights _UpperCAmelCase = LlamaModel(snake_case_ ) original_model.to(snake_case_ ) original_model.eval() _UpperCAmelCase = original_model(snake_case_ ).last_hidden_state _UpperCAmelCase = original_model(snake_case_ ).last_hidden_state set_seed(4_2 ) # Fixed seed at init time so the two models get the same random weights _UpperCAmelCase = {"type": scaling_type, "factor": 1_0.0} _UpperCAmelCase = LlamaModel(snake_case_ ) scaled_model.to(snake_case_ ) scaled_model.eval() _UpperCAmelCase = scaled_model(snake_case_ ).last_hidden_state _UpperCAmelCase = scaled_model(snake_case_ ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(snake_case_ , snake_case_ , atol=1e-5 ) ) else: self.assertFalse(torch.allclose(snake_case_ , snake_case_ , atol=1e-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(snake_case_ , snake_case_ , atol=1e-5 ) ) @require_torch class A_ ( unittest.TestCase ): @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!" ) @slow def lowercase ( self : Any ): _UpperCAmelCase = [1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8] _UpperCAmelCase = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf" , device_map="auto" ) _UpperCAmelCase = model(torch.tensor([input_ids] ) ) # Expected mean on dim = -1 _UpperCAmelCase = torch.tensor([[-6.6_5_5_0, -4.1_2_2_7, -4.9_8_5_9, -3.2_4_0_6, 0.8_2_6_2, -3.0_0_3_3, 1.2_9_6_4, -3.3_6_9_9]] ) torch.testing.assert_close(out.mean(-1 ) , snake_case_ , atol=1e-2 , rtol=1e-2 ) # slicing logits[0, 0, 0:30] # fmt: off _UpperCAmelCase = torch.tensor([-1_2.8_2_8_1, -7.4_4_5_3, -0.4_6_3_9, -8.0_6_2_5, -7.2_5_0_0, -8.0_0_0_0, -6.4_8_8_3, -7.7_6_9_5, -7.8_4_3_8, -7.0_3_1_2, -6.2_1_8_8, -7.1_3_2_8, -1.8_4_9_6, 1.9_9_6_1, -8.6_2_5_0, -6.7_2_2_7, -1_2.8_2_8_1, -6.9_4_9_2, -7.0_7_4_2, -7.7_8_5_2, -7.5_8_2_0, -7.9_0_6_2, -6.9_3_7_5, -7.9_8_0_5, -8.3_4_3_8, -8.1_5_6_2, -8.0_4_6_9, -7.6_2_5_0, -7.7_4_2_2, -7.3_3_9_8,] ) # fmt: on torch.testing.assert_close(out[0, 0, :3_0] , snake_case_ , atol=1e-5 , rtol=1e-5 ) @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!" ) @slow def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = [1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8] _UpperCAmelCase = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-hf" , device_map="auto" ) _UpperCAmelCase = model(torch.tensor(snake_case_ ) ) # Expected mean on dim = -1 _UpperCAmelCase = torch.tensor([[-2.0_6_2_2, -1.2_7_9_4, -1.1_6_3_8, -0.9_7_8_8, -1.4_6_0_3, -1.0_2_3_8, -1.7_8_9_3, -1.4_4_1_1]] ) torch.testing.assert_close(out.mean(-1 ) , snake_case_ , atol=1e-2 , rtol=1e-2 ) # slicing logits[0, 0, 0:30] # fmt: off _UpperCAmelCase = torch.tensor([-8.1_4_0_6, -8.0_5_4_7, 2.7_4_6_1, -1.2_3_4_4, -0.1_4_4_8, -1.8_2_6_2, -1.0_0_2_0, -1.8_1_5_4, -1.6_8_9_5, -1.8_5_1_6, -2.3_5_7_4, -0.9_2_7_7, 3.7_5_9_8, 6.5_7_4_2, -1.2_9_9_8, -0.1_1_7_7, -8.1_4_0_6, -2.9_6_8_8, -2.9_1_9_9, -3.1_6_9_9, -3.5_2_5_4, -2.3_5_5_5, -2.7_9_8_8, -3.4_1_4_1, -2.8_2_6_2, -4.5_1_9_5, -3.3_3_7_9, -3.3_1_6_4, -2.7_8_3_2, -3.0_2_7_3] ) # fmt: on torch.testing.assert_close(out[0, 0, :3_0] , snake_case_ , atol=1e-5 , rtol=1e-5 ) @unittest.skip("Logits are not exactly the same, once we fix the instabalities somehow, will update!" ) @slow def lowercase ( self : Any ): _UpperCAmelCase = [1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8] _UpperCAmelCase = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf" , device_map="auto" ) _UpperCAmelCase = model(torch.tensor(snake_case_ ) ) # Expected mean on dim = -1 _UpperCAmelCase = torch.tensor([[-0.8_5_6_2, -1.8_5_2_0, -0.7_5_5_1, -0.4_1_6_2, -1.5_1_6_1, -1.2_0_3_8, -2.4_8_2_3, -2.3_2_5_4]] ) torch.testing.assert_close(out.mean(-1 ) , snake_case_ , atol=1e-2 , rtol=1e-2 ) # slicing logits[0, 0, 0:30] # fmt: off _UpperCAmelCase = torch.tensor([-2.2_2_2_7, 4.8_8_2_8, 0.9_0_2_3, -0.4_5_7_8, -0.7_8_7_1, -0.1_0_3_3, -0.6_2_2_1, -0.5_7_8_6, -0.7_8_0_3, -1.0_6_7_4, -1.2_9_2_0, -0.1_5_7_0, 0.8_0_0_8, 2.0_7_2_3, -0.9_4_9_7, 0.2_7_7_1, -2.2_2_2_7, -0.7_6_1_2, -1.4_3_4_6, -1.2_0_6_1, -1.6_4_2_6, -0.3_0_0_0, -0.7_1_3_9, -1.1_9_3_4, -1.8_6_9_1, -1.6_9_7_3, -1.5_9_4_7, -1.2_7_0_5, -0.3_5_2_3, -0.5_5_1_3] ) # fmt: on torch.testing.assert_close(out.mean(-1 ) , snake_case_ , atol=1e-2 , rtol=1e-2 ) @unittest.skip( "Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test" ) @slow def lowercase ( self : List[Any] ): _UpperCAmelCase = [1, 3_0_6, 4_6_5_8, 2_7_8, 6_5_9_3, 3_1_0, 2_8_3_4, 3_3_8] _UpperCAmelCase = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf" , device_map="auto" ) _UpperCAmelCase = model(torch.tensor(snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-4.2_3_2_7, -3.3_3_6_0, -4.6_6_6_5, -4.7_6_3_1, -1.8_1_8_0, -3.4_1_7_0, -1.4_2_1_1, -3.1_8_1_0]] , dtype=torch.floataa ) torch.testing.assert_close(out.mean(-1 ) , snake_case_ , atol=1e-2 , rtol=1e-2 ) # fmt: off _UpperCAmelCase = torch.tensor([-9.4_9_2_2, -3.9_5_5_1, 1.7_9_9_8, -5.6_7_5_8, -5.1_0_5_5, -5.8_9_8_4, -4.8_3_2_0, -6.8_0_8_6, -6.5_3_9_1, -5.6_1_7_2, -5.5_8_2_0, -5.5_3_5_2, 1.7_8_8_1, 3.6_2_8_9, -6.5_1_1_7, -3.4_7_8_5, -9.5_0_0_0, -6.0_3_5_2, -6.8_1_2_5, -6.0_1_9_5, -6.6_8_3_6, -5.4_7_2_7, -6.2_8_1_2, -6.0_3_9_1, -7.3_3_9_8, -7.4_2_9_7, -7.4_8_4_4, -6.5_8_2_0, -5.8_7_8_9, -5.5_3_1_2] ) # fmt: on torch.testing.assert_close(out[0, 0, :3_0] , snake_case_ , atol=1e-5 , rtol=1e-5 ) @unittest.skip("Model is curently gated" ) @slow def lowercase ( self : Optional[Any] ): _UpperCAmelCase = "Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the \"princi" _UpperCAmelCase = "Simply put, the theory of relativity states that " _UpperCAmelCase = LlamaTokenizer.from_pretrained("meta-llama/Llama-2-13b-chat-hf" ) _UpperCAmelCase = tokenizer.encode(snake_case_ , return_tensors="pt" ) _UpperCAmelCase = LlamaForCausalLM.from_pretrained( "meta-llama/Llama-2-13b-chat-hf" , device_map="sequential" , use_safetensors=snake_case_ ) # greedy generation outputs _UpperCAmelCase = model.generate(snake_case_ , max_new_tokens=6_4 , top_p=snake_case_ , temperature=1 , do_sample=snake_case_ ) _UpperCAmelCase = tokenizer.decode(generated_ids[0] , skip_special_tokens=snake_case_ ) self.assertEqual(snake_case_ , snake_case_ )
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = """encoder-decoder""" _lowerCamelCase : Dict = True def __init__( self : List[Any] , **snake_case_ : Dict ): super().__init__(**snake_case_ ) assert ( "encoder" in kwargs and "decoder" in kwargs ), "Config has to be initialized with encoder and decoder config" _UpperCAmelCase = kwargs.pop("encoder" ) _UpperCAmelCase = encoder_config.pop("model_type" ) _UpperCAmelCase = kwargs.pop("decoder" ) _UpperCAmelCase = decoder_config.pop("model_type" ) from ..auto.configuration_auto import AutoConfig _UpperCAmelCase = AutoConfig.for_model(snake_case_ , **snake_case_ ) _UpperCAmelCase = AutoConfig.for_model(snake_case_ , **snake_case_ ) _UpperCAmelCase = True @classmethod def lowercase ( cls : Tuple , snake_case_ : PretrainedConfig , snake_case_ : PretrainedConfig , **snake_case_ : Any ): logger.info("Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config" ) _UpperCAmelCase = True _UpperCAmelCase = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **snake_case_ ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = copy.deepcopy(self.__dict__ ) _UpperCAmelCase = self.encoder.to_dict() _UpperCAmelCase = self.decoder.to_dict() _UpperCAmelCase = self.__class__.model_type return output
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' import unittest from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers @require_sentencepiece @slow # see https://github.com/huggingface/transformers/issues/11457 class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = BarthezTokenizer _lowerCamelCase : Dict = BarthezTokenizerFast _lowerCamelCase : Dict = True _lowerCamelCase : Optional[Any] = True def lowercase ( self : Any ): super().setUp() _UpperCAmelCase = BarthezTokenizerFast.from_pretrained("moussaKam/mbarthez" ) tokenizer.save_pretrained(self.tmpdirname ) tokenizer.save_pretrained(self.tmpdirname , legacy_format=snake_case_ ) _UpperCAmelCase = tokenizer def lowercase ( self : Dict ): _UpperCAmelCase = "<pad>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<s>" ) self.assertEqual(vocab_keys[1] , "<pad>" ) self.assertEqual(vocab_keys[-1] , "<mask>" ) self.assertEqual(len(snake_case_ ) , 1_0_1_1_2_2 ) def lowercase ( self : Tuple ): self.assertEqual(self.get_tokenizer().vocab_size , 1_0_1_1_2_2 ) @require_torch def lowercase ( self : Optional[Any] ): _UpperCAmelCase = ["A long paragraph for summarization.", "Another paragraph for summarization."] _UpperCAmelCase = [0, 5_7, 3_0_1_8, 7_0_3_0_7, 9_1, 2] _UpperCAmelCase = self.tokenizer( snake_case_ , max_length=len(snake_case_ ) , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) self.assertIsInstance(snake_case_ , snake_case_ ) self.assertEqual((2, 6) , batch.input_ids.shape ) self.assertEqual((2, 6) , batch.attention_mask.shape ) _UpperCAmelCase = batch.input_ids.tolist()[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Any ): if not self.test_rust_tokenizer: return _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = "I was born in 92000, and this is falsé." _UpperCAmelCase = tokenizer.tokenize(snake_case_ ) _UpperCAmelCase = rust_tokenizer.tokenize(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) _UpperCAmelCase = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) _UpperCAmelCase = rust_tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = tokenizer.encode(snake_case_ ) _UpperCAmelCase = rust_tokenizer.encode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) @slow def lowercase ( self : int ): # fmt: off _UpperCAmelCase = {"input_ids": [[0, 4_9_0, 1_4_3_2_8, 4_5_0_7, 3_5_4, 4_7, 4_3_6_6_9, 9_5, 2_5, 7_8_1_1_7, 2_0_2_1_5, 1_9_7_7_9, 1_9_0, 2_2, 4_0_0, 4, 3_5_3_4_3, 8_0_3_1_0, 6_0_3, 8_6, 2_4_9_3_7, 1_0_5, 3_3_4_3_8, 9_4_7_6_2, 1_9_6, 3_9_6_4_2, 7, 1_5, 1_5_9_3_3, 1_7_3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1_0_5_3_4, 8_7, 2_5, 6_6, 3_3_5_8, 1_9_6, 5_5_2_8_9, 8, 8_2_9_6_1, 8_1, 2_2_0_4, 7_5_2_0_3, 7, 1_5, 7_6_3, 1_2_9_5_6, 2_1_6, 1_7_8, 1_4_3_2_8, 9_5_9_5, 1_3_7_7, 6_9_6_9_3, 7, 4_4_8, 7_1_0_2_1, 1_9_6, 1_8_1_0_6, 1_4_3_7, 1_3_9_7_4, 1_0_8, 9_0_8_3, 4, 4_9_3_1_5, 7, 3_9, 8_6, 1_3_2_6, 2_7_9_3, 4_6_3_3_3, 4, 4_4_8, 1_9_6, 7_4_5_8_8, 7, 4_9_3_1_5, 7, 3_9, 2_1, 8_2_2, 3_8_4_7_0, 7_4, 2_1, 6_6_7_2_3, 6_2_4_8_0, 8, 2_2_0_5_0, 5, 2]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # noqa: E501 # fmt: on # moussaKam/mbarthez is a french model. So we also use french texts. _UpperCAmelCase = [ "Le transformeur est un modèle d'apprentissage profond introduit en 2017, " "utilisé principalement dans le domaine du traitement automatique des langues (TAL).", "À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus " "pour gérer des données séquentielles, telles que le langage naturel, pour des tâches " "telles que la traduction et la synthèse de texte.", ] self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="moussaKam/mbarthez" , revision="c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6" , sequences=snake_case_ , )
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' import os import re import shutil import sys import tempfile import unittest import black __SCREAMING_SNAKE_CASE :Optional[int] = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, '''utils''')) import check_copies # noqa: E402 # This is the reference code that will be used in the tests. # If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated. __SCREAMING_SNAKE_CASE :Any = ''' def __init__(self, config): super().__init__() self.transform = BertPredictionHeadTransform(config) # The output weights are the same as the input embeddings, but there is # an output-only bias for each token. self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False) self.bias = nn.Parameter(torch.zeros(config.vocab_size)) # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings` self.decoder.bias = self.bias def forward(self, hidden_states): hidden_states = self.transform(hidden_states) hidden_states = self.decoder(hidden_states) return hidden_states ''' class A_ ( unittest.TestCase ): def lowercase ( self : List[Any] ): _UpperCAmelCase = tempfile.mkdtemp() os.makedirs(os.path.join(self.transformer_dir , "models/bert/" ) ) _UpperCAmelCase = self.transformer_dir shutil.copy( os.path.join(snake_case_ , "src/transformers/models/bert/modeling_bert.py" ) , os.path.join(self.transformer_dir , "models/bert/modeling_bert.py" ) , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = "src/transformers" shutil.rmtree(self.transformer_dir ) def lowercase ( self : Dict , snake_case_ : int , snake_case_ : Any , snake_case_ : Any , snake_case_ : Union[str, Any]=None ): _UpperCAmelCase = comment + f'\nclass {class_name}(nn.Module):\n' + class_code if overwrite_result is not None: _UpperCAmelCase = comment + f'\nclass {class_name}(nn.Module):\n' + overwrite_result _UpperCAmelCase = black.Mode(target_versions={black.TargetVersion.PYaa} , line_length=1_1_9 ) _UpperCAmelCase = black.format_str(snake_case_ , mode=snake_case_ ) _UpperCAmelCase = os.path.join(self.transformer_dir , "new_code.py" ) with open(snake_case_ , "w" , newline="\n" ) as f: f.write(snake_case_ ) if overwrite_result is None: self.assertTrue(len(check_copies.is_copy_consistent(snake_case_ ) ) == 0 ) else: check_copies.is_copy_consistent(f.name , overwrite=snake_case_ ) with open(snake_case_ , "r" ) as f: self.assertTrue(f.read() , snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase = check_copies.find_code_in_transformers("models.bert.modeling_bert.BertLMPredictionHead" ) self.assertEqual(snake_case_ , snake_case_ ) def lowercase ( self : Any ): # Base copy consistency self.check_copy_consistency( "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead" , "BertLMPredictionHead" , REFERENCE_CODE + "\n" , ) # With no empty line at the end self.check_copy_consistency( "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead" , "BertLMPredictionHead" , snake_case_ , ) # Copy consistency with rename self.check_copy_consistency( "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel" , "TestModelLMPredictionHead" , re.sub("Bert" , "TestModel" , snake_case_ ) , ) # Copy consistency with a really long name _UpperCAmelCase = "TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason" self.check_copy_consistency( f'# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}' , f'{long_class_name}LMPredictionHead' , re.sub("Bert" , snake_case_ , snake_case_ ) , ) # Copy consistency with overwrite self.check_copy_consistency( "# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel" , "TestModelLMPredictionHead" , snake_case_ , overwrite_result=re.sub("Bert" , "TestModel" , snake_case_ ) , ) def lowercase ( self : List[Any] ): _UpperCAmelCase = check_copies.LOCALIZED_READMES["README_zh-hans.md"] _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the" " Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for" " Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong" " Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1." " **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace)," " released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and" " lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same" " method has been applied to compress GPT2 into" " [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into" " [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation)," " Multilingual BERT into" " [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German" " version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**" " (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders" " as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang" " Luong, Quoc V. Le, Christopher D. Manning." ) _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the" " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of" " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian" " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n" ) _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the" " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of" " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian" " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1." " **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文" " [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and" " lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same" " method has been applied to compress GPT2 into" " [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into" " [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation)," " Multilingual BERT into" " [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German" " version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自" " Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather" " than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le," " Christopher D. Manning 发布。\n" ) _UpperCAmelCase , _UpperCAmelCase = check_copies.convert_to_localized_md( snake_case_ , snake_case_ , localized_readme["format_model_list"] ) self.assertFalse(snake_case_ ) self.assertEqual(snake_case_ , snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = check_copies.convert_to_localized_md( snake_case_ , snake_case_ , localized_readme["format_model_list"] ) # Check whether the number of models is equal to README.md after conversion. self.assertTrue(snake_case_ ) _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the" " Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for" " Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong" " Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut." ) _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and" " the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of" " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian" " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n" ) _UpperCAmelCase = ( "1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the" " Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of" " Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian" " Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n" ) _UpperCAmelCase , _UpperCAmelCase = check_copies.convert_to_localized_md( snake_case_ , snake_case_ , localized_readme["format_model_list"] ) # Check if the model link is synchronized. self.assertEqual(snake_case_ , snake_case_ )
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__lowercase ) )
22
1
'''simple docstring''' from collections import UserDict from typing import Union import numpy as np import requests from ..utils import ( add_end_docstrings, logging, ) from .audio_classification import ffmpeg_read from .base import PIPELINE_INIT_ARGS, Pipeline __SCREAMING_SNAKE_CASE :Optional[int] = logging.get_logger(__name__) @add_end_docstrings(lowerCAmelCase_ ) class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , **snake_case_ : Tuple ): super().__init__(**snake_case_ ) if self.framework != "pt": raise ValueError(f'The {self.__class__} is only available in PyTorch.' ) # No specific FOR_XXX available yet def __call__( self : Dict , snake_case_ : Union[np.ndarray, bytes, str] , **snake_case_ : Union[str, Any] ): return super().__call__(snake_case_ , **snake_case_ ) def lowercase ( self : int , **snake_case_ : int ): _UpperCAmelCase = {} if "candidate_labels" in kwargs: _UpperCAmelCase = kwargs["candidate_labels"] if "hypothesis_template" in kwargs: _UpperCAmelCase = kwargs["hypothesis_template"] return preprocess_params, {}, {} def lowercase ( self : Union[str, Any] , snake_case_ : int , snake_case_ : str=None , snake_case_ : List[Any]="This is a sound of {}." ): if isinstance(snake_case_ , snake_case_ ): if audio.startswith("http://" ) or audio.startswith("https://" ): # We need to actually check for a real protocol, otherwise it's impossible to use a local file # like http_huggingface_co.png _UpperCAmelCase = requests.get(snake_case_ ).content else: with open(snake_case_ , "rb" ) as f: _UpperCAmelCase = f.read() if isinstance(snake_case_ , snake_case_ ): _UpperCAmelCase = ffmpeg_read(snake_case_ , self.feature_extractor.sampling_rate ) if not isinstance(snake_case_ , np.ndarray ): raise ValueError("We expect a numpy ndarray as input" ) if len(audio.shape ) != 1: raise ValueError("We expect a single channel audio input for ZeroShotAudioClassificationPipeline" ) _UpperCAmelCase = self.feature_extractor( [audio] , sampling_rate=self.feature_extractor.sampling_rate , return_tensors="pt" ) _UpperCAmelCase = candidate_labels _UpperCAmelCase = [hypothesis_template.format(snake_case_ ) for x in candidate_labels] _UpperCAmelCase = self.tokenizer(snake_case_ , return_tensors=self.framework , padding=snake_case_ ) _UpperCAmelCase = [text_inputs] return inputs def lowercase ( self : List[str] , snake_case_ : Any ): _UpperCAmelCase = model_inputs.pop("candidate_labels" ) _UpperCAmelCase = model_inputs.pop("text_inputs" ) if isinstance(text_inputs[0] , snake_case_ ): _UpperCAmelCase = text_inputs[0] else: # Batching case. _UpperCAmelCase = text_inputs[0][0] _UpperCAmelCase = self.model(**snake_case_ , **snake_case_ ) _UpperCAmelCase = { "candidate_labels": candidate_labels, "logits": outputs.logits_per_audio, } return model_outputs def lowercase ( self : List[Any] , snake_case_ : Union[str, Any] ): _UpperCAmelCase = model_outputs.pop("candidate_labels" ) _UpperCAmelCase = model_outputs["logits"][0] if self.framework == "pt": _UpperCAmelCase = logits.softmax(dim=0 ) _UpperCAmelCase = probs.tolist() else: raise ValueError("`tf` framework not supported." ) _UpperCAmelCase = [ {"score": score, "label": candidate_label} for score, candidate_label in sorted(zip(snake_case_ , snake_case_ ) , key=lambda snake_case_ : -x[0] ) ] return result
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __SCREAMING_SNAKE_CASE :Optional[int] = { '''configuration_blenderbot''': [ '''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BlenderbotConfig''', '''BlenderbotOnnxConfig''', ], '''tokenization_blenderbot''': ['''BlenderbotTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :List[Any] = ['''BlenderbotTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Optional[int] = [ '''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BlenderbotForCausalLM''', '''BlenderbotForConditionalGeneration''', '''BlenderbotModel''', '''BlenderbotPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :int = [ '''TFBlenderbotForConditionalGeneration''', '''TFBlenderbotModel''', '''TFBlenderbotPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :Tuple = [ '''FlaxBlenderbotForConditionalGeneration''', '''FlaxBlenderbotModel''', '''FlaxBlenderbotPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_blenderbot import ( BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotConfig, BlenderbotOnnxConfig, ) from .tokenization_blenderbot import BlenderbotTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_fast import BlenderbotTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot import ( BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel, BlenderbotPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot import ( TFBlenderbotForConditionalGeneration, TFBlenderbotModel, TFBlenderbotPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, FlaxBlenderbotPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Optional[int] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' 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: __SCREAMING_SNAKE_CASE :List[Any] = None __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''', }, } __SCREAMING_SNAKE_CASE :Optional[Any] = { '''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, } __SCREAMING_SNAKE_CASE :Optional[int] = '''▁''' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = VOCAB_FILES_NAMES _lowerCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : int = AlbertTokenizer def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=True , snake_case_ : str=True , snake_case_ : Tuple=False , snake_case_ : List[Any]="[CLS]" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : str="<unk>" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : List[Any]="<pad>" , snake_case_ : List[str]="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. _UpperCAmelCase = ( AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ , normalized=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token ) super().__init__( snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
1
'''simple docstring''' import os from shutil import copyfile from typing import List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Tuple = {'''vocab_file''': '''sentencepiece.model'''} __SCREAMING_SNAKE_CASE :Union[str, Any] = { '''vocab_file''': { '''google/rembert''': '''https://huggingface.co/google/rembert/resolve/main/sentencepiece.model''', }, } __SCREAMING_SNAKE_CASE :List[Any] = { '''google/rembert''': 256, } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[Any] = VOCAB_FILES_NAMES _lowerCamelCase : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Any = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : List[str] , snake_case_ : Tuple , snake_case_ : Any=False , snake_case_ : Tuple=True , snake_case_ : Tuple=True , snake_case_ : int="[CLS]" , snake_case_ : Optional[Any]="[SEP]" , snake_case_ : int="[UNK]" , snake_case_ : Optional[int]="[SEP]" , snake_case_ : Any="[PAD]" , snake_case_ : Any="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Optional[int] , ): super().__init__( do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = spm.SentencePieceProcessor() self.sp_model.Load(snake_case_ ) @property def lowercase ( self : Union[str, Any] ): return len(self.sp_model ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = {self.convert_ids_to_tokens(snake_case_ ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Tuple ): _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None return state def __setstate__( self : Tuple , snake_case_ : Dict ): _UpperCAmelCase = d _UpperCAmelCase = spm.SentencePieceProcessor() self.sp_model.Load(self.vocab_file ) def lowercase ( self : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : str=False ): _UpperCAmelCase = self.sp_model.EncodeAsPieces(snake_case_ ) return pieces def lowercase ( self : Union[str, Any] , snake_case_ : Optional[Any] ): return self.sp_model.PieceToId(snake_case_ ) def lowercase ( self : Dict , snake_case_ : Tuple ): return self.sp_model.IdToPiece(snake_case_ ) def lowercase ( self : Dict , snake_case_ : Union[str, Any] ): _UpperCAmelCase = self.sp_model.decode_pieces(snake_case_ ) return out_string def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Optional[Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None , snake_case_ : bool = False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( "You should not supply a second sequence if the provided sequence of " "ids is already formatted with special tokens for the model." ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(snake_case_ )) + [1] + ([0] * len(snake_case_ )) + [1] return [1] + ([0] * len(snake_case_ )) + [1] def lowercase ( self : Tuple , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[str] = None ): if not os.path.isdir(snake_case_ ): logger.error("Vocabulary path ({}) should be a directory".format(snake_case_ ) ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
1
'''simple docstring''' from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :Tuple = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = { '''microsoft/trocr-base-handwritten''': ( '''https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json''' ), # See all TrOCR models at https://huggingface.co/models?filter=trocr } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """trocr""" _lowerCamelCase : List[str] = ["""past_key_values"""] _lowerCamelCase : int = { """num_attention_heads""": """decoder_attention_heads""", """hidden_size""": """d_model""", """num_hidden_layers""": """decoder_layers""", } def __init__( self : Union[str, Any] , snake_case_ : Dict=5_0_2_6_5 , snake_case_ : Dict=1_0_2_4 , snake_case_ : Optional[Any]=1_2 , snake_case_ : int=1_6 , snake_case_ : Tuple=4_0_9_6 , snake_case_ : List[Any]="gelu" , snake_case_ : Dict=5_1_2 , snake_case_ : str=0.1 , snake_case_ : Optional[Any]=0.0 , snake_case_ : Optional[int]=0.0 , snake_case_ : List[str]=2 , snake_case_ : int=0.0_2 , snake_case_ : int=0.0 , snake_case_ : Union[str, Any]=True , snake_case_ : str=False , snake_case_ : Tuple=True , snake_case_ : List[str]=True , snake_case_ : Optional[int]=1 , snake_case_ : int=0 , snake_case_ : Dict=2 , **snake_case_ : List[Any] , ): _UpperCAmelCase = vocab_size _UpperCAmelCase = d_model _UpperCAmelCase = decoder_layers _UpperCAmelCase = decoder_attention_heads _UpperCAmelCase = decoder_ffn_dim _UpperCAmelCase = activation_function _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = init_std _UpperCAmelCase = decoder_layerdrop _UpperCAmelCase = use_cache _UpperCAmelCase = scale_embedding _UpperCAmelCase = use_learned_position_embeddings _UpperCAmelCase = layernorm_embedding super().__init__( pad_token_id=snake_case_ , bos_token_id=snake_case_ , eos_token_id=snake_case_ , decoder_start_token_id=snake_case_ , **snake_case_ , )
22
'''simple docstring''' import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef __SCREAMING_SNAKE_CASE :List[str] = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : Tuple ) -> int: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) return (preds == labels).mean() def UpperCAmelCase_ ( __lowercase : int , __lowercase : str ) -> Optional[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = simple_accuracy(__lowercase , __lowercase ) _UpperCAmelCase = fa_score(y_true=__lowercase , y_pred=__lowercase ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[int] , __lowercase : List[str] ) -> List[Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) _UpperCAmelCase = pearsonr(__lowercase , __lowercase )[0] _UpperCAmelCase = spearmanr(__lowercase , __lowercase )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) assert len(__lowercase ) == len(__lowercase ), f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' if task_name == "cola": return {"mcc": matthews_corrcoef(__lowercase , __lowercase )} elif task_name == "sst-2": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mrpc": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "sts-b": return pearson_and_spearman(__lowercase , __lowercase ) elif task_name == "qqp": return acc_and_fa(__lowercase , __lowercase ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "qnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "rte": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "wnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} elif task_name == "hans": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase ) def UpperCAmelCase_ ( __lowercase : List[Any] , __lowercase : Dict , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' warnings.warn(__lowercase , __lowercase ) requires_backends(__lowercase , "sklearn" ) if len(__lowercase ) != len(__lowercase ): raise ValueError(f'Predictions and labels have mismatched lengths {len(__lowercase )} and {len(__lowercase )}' ) if task_name == "xnli": return {"acc": simple_accuracy(__lowercase , __lowercase )} else: raise KeyError(__lowercase )
22
1
'''simple docstring''' from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from ..image_utils import load_image if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_OBJECT_DETECTION_MAPPING, MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING __SCREAMING_SNAKE_CASE :Optional[int] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Tuple = Dict[str, Any] __SCREAMING_SNAKE_CASE :Optional[int] = List[Prediction] @add_end_docstrings(lowerCAmelCase_ ) class A_ ( lowerCAmelCase_ ): def __init__( self : List[str] , *snake_case_ : List[Any] , **snake_case_ : Union[str, Any] ): super().__init__(*snake_case_ , **snake_case_ ) if self.framework == "tf": raise ValueError(f'The {self.__class__} is only available in PyTorch.' ) requires_backends(self , "vision" ) self.check_model_type( dict(MODEL_FOR_OBJECT_DETECTION_MAPPING.items() + MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING.items() ) ) def lowercase ( self : List[Any] , **snake_case_ : Optional[Any] ): _UpperCAmelCase = {} if "threshold" in kwargs: _UpperCAmelCase = kwargs["threshold"] return {}, {}, postprocess_kwargs def __call__( self : Tuple , *snake_case_ : Optional[int] , **snake_case_ : Optional[int] ): return super().__call__(*snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Dict ): _UpperCAmelCase = load_image(snake_case_ ) _UpperCAmelCase = torch.IntTensor([[image.height, image.width]] ) _UpperCAmelCase = self.image_processor(images=[image] , return_tensors="pt" ) if self.tokenizer is not None: _UpperCAmelCase = self.tokenizer(text=inputs["words"] , boxes=inputs["boxes"] , return_tensors="pt" ) _UpperCAmelCase = target_size return inputs def lowercase ( self : Optional[int] , snake_case_ : str ): _UpperCAmelCase = model_inputs.pop("target_size" ) _UpperCAmelCase = self.model(**snake_case_ ) _UpperCAmelCase = outputs.__class__({"target_size": target_size, **outputs} ) if self.tokenizer is not None: _UpperCAmelCase = model_inputs["bbox"] return model_outputs def lowercase ( self : Dict , snake_case_ : Optional[Any] , snake_case_ : str=0.9 ): _UpperCAmelCase = model_outputs["target_size"] if self.tokenizer is not None: # This is a LayoutLMForTokenClassification variant. # The OCR got the boxes and the model classified the words. _UpperCAmelCase , _UpperCAmelCase = target_size[0].tolist() def unnormalize(snake_case_ : List[Any] ): return self._get_bounding_box( torch.Tensor( [ (width * bbox[0] / 1_0_0_0), (height * bbox[1] / 1_0_0_0), (width * bbox[2] / 1_0_0_0), (height * bbox[3] / 1_0_0_0), ] ) ) _UpperCAmelCase , _UpperCAmelCase = model_outputs["logits"].squeeze(0 ).softmax(dim=-1 ).max(dim=-1 ) _UpperCAmelCase = [self.model.config.idalabel[prediction] for prediction in classes.tolist()] _UpperCAmelCase = [unnormalize(snake_case_ ) for bbox in model_outputs["bbox"].squeeze(0 )] _UpperCAmelCase = ["score", "label", "box"] _UpperCAmelCase = [dict(zip(snake_case_ , snake_case_ ) ) for vals in zip(scores.tolist() , snake_case_ , snake_case_ ) if vals[0] > threshold] else: # This is a regular ForObjectDetectionModel _UpperCAmelCase = self.image_processor.post_process_object_detection(snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = raw_annotations[0] _UpperCAmelCase = raw_annotation["scores"] _UpperCAmelCase = raw_annotation["labels"] _UpperCAmelCase = raw_annotation["boxes"] _UpperCAmelCase = scores.tolist() _UpperCAmelCase = [self.model.config.idalabel[label.item()] for label in labels] _UpperCAmelCase = [self._get_bounding_box(snake_case_ ) for box in boxes] # {"scores": [...], ...} --> [{"score":x, ...}, ...] _UpperCAmelCase = ["score", "label", "box"] _UpperCAmelCase = [ dict(zip(snake_case_ , snake_case_ ) ) for vals in zip(raw_annotation["scores"] , raw_annotation["labels"] , raw_annotation["boxes"] ) ] return annotation def lowercase ( self : Optional[int] , snake_case_ : "torch.Tensor" ): if self.framework != "pt": raise ValueError("The ObjectDetectionPipeline is only available in PyTorch." ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = box.int().tolist() _UpperCAmelCase = { "xmin": xmin, "ymin": ymin, "xmax": xmax, "ymax": ymax, } return bbox
22
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
1
'''simple docstring''' import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration __SCREAMING_SNAKE_CASE :Any = 50000 __SCREAMING_SNAKE_CASE :List[str] = 5000 __SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE :Dict = os.path.split(__file__) __SCREAMING_SNAKE_CASE :str = os.path.join(RESULTS_BASEPATH, '''results''', RESULTS_FILENAME.replace('''.py''', '''.json''')) @get_duration def UpperCAmelCase_ ( __lowercase : datasets.Dataset , __lowercase : Any ) -> Dict: '''simple docstring''' for i in range(__lowercase ): _UpperCAmelCase = dataset[i] @get_duration def UpperCAmelCase_ ( __lowercase : datasets.Dataset , __lowercase : int , __lowercase : Union[str, Any] ) -> str: '''simple docstring''' for i in range(0 , len(__lowercase ) , __lowercase ): _UpperCAmelCase = dataset[i : i + batch_size] @get_duration def UpperCAmelCase_ ( __lowercase : datasets.Dataset , __lowercase : int , __lowercase : Union[str, Any] ) -> Dict: '''simple docstring''' with dataset.formatted_as(type=__lowercase ): for i in range(__lowercase ): _UpperCAmelCase = dataset[i] @get_duration def UpperCAmelCase_ ( __lowercase : datasets.Dataset , __lowercase : Optional[int] , __lowercase : List[str] , __lowercase : Any ) -> Union[str, Any]: '''simple docstring''' with dataset.formatted_as(type=__lowercase ): for i in range(0 , __lowercase , __lowercase ): _UpperCAmelCase = dataset[i : i + batch_size] def UpperCAmelCase_ ( ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase = {"num examples": SPEED_TEST_N_EXAMPLES} _UpperCAmelCase = [ (read, {"length": SMALL_TEST}), (read, {"length": SPEED_TEST_N_EXAMPLES}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1000}), (read_formatted, {"type": "numpy", "length": SMALL_TEST}), (read_formatted, {"type": "pandas", "length": SMALL_TEST}), (read_formatted, {"type": "torch", "length": SMALL_TEST}), (read_formatted, {"type": "tensorflow", "length": SMALL_TEST}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1000}), ] _UpperCAmelCase = [ (read, {"length": SMALL_TEST}), (read, {"length": SPEED_TEST_N_EXAMPLES}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}), (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1000}), (read_formatted, {"type": "numpy", "length": SMALL_TEST}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}), (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1000}), ] with tempfile.TemporaryDirectory() as tmp_dir: print("generating dataset" ) _UpperCAmelCase = datasets.Features( {"list": datasets.Sequence(datasets.Value("float32" ) ), "numbers": datasets.Value("float32" )} ) _UpperCAmelCase = generate_example_dataset( os.path.join(__lowercase , "dataset.arrow" ) , __lowercase , num_examples=__lowercase , seq_shapes={"list": (100,)} , ) print("first set of iterations" ) for func, kwargs in functions: print(func.__name__ , str(__lowercase ) ) _UpperCAmelCase = func(__lowercase , **__lowercase ) print("shuffling dataset" ) _UpperCAmelCase = dataset.shuffle() print("Second set of iterations (after shuffling" ) for func, kwargs in functions_shuffled: print("shuffled " , func.__name__ , str(__lowercase ) ) _UpperCAmelCase = func( __lowercase , **__lowercase ) with open(__lowercase , "wb" ) as f: f.write(json.dumps(__lowercase ).encode("utf-8" ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
22
'''simple docstring''' import os from datetime import datetime as dt from github import Github __SCREAMING_SNAKE_CASE :str = [ '''good first issue''', '''feature request''', '''wip''', ] def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = Github(os.environ["GITHUB_TOKEN"] ) _UpperCAmelCase = g.get_repo("huggingface/accelerate" ) _UpperCAmelCase = repo.get_issues(state="open" ) for issue in open_issues: _UpperCAmelCase = sorted([comment for comment in issue.get_comments()] , key=lambda __lowercase : i.created_at , reverse=__lowercase ) _UpperCAmelCase = comments[0] if len(__lowercase ) > 0 else None _UpperCAmelCase = dt.utcnow() _UpperCAmelCase = (current_time - issue.updated_at).days _UpperCAmelCase = (current_time - issue.created_at).days if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and days_since_updated > 7 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Close issue since it has been 7 days of inactivity since bot mention. issue.edit(state="closed" ) elif ( days_since_updated > 23 and days_since_creation >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # Add stale comment issue.create_comment( "This issue has been automatically marked as stale because it has not had " "recent activity. If you think this still needs to be addressed " "please comment on this thread.\n\nPlease note that issues that do not follow the " "[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) " "are likely to be ignored." ) if __name__ == "__main__": main()
22
1
'''simple docstring''' import unittest import numpy as np import torch from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class A_ ( unittest.TestCase ): @property def lowercase ( self : Dict ): torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(3_2, 6_4) , layers_per_block=2 , sample_size=3_2 , in_channels=3 , out_channels=3 , down_block_types=("DownBlock2D", "AttnDownBlock2D") , up_block_types=("AttnUpBlock2D", "UpBlock2D") , ) return model def lowercase ( self : List[Any] ): _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = PNDMScheduler() _UpperCAmelCase = PNDMPipeline(unet=snake_case_ , scheduler=snake_case_ ) pndm.to(snake_case_ ) pndm.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = pndm(generator=snake_case_ , num_inference_steps=2_0 , output_type="numpy" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = pndm(generator=snake_case_ , num_inference_steps=2_0 , output_type="numpy" , return_dict=snake_case_ )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 3_2, 3_2, 3) _UpperCAmelCase = np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch class A_ ( unittest.TestCase ): def lowercase ( self : List[str] ): _UpperCAmelCase = "google/ddpm-cifar10-32" _UpperCAmelCase = UNetaDModel.from_pretrained(snake_case_ ) _UpperCAmelCase = PNDMScheduler() _UpperCAmelCase = PNDMPipeline(unet=snake_case_ , scheduler=snake_case_ ) pndm.to(snake_case_ ) pndm.set_progress_bar_config(disable=snake_case_ ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = pndm(generator=snake_case_ , output_type="numpy" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 3_2, 3_2, 3) _UpperCAmelCase = np.array([0.1_5_6_4, 0.1_4_6_4_5, 0.1_4_0_6, 0.1_4_7_1_5, 0.1_2_4_2_5, 0.1_4_0_4_5, 0.1_3_1_1_5, 0.1_2_1_7_5, 0.1_2_5] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
22
'''simple docstring''' import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( "files" , [ ["full:README.md", "dataset_infos.json"], ["empty:README.md", "dataset_infos.json"], ["dataset_infos.json"], ["full:README.md"], ] , ) def UpperCAmelCase_ ( __lowercase : Any , __lowercase : int ) -> int: '''simple docstring''' _UpperCAmelCase = tmp_path_factory.mktemp("dset_infos_dir" ) if "full:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("---\ndataset_info:\n dataset_size: 42\n---" ) if "empty:README.md" in files: with open(dataset_infos_dir / "README.md" , "w" ) as f: f.write("" ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / "dataset_infos.json" , "w" ) as f: f.write("{\"default\": {\"dataset_size\": 42}}" ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( "dataset_info" , [ DatasetInfo(), DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ), ] , ) def UpperCAmelCase_ ( __lowercase : Tuple , __lowercase : DatasetInfo ) -> Any: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_info.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfo.from_directory(__lowercase ) assert dataset_info == reloaded assert os.path.exists(os.path.join(__lowercase , "dataset_info.json" ) ) def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = DatasetInfo( description="foo" , citation="bar" , homepage="https://foo.bar" , license="CC0" , features=Features({"a": Value("int32" )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train", "num_examples": 42}] , download_checksums={} , download_size=1337 , post_processing_size=442 , dataset_size=1234 , size_in_bytes=1337 + 442 + 1234 , ) _UpperCAmelCase = dataset_info._to_yaml_dict() assert sorted(__lowercase ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _UpperCAmelCase = yaml.safe_dump(__lowercase ) _UpperCAmelCase = yaml.safe_load(__lowercase ) assert dataset_info_yaml_dict == reloaded def UpperCAmelCase_ ( ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = DatasetInfo() _UpperCAmelCase = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( "dataset_infos_dict" , [ DatasetInfosDict(), DatasetInfosDict({"default": DatasetInfo()} ), DatasetInfosDict({"my_config_name": DatasetInfo()} ), DatasetInfosDict( { "default": DatasetInfo( description="foo" , features=Features({"a": Value("int32" )} ) , builder_name="builder" , config_name="config" , version="1.0.0" , splits=[{"name": "train"}] , download_size=42 , ) } ), DatasetInfosDict( { "v1": DatasetInfo(dataset_size=42 ), "v2": DatasetInfo(dataset_size=1337 ), } ), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : DatasetInfosDict ) -> Dict: '''simple docstring''' _UpperCAmelCase = str(__lowercase ) dataset_infos_dict.write_to_directory(__lowercase ) _UpperCAmelCase = DatasetInfosDict.from_directory(__lowercase ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _UpperCAmelCase = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _UpperCAmelCase = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(__lowercase , "README.md" ) )
22
1
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : list[int] ) -> list[list[int]]: '''simple docstring''' _UpperCAmelCase = [] if len(__lowercase ) == 1: return [nums.copy()] for _ in range(len(__lowercase ) ): _UpperCAmelCase = nums.pop(0 ) _UpperCAmelCase = permute(__lowercase ) for perm in permutations: perm.append(__lowercase ) result.extend(__lowercase ) nums.append(__lowercase ) return result def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' def backtrack(__lowercase : Dict ): if start == len(__lowercase ) - 1: output.append(nums[:] ) else: for i in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase , _UpperCAmelCase = nums[i], nums[start] backtrack(start + 1 ) _UpperCAmelCase , _UpperCAmelCase = nums[i], nums[start] # backtrack _UpperCAmelCase = [] backtrack(0 ) return output if __name__ == "__main__": import doctest # use res to print the data in permute2 function __SCREAMING_SNAKE_CASE :Union[str, Any] = permutea([1, 2, 3]) print(res) doctest.testmod()
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' return " ".join( "".join(word[::-1] ) if len(__lowercase ) > 4 else word for word in sentence.split() ) if __name__ == "__main__": import doctest doctest.testmod() print(reverse_long_words('''Hey wollef sroirraw'''))
22
1
'''simple docstring''' import importlib.metadata from typing import Union from packaging.version import Version, parse from .constants import STR_OPERATION_TO_FUNC __SCREAMING_SNAKE_CASE :Tuple = parse(importlib.metadata.version('''torch''')) def UpperCAmelCase_ ( __lowercase : Union[str, Version] , __lowercase : str , __lowercase : str ) -> Union[str, Any]: '''simple docstring''' if operation not in STR_OPERATION_TO_FUNC.keys(): raise ValueError(f'`operation` must be one of {list(STR_OPERATION_TO_FUNC.keys() )}, received {operation}' ) _UpperCAmelCase = STR_OPERATION_TO_FUNC[operation] if isinstance(__lowercase , __lowercase ): _UpperCAmelCase = parse(importlib.metadata.version(__lowercase ) ) return operation(__lowercase , parse(__lowercase ) ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> Tuple: '''simple docstring''' return compare_versions(__lowercase , __lowercase , __lowercase )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : str ) -> list: '''simple docstring''' if n_term == "": return [] _UpperCAmelCase = [] for temp in range(int(__lowercase ) ): series.append(f'1/{temp + 1}' if series else "1" ) return series if __name__ == "__main__": __SCREAMING_SNAKE_CASE :str = input('''Enter the last number (nth term) of the Harmonic Series''') print('''Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n''') print(harmonic_series(nth_term))
22
1
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' import unittest from transformers import PegasusTokenizer, PegasusTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __SCREAMING_SNAKE_CASE :int = get_tests_dir('''fixtures/test_sentencepiece_no_bos.model''') @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : int = PegasusTokenizerFast _lowerCamelCase : Union[str, Any] = True _lowerCamelCase : List[str] = True def lowercase ( self : Optional[int] ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/pegasus-large" ) def lowercase ( self : Union[str, Any] , **snake_case_ : Union[str, Any] ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Tuple , snake_case_ : Any ): return ("This is a test", "This is a test") def lowercase ( self : Optional[int] ): _UpperCAmelCase = "</s>" _UpperCAmelCase = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_ ) , snake_case_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_ ) , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , "<pad>" ) self.assertEqual(vocab_keys[1] , "</s>" ) self.assertEqual(vocab_keys[-1] , "v" ) self.assertEqual(len(snake_case_ ) , 1_1_0_3 ) def lowercase ( self : Any ): self.assertEqual(self.get_tokenizer().vocab_size , 1_1_0_3 ) def lowercase ( self : List[Any] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important" " </s> <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Tuple ): _UpperCAmelCase = self._large_tokenizer # <mask_1> masks whole sentence while <mask_2> masks single word _UpperCAmelCase = "<mask_1> To ensure a <mask_2> flow of bank resolutions." _UpperCAmelCase = [2, 4_1_3, 6_1_5, 1_1_4, 3, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self._large_tokenizer # The tracebacks for the following asserts are **better** without messages or self.assertEqual assert tokenizer.vocab_size == 9_6_1_0_3 assert tokenizer.pad_token_id == 0 assert tokenizer.eos_token_id == 1 assert tokenizer.offset == 1_0_3 assert tokenizer.unk_token_id == tokenizer.offset + 2 == 1_0_5 assert tokenizer.unk_token == "<unk>" assert tokenizer.model_max_length == 1_0_2_4 _UpperCAmelCase = "To ensure a smooth flow of bank resolutions." _UpperCAmelCase = [4_1_3, 6_1_5, 1_1_4, 2_2_9_1, 1_9_7_1, 1_1_3, 1_6_7_9, 1_0_7_1_0, 1_0_7, 1] _UpperCAmelCase = tokenizer([raw_input_str] , return_tensors=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3] ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"] @require_torch def lowercase ( self : int ): _UpperCAmelCase = ["This is going to be way too long." * 1_5_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 1_0_2_4) assert batch.attention_mask.shape == (2, 1_0_2_4) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. @slow def lowercase ( self : Dict ): # fmt: off _UpperCAmelCase = {"input_ids": [[3_8_9_7_9, 1_4_3, 1_8_4_8_5, 6_0_6, 1_3_0, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 5_4_1_8_9, 1_1_2_9, 1_1_1, 2_6_6_6_9, 8_7_6_8_6, 1_2_1, 9_1_1_4, 1_4_7_8_7, 1_2_1, 1_3_2_4_9, 1_5_8, 5_9_2, 9_5_6, 1_2_1, 1_4_6_2_1, 3_1_5_7_6, 1_4_3, 6_2_6_1_3, 1_0_8, 9_6_8_8, 9_3_0, 4_3_4_3_0, 1_1_5_6_2, 6_2_6_1_3, 3_0_4, 1_0_8, 1_1_4_4_3, 8_9_7, 1_0_8, 9_3_1_4, 1_7_4_1_5, 6_3_3_9_9, 1_0_8, 1_1_4_4_3, 7_6_1_4, 1_8_3_1_6, 1_1_8, 4_2_8_4, 7_1_4_8, 1_2_4_3_0, 1_4_3, 1_4_0_0, 2_5_7_0_3, 1_5_8, 1_1_1, 4_2_8_4, 7_1_4_8, 1_1_7_7_2, 1_4_3, 2_1_2_9_7, 1_0_6_4, 1_5_8, 1_2_2, 2_0_4, 3_5_0_6, 1_7_5_4, 1_1_3_3, 1_4_7_8_7, 1_5_8_1, 1_1_5, 3_3_2_2_4, 4_4_8_2, 1_1_1, 1_3_5_5, 1_1_0, 2_9_1_7_3, 3_1_7, 5_0_8_3_3, 1_0_8, 2_0_1_4_7, 9_4_6_6_5, 1_1_1, 7_7_1_9_8, 1_0_7, 1], [1_1_0, 6_2_6_1_3, 1_1_7, 6_3_8, 1_1_2, 1_1_3_3, 1_2_1, 2_0_0_9_8, 1_3_5_5, 7_9_0_5_0, 1_3_8_7_2, 1_3_5, 1_5_9_6, 5_3_5_4_1, 1_3_5_2, 1_4_1, 1_3_0_3_9, 5_5_4_2, 1_2_4, 3_0_2, 5_1_8, 1_1_1, 2_6_8, 2_9_5_6, 1_1_5, 1_4_9, 4_4_2_7, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_3_9, 1_2_3_5, 2_7_9_9, 1_8_2_8_9, 1_7_7_8_0, 2_0_4, 1_0_9, 9_4_7_4, 1_2_9_6, 1_0_7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=snake_case_ , model_name="google/bigbird-pegasus-large-arxiv" , revision="ba85d0851d708441f91440d509690f1ab6353415" , ) @require_sentencepiece @require_tokenizers class A_ ( lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[str] = PegasusTokenizer _lowerCamelCase : List[Any] = PegasusTokenizerFast _lowerCamelCase : int = True _lowerCamelCase : Union[str, Any] = True def lowercase ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing _UpperCAmelCase = PegasusTokenizer(snake_case_ , offset=0 , mask_token_sent=snake_case_ , mask_token="[MASK]" ) tokenizer.save_pretrained(self.tmpdirname ) @cached_property def lowercase ( self : Tuple ): return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv" ) def lowercase ( self : Optional[Any] , **snake_case_ : Dict ): return PegasusTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : str ): return ("This is a test", "This is a test") def lowercase ( self : List[str] ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(self.tmpdirname ) _UpperCAmelCase = ( "Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>" " <pad> <pad> <pad>" ) _UpperCAmelCase = rust_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] _UpperCAmelCase = py_tokenizer([raw_input_str] , return_tensors=snake_case_ , add_special_tokens=snake_case_ ).input_ids[0] self.assertListEqual(snake_case_ , snake_case_ ) @require_torch def lowercase ( self : Tuple ): _UpperCAmelCase = ["This is going to be way too long." * 1_0_0_0, "short example"] _UpperCAmelCase = ["not super long but more than 5 tokens", "tiny"] _UpperCAmelCase = self._large_tokenizer(snake_case_ , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) _UpperCAmelCase = self._large_tokenizer( text_target=snake_case_ , max_length=5 , padding=snake_case_ , truncation=snake_case_ , return_tensors="pt" ) assert batch.input_ids.shape == (2, 4_0_9_6) assert batch.attention_mask.shape == (2, 4_0_9_6) assert targets["input_ids"].shape == (2, 5) assert len(snake_case_ ) == 2 # input_ids, attention_mask. def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = ( "This is an example string that is used to test the original TF implementation against the HF" " implementation" ) _UpperCAmelCase = self._large_tokenizer(snake_case_ ).input_ids self.assertListEqual( snake_case_ , [1_8_2, 1_1_7, 1_4_2, 5_8_7, 4_2_1_1, 1_2_0, 1_1_7, 2_6_3, 1_1_2, 8_0_4, 1_0_9, 8_5_6, 2_5_0_1_6, 3_1_3_7, 4_6_4, 1_0_9, 2_6_9_5_5, 3_1_3_7, 1] , )
22
1
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
'''simple docstring''' import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class A_ ( unittest.TestCase ): def lowercase ( self : int ): _UpperCAmelCase = tempfile.mkdtemp() _UpperCAmelCase = BlipImageProcessor() _UpperCAmelCase = BertTokenizer.from_pretrained("hf-internal-testing/tiny-random-BertModel" ) _UpperCAmelCase = BlipProcessor(snake_case_ , snake_case_ ) processor.save_pretrained(self.tmpdirname ) def lowercase ( self : Tuple , **snake_case_ : int ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).tokenizer def lowercase ( self : Dict , **snake_case_ : Any ): return AutoProcessor.from_pretrained(self.tmpdirname , **snake_case_ ).image_processor def lowercase ( self : int ): shutil.rmtree(self.tmpdirname ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = [np.random.randint(2_5_5 , size=(3, 3_0, 4_0_0) , dtype=np.uinta )] _UpperCAmelCase = [Image.fromarray(np.moveaxis(snake_case_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def lowercase ( self : int ): _UpperCAmelCase = BlipProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) _UpperCAmelCase = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) _UpperCAmelCase = self.get_image_processor(do_normalize=snake_case_ , padding_value=1.0 ) _UpperCAmelCase = BlipProcessor.from_pretrained( self.tmpdirname , bos_token="(BOS)" , eos_token="(EOS)" , do_normalize=snake_case_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , snake_case_ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="np" ) _UpperCAmelCase = processor(images=snake_case_ , return_tensors="np" ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum() , input_processor[key].sum() , delta=1e-2 ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = processor(text=snake_case_ ) _UpperCAmelCase = tokenizer(snake_case_ , return_token_type_ids=snake_case_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] ) # test if it raises when no input is passed with pytest.raises(snake_case_ ): processor() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] _UpperCAmelCase = processor.batch_decode(snake_case_ ) _UpperCAmelCase = tokenizer.batch_decode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) def lowercase ( self : str ): _UpperCAmelCase = self.get_image_processor() _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = BlipProcessor(tokenizer=snake_case_ , image_processor=snake_case_ ) _UpperCAmelCase = "lower newer" _UpperCAmelCase = self.prepare_image_inputs() _UpperCAmelCase = processor(text=snake_case_ , images=snake_case_ ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["pixel_values", "input_ids", "attention_mask"] )
22
1
'''simple docstring''' import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Tuple = { '''asapp/sew-d-tiny-100k''': '''https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json''', # See all SEW-D models at https://huggingface.co/models?filter=sew-d } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : List[str] = """sew-d""" def __init__( self : Optional[Any] , snake_case_ : Tuple=3_2 , snake_case_ : Optional[Any]=7_6_8 , snake_case_ : Tuple=1_2 , snake_case_ : Union[str, Any]=1_2 , snake_case_ : Tuple=3_0_7_2 , snake_case_ : Tuple=2 , snake_case_ : int=5_1_2 , snake_case_ : Optional[int]=2_5_6 , snake_case_ : Union[str, Any]=True , snake_case_ : Any=True , snake_case_ : str=("p2c", "c2p") , snake_case_ : Dict="layer_norm" , snake_case_ : str="gelu_python" , snake_case_ : Dict=0.1 , snake_case_ : List[str]=0.1 , snake_case_ : Tuple=0.1 , snake_case_ : Any=0.0 , snake_case_ : Tuple=0.1 , snake_case_ : Union[str, Any]=0.0_2 , snake_case_ : str=1e-7 , snake_case_ : Optional[Any]=1e-5 , snake_case_ : Optional[Any]="group" , snake_case_ : Tuple="gelu" , snake_case_ : Tuple=(6_4, 1_2_8, 1_2_8, 1_2_8, 1_2_8, 2_5_6, 2_5_6, 2_5_6, 2_5_6, 5_1_2, 5_1_2, 5_1_2, 5_1_2) , snake_case_ : Dict=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) , snake_case_ : Dict=(1_0, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) , snake_case_ : int=False , snake_case_ : Union[str, Any]=1_2_8 , snake_case_ : int=1_6 , snake_case_ : Any=True , snake_case_ : Tuple=0.0_5 , snake_case_ : Tuple=1_0 , snake_case_ : Dict=2 , snake_case_ : Tuple=0.0 , snake_case_ : List[Any]=1_0 , snake_case_ : Union[str, Any]=0 , snake_case_ : Any="mean" , snake_case_ : Optional[Any]=False , snake_case_ : Any=False , snake_case_ : Tuple=2_5_6 , snake_case_ : int=0 , snake_case_ : Optional[Any]=1 , snake_case_ : List[str]=2 , **snake_case_ : List[str] , ): super().__init__(**snake_case_ , pad_token_id=snake_case_ , bos_token_id=snake_case_ , eos_token_id=snake_case_ ) _UpperCAmelCase = hidden_size _UpperCAmelCase = feat_extract_norm _UpperCAmelCase = feat_extract_activation _UpperCAmelCase = list(snake_case_ ) _UpperCAmelCase = list(snake_case_ ) _UpperCAmelCase = list(snake_case_ ) _UpperCAmelCase = conv_bias _UpperCAmelCase = num_conv_pos_embeddings _UpperCAmelCase = num_conv_pos_embedding_groups _UpperCAmelCase = len(self.conv_dim ) _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = intermediate_size _UpperCAmelCase = squeeze_factor _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = position_buckets _UpperCAmelCase = share_att_key _UpperCAmelCase = relative_attention _UpperCAmelCase = norm_rel_ebd _UpperCAmelCase = list(snake_case_ ) _UpperCAmelCase = hidden_act _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_dropout _UpperCAmelCase = attention_dropout _UpperCAmelCase = activation_dropout _UpperCAmelCase = feat_proj_dropout _UpperCAmelCase = final_dropout _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = feature_layer_norm_eps _UpperCAmelCase = initializer_range _UpperCAmelCase = vocab_size if ( (len(self.conv_stride ) != self.num_feat_extract_layers) or (len(self.conv_kernel ) != self.num_feat_extract_layers) or (len(self.conv_dim ) != self.num_feat_extract_layers) ): raise ValueError( "Configuration for convolutional layers is incorrect." "It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`," f'but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)' f'= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.' ) # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 _UpperCAmelCase = apply_spec_augment _UpperCAmelCase = mask_time_prob _UpperCAmelCase = mask_time_length _UpperCAmelCase = mask_time_min_masks _UpperCAmelCase = mask_feature_prob _UpperCAmelCase = mask_feature_length _UpperCAmelCase = mask_feature_min_masks # ctc loss _UpperCAmelCase = ctc_loss_reduction _UpperCAmelCase = ctc_zero_infinity # sequence classification _UpperCAmelCase = use_weighted_layer_sum _UpperCAmelCase = classifier_proj_size @property def lowercase ( self : Any ): return functools.reduce(operator.mul , self.conv_stride , 1 )
22
'''simple docstring''' import inspect from typing import List, Optional, Tuple, Union import numpy as np import PIL import torch import torch.utils.checkpoint from ...models import UNetaDModel, VQModel from ...schedulers import ( DDIMScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, ) from ...utils import PIL_INTERPOLATION, randn_tensor from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput def UpperCAmelCase_ ( __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase , _UpperCAmelCase = image.size _UpperCAmelCase , _UpperCAmelCase = (x - x % 32 for x in (w, h)) # resize to integer multiple of 32 _UpperCAmelCase = image.resize((w, h) , resample=PIL_INTERPOLATION["lanczos"] ) _UpperCAmelCase = np.array(__lowercase ).astype(np.floataa ) / 255.0 _UpperCAmelCase = image[None].transpose(0 , 3 , 1 , 2 ) _UpperCAmelCase = torch.from_numpy(__lowercase ) return 2.0 * image - 1.0 class A_ ( lowerCAmelCase_ ): def __init__( self : Optional[Any] , snake_case_ : VQModel , snake_case_ : UNetaDModel , snake_case_ : Union[ DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler, EulerDiscreteScheduler, EulerAncestralDiscreteScheduler, DPMSolverMultistepScheduler, ] , ): super().__init__() self.register_modules(vqvae=snake_case_ , unet=snake_case_ , scheduler=snake_case_ ) @torch.no_grad() def __call__( self : Any , snake_case_ : Union[torch.Tensor, PIL.Image.Image] = None , snake_case_ : Optional[int] = 1 , snake_case_ : Optional[int] = 1_0_0 , snake_case_ : Optional[float] = 0.0 , snake_case_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , snake_case_ : Optional[str] = "pil" , snake_case_ : bool = True , ): if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = 1 elif isinstance(snake_case_ , torch.Tensor ): _UpperCAmelCase = image.shape[0] else: raise ValueError(f'`image` has to be of type `PIL.Image.Image` or `torch.Tensor` but is {type(snake_case_ )}' ) if isinstance(snake_case_ , PIL.Image.Image ): _UpperCAmelCase = preprocess(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = image.shape[-2:] # in_channels should be 6: 3 for latents, 3 for low resolution image _UpperCAmelCase = (batch_size, self.unet.config.in_channels // 2, height, width) _UpperCAmelCase = next(self.unet.parameters() ).dtype _UpperCAmelCase = randn_tensor(snake_case_ , generator=snake_case_ , device=self.device , dtype=snake_case_ ) _UpperCAmelCase = image.to(device=self.device , dtype=snake_case_ ) # set timesteps and move to the correct device self.scheduler.set_timesteps(snake_case_ , device=self.device ) _UpperCAmelCase = self.scheduler.timesteps # scale the initial noise by the standard deviation required by the scheduler _UpperCAmelCase = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature. # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _UpperCAmelCase = "eta" in set(inspect.signature(self.scheduler.step ).parameters.keys() ) _UpperCAmelCase = {} if accepts_eta: _UpperCAmelCase = eta for t in self.progress_bar(snake_case_ ): # concat latents and low resolution image in the channel dimension. _UpperCAmelCase = torch.cat([latents, image] , dim=1 ) _UpperCAmelCase = self.scheduler.scale_model_input(snake_case_ , snake_case_ ) # predict the noise residual _UpperCAmelCase = self.unet(snake_case_ , snake_case_ ).sample # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase = self.scheduler.step(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ).prev_sample # decode the image latents with the VQVAE _UpperCAmelCase = self.vqvae.decode(snake_case_ ).sample _UpperCAmelCase = torch.clamp(snake_case_ , -1.0 , 1.0 ) _UpperCAmelCase = image / 2 + 0.5 _UpperCAmelCase = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": _UpperCAmelCase = self.numpy_to_pil(snake_case_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=snake_case_ )
22
1
'''simple docstring''' import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class A_ ( tf.keras.layers.Layer ): def __init__( self : Tuple , snake_case_ : Dict[str, int] , snake_case_ : List[str] , snake_case_ : int = None , snake_case_ : int = None ): super().__init__() _UpperCAmelCase = pad_token_id _UpperCAmelCase = max_length _UpperCAmelCase = vocab _UpperCAmelCase = merges _UpperCAmelCase = BytePairTokenizer(snake_case_ , snake_case_ , sequence_length=snake_case_ ) @classmethod def lowercase ( cls : Optional[int] , snake_case_ : GPTaTokenizer , *snake_case_ : List[Any] , **snake_case_ : Any ): _UpperCAmelCase = [" ".join(snake_case_ ) for m in tokenizer.bpe_ranks.keys()] _UpperCAmelCase = tokenizer.get_vocab() return cls(snake_case_ , snake_case_ , *snake_case_ , **snake_case_ ) @classmethod def lowercase ( cls : Optional[int] , snake_case_ : Union[str, os.PathLike] , *snake_case_ : Union[str, Any] , **snake_case_ : List[Any] ): _UpperCAmelCase = GPTaTokenizer.from_pretrained(snake_case_ , *snake_case_ , **snake_case_ ) return cls.from_tokenizer(snake_case_ , *snake_case_ , **snake_case_ ) @classmethod def lowercase ( cls : int , snake_case_ : List[Any] ): return cls(**snake_case_ ) def lowercase ( self : str ): return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def lowercase ( self : List[str] , snake_case_ : Union[str, Any] , snake_case_ : int = None ): _UpperCAmelCase = self.tf_tokenizer(snake_case_ ) _UpperCAmelCase = tf.ones_like(snake_case_ ) if self.pad_token_id is not None: # pad the tokens up to max length _UpperCAmelCase = max_length if max_length is not None else self.max_length if max_length is not None: _UpperCAmelCase , _UpperCAmelCase = pad_model_inputs( snake_case_ , max_seq_length=snake_case_ , pad_value=self.pad_token_id ) return {"attention_mask": attention_mask, "input_ids": input_ids}
22
'''simple docstring''' import string from math import logaa def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> int: '''simple docstring''' _UpperCAmelCase = document.translate( str.maketrans("" , "" , string.punctuation ) ).replace("\n" , "" ) _UpperCAmelCase = document_without_punctuation.split(" " ) # word tokenization return len([word for word in tokenize_document if word.lower() == term.lower()] ) def UpperCAmelCase_ ( __lowercase : str , __lowercase : str ) -> tuple[int, int]: '''simple docstring''' _UpperCAmelCase = corpus.lower().translate( str.maketrans("" , "" , string.punctuation ) ) # strip all punctuation and replace it with '' _UpperCAmelCase = corpus_without_punctuation.split("\n" ) _UpperCAmelCase = term.lower() return (len([doc for doc in docs if term in doc] ), len(__lowercase )) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int , __lowercase : Union[str, Any]=False ) -> float: '''simple docstring''' if smoothing: if n == 0: raise ValueError("log10(0) is undefined." ) return round(1 + logaa(n / (1 + df) ) , 3 ) if df == 0: raise ZeroDivisionError("df must be > 0" ) elif n == 0: raise ValueError("log10(0) is undefined." ) return round(logaa(n / df ) , 3 ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : int ) -> float: '''simple docstring''' return round(tf * idf , 3 )
22
1
'''simple docstring''' import math class A_ : def __init__( self : Dict , snake_case_ : int=0 ): # a graph with Node 0,1,...,N-1 _UpperCAmelCase = n _UpperCAmelCase = [ [math.inf for j in range(0 , snake_case_ )] for i in range(0 , snake_case_ ) ] # adjacency matrix for weight _UpperCAmelCase = [ [math.inf for j in range(0 , snake_case_ )] for i in range(0 , snake_case_ ) ] # dp[i][j] stores minimum distance from i to j def lowercase ( self : Union[str, Any] , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = w def lowercase ( self : Union[str, Any] ): for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): _UpperCAmelCase = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def lowercase ( self : List[str] , snake_case_ : List[Any] , snake_case_ : List[Any] ): return self.dp[u][v] if __name__ == "__main__": __SCREAMING_SNAKE_CASE :Dict = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
22
'''simple docstring''' from ..utils import ( OptionalDependencyNotAvailable, is_flax_available, is_scipy_available, is_torch_available, is_torchsde_available, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_pt_objects import * # noqa F403 else: from .scheduling_consistency_models import CMStochasticIterativeScheduler from .scheduling_ddim import DDIMScheduler from .scheduling_ddim_inverse import DDIMInverseScheduler from .scheduling_ddim_parallel import DDIMParallelScheduler from .scheduling_ddpm import DDPMScheduler from .scheduling_ddpm_parallel import DDPMParallelScheduler from .scheduling_deis_multistep import DEISMultistepScheduler from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler from .scheduling_euler_discrete import EulerDiscreteScheduler from .scheduling_heun_discrete import HeunDiscreteScheduler from .scheduling_ipndm import IPNDMScheduler from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler from .scheduling_karras_ve import KarrasVeScheduler from .scheduling_pndm import PNDMScheduler from .scheduling_repaint import RePaintScheduler from .scheduling_sde_ve import ScoreSdeVeScheduler from .scheduling_sde_vp import ScoreSdeVpScheduler from .scheduling_unclip import UnCLIPScheduler from .scheduling_unipc_multistep import UniPCMultistepScheduler from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin from .scheduling_vq_diffusion import VQDiffusionScheduler try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_flax_objects import * # noqa F403 else: from .scheduling_ddim_flax import FlaxDDIMScheduler from .scheduling_ddpm_flax import FlaxDDPMScheduler from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler from .scheduling_pndm_flax import FlaxPNDMScheduler from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler from .scheduling_utils_flax import ( FlaxKarrasDiffusionSchedulers, FlaxSchedulerMixin, FlaxSchedulerOutput, broadcast_to_shape_from_left, ) try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .scheduling_lms_discrete import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ..utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler
22
1
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
'''simple docstring''' def UpperCAmelCase_ ( __lowercase : int ) -> int: '''simple docstring''' if not isinstance(__lowercase , __lowercase ) or number < 0: raise ValueError("Input must be a non-negative integer" ) _UpperCAmelCase = 0 while number: # This way we arrive at next set bit (next 1) instead of looping # through each bit and checking for 1s hence the # loop won't run 32 times it will only run the number of `1` times number &= number - 1 count += 1 return count if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' __SCREAMING_SNAKE_CASE :Dict = { 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_ ( __lowercase : float ) -> str: '''simple docstring''' assert type(__lowercase ) in (int, float) and decimal == int(__lowercase ) _UpperCAmelCase = int(__lowercase ) _UpperCAmelCase = "" _UpperCAmelCase = False if decimal < 0: _UpperCAmelCase = True decimal *= -1 while decimal > 0: _UpperCAmelCase , _UpperCAmelCase = divmod(__lowercase , 16 ) _UpperCAmelCase = values[remainder] + hexadecimal _UpperCAmelCase = "0x" + hexadecimal if negative: _UpperCAmelCase = "-" + hexadecimal return hexadecimal if __name__ == "__main__": import doctest doctest.testmod()
22
'''simple docstring''' from __future__ import annotations from collections.abc import Callable from typing import Any, Generic, TypeVar __SCREAMING_SNAKE_CASE :Optional[int] = TypeVar('''T''') class A_ ( Generic[T] ): def __init__( self : List[Any] , snake_case_ : list[T] , snake_case_ : Callable[[T, T], T] ): _UpperCAmelCase = None _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = [any_type for _ in range(self.N )] + arr _UpperCAmelCase = fnc self.build() def lowercase ( self : List[Any] ): for p in range(self.N - 1 , 0 , -1 ): _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : T ): p += self.N _UpperCAmelCase = v while p > 1: _UpperCAmelCase = p // 2 _UpperCAmelCase = self.fn(self.st[p * 2] , self.st[p * 2 + 1] ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : int ): # noqa: E741 _UpperCAmelCase , _UpperCAmelCase = l + self.N, r + self.N _UpperCAmelCase = None while l <= r: if l % 2 == 1: _UpperCAmelCase = self.st[l] if res is None else self.fn(snake_case_ , self.st[l] ) if r % 2 == 0: _UpperCAmelCase = self.st[r] if res is None else self.fn(snake_case_ , self.st[r] ) _UpperCAmelCase , _UpperCAmelCase = (l + 1) // 2, (r - 1) // 2 return res if __name__ == "__main__": from functools import reduce __SCREAMING_SNAKE_CASE :Union[str, Any] = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12] __SCREAMING_SNAKE_CASE :List[str] = { 0: 7, 1: 2, 2: 6, 3: -14, 4: 5, 5: 4, 6: 7, 7: -10, 8: 9, 9: 10, 10: 12, 11: 1, } __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, min) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, max) __SCREAMING_SNAKE_CASE :Any = SegmentTree(test_array, lambda a, b: a + b) def UpperCAmelCase_ ( ) -> None: '''simple docstring''' for i in range(len(__lowercase ) ): for j in range(__lowercase , len(__lowercase ) ): _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(__lowercase , test_array[i : j + 1] ) _UpperCAmelCase = reduce(lambda __lowercase , __lowercase : a + b , test_array[i : j + 1] ) assert min_range == min_segment_tree.query(__lowercase , __lowercase ) assert max_range == max_segment_tree.query(__lowercase , __lowercase ) assert sum_range == sum_segment_tree.query(__lowercase , __lowercase ) test_all_segments() for index, value in test_updates.items(): __SCREAMING_SNAKE_CASE :str = value min_segment_tree.update(index, value) max_segment_tree.update(index, value) sum_segment_tree.update(index, value) test_all_segments()
22
1
'''simple docstring''' from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class A_ : def lowercase ( self : str , snake_case_ : int ): raise NotImplementedError() def lowercase ( self : Any ): raise NotImplementedError() class A_ ( lowerCAmelCase_ ): def __init__( self : str , snake_case_ : "AutoTokenizer" , snake_case_ : bool = False , **snake_case_ : Tuple ): _UpperCAmelCase = tokenizer _UpperCAmelCase = skip_prompt _UpperCAmelCase = decode_kwargs # variables used in the streaming process _UpperCAmelCase = [] _UpperCAmelCase = 0 _UpperCAmelCase = True def lowercase ( self : Tuple , snake_case_ : List[str] ): if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError("TextStreamer only supports batch size 1" ) elif len(value.shape ) > 1: _UpperCAmelCase = value[0] if self.skip_prompt and self.next_tokens_are_prompt: _UpperCAmelCase = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) _UpperCAmelCase = self.tokenizer.decode(self.token_cache , **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith("\n" ): _UpperCAmelCase = text[self.print_len :] _UpperCAmelCase = [] _UpperCAmelCase = 0 # If the last token is a CJK character, we print the characters. elif len(snake_case_ ) > 0 and self._is_chinese_char(ord(text[-1] ) ): _UpperCAmelCase = text[self.print_len :] self.print_len += len(snake_case_ ) # Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words, # which may change with the subsequent token -- there are probably smarter ways to do this!) else: _UpperCAmelCase = text[self.print_len : text.rfind(" " ) + 1] self.print_len += len(snake_case_ ) self.on_finalized_text(snake_case_ ) def lowercase ( self : Optional[int] ): # Flush the cache, if it exists if len(self.token_cache ) > 0: _UpperCAmelCase = self.tokenizer.decode(self.token_cache , **self.decode_kwargs ) _UpperCAmelCase = text[self.print_len :] _UpperCAmelCase = [] _UpperCAmelCase = 0 else: _UpperCAmelCase = "" _UpperCAmelCase = True self.on_finalized_text(snake_case_ , stream_end=snake_case_ ) def lowercase ( self : Any , snake_case_ : str , snake_case_ : bool = False ): print(snake_case_ , flush=snake_case_ , end="" if not stream_end else None ) def lowercase ( self : Optional[Any] , snake_case_ : Tuple ): # This defines a "chinese character" as anything in the CJK Unicode block: # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) # # Note that the CJK Unicode block is NOT all Japanese and Korean characters, # despite its name. The modern Korean Hangul alphabet is a different block, # as is Japanese Hiragana and Katakana. Those alphabets are used to write # space-separated words, so they are not treated specially and handled # like the all of the other languages. if ( (cp >= 0X4e_00 and cp <= 0X9f_ff) or (cp >= 0X34_00 and cp <= 0X4d_bf) # or (cp >= 0X2_00_00 and cp <= 0X2_a6_df) # or (cp >= 0X2_a7_00 and cp <= 0X2_b7_3f) # or (cp >= 0X2_b7_40 and cp <= 0X2_b8_1f) # or (cp >= 0X2_b8_20 and cp <= 0X2_ce_af) # or (cp >= 0Xf9_00 and cp <= 0Xfa_ff) or (cp >= 0X2_f8_00 and cp <= 0X2_fa_1f) # ): # return True return False class A_ ( lowerCAmelCase_ ): def __init__( self : List[Any] , snake_case_ : "AutoTokenizer" , snake_case_ : bool = False , snake_case_ : Optional[float] = None , **snake_case_ : Union[str, Any] ): super().__init__(snake_case_ , snake_case_ , **snake_case_ ) _UpperCAmelCase = Queue() _UpperCAmelCase = None _UpperCAmelCase = timeout def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : bool = False ): self.text_queue.put(snake_case_ , timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal , timeout=self.timeout ) def __iter__( self : str ): return self def lowercase ( self : Any ): _UpperCAmelCase = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
22
'''simple docstring''' import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( "kwargs, expected" , [ ({"num_shards": 0, "max_num_jobs": 1}, []), ({"num_shards": 10, "max_num_jobs": 1}, [range(10 )]), ({"num_shards": 10, "max_num_jobs": 10}, [range(__lowercase , i + 1 ) for i in range(10 )]), ({"num_shards": 1, "max_num_jobs": 10}, [range(1 )]), ({"num_shards": 10, "max_num_jobs": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"num_shards": 3, "max_num_jobs": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict ) -> List[Any]: '''simple docstring''' _UpperCAmelCase = _distribute_shards(**__lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, max_num_jobs, expected" , [ ({"foo": 0}, 10, [{"foo": 0}]), ({"shards": [0, 1, 2, 3]}, 1, [{"shards": [0, 1, 2, 3]}]), ({"shards": [0, 1, 2, 3]}, 4, [{"shards": [0]}, {"shards": [1]}, {"shards": [2]}, {"shards": [3]}]), ({"shards": [0, 1]}, 4, [{"shards": [0]}, {"shards": [1]}]), ({"shards": [0, 1, 2, 3]}, 2, [{"shards": [0, 1]}, {"shards": [2, 3]}]), ] , ) def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[Any] , __lowercase : int ) -> str: '''simple docstring''' _UpperCAmelCase = _split_gen_kwargs(__lowercase , __lowercase ) assert out == expected @pytest.mark.parametrize( "gen_kwargs, expected" , [ ({"foo": 0}, 1), ({"shards": [0]}, 1), ({"shards": [0, 1, 2, 3]}, 4), ({"shards": [0, 1, 2, 3], "foo": 0}, 4), ({"shards": [0, 1, 2, 3], "other": (0, 1)}, 4), ({"shards": [0, 1, 2, 3], "shards2": [0, 1]}, RuntimeError), ] , ) def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : List[Any] ) -> List[Any]: '''simple docstring''' if expected is RuntimeError: with pytest.raises(__lowercase ): _number_of_shards_in_gen_kwargs(__lowercase ) else: _UpperCAmelCase = _number_of_shards_in_gen_kwargs(__lowercase ) assert out == expected
22
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __SCREAMING_SNAKE_CASE :Optional[Any] = { '''configuration_timesformer''': ['''TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TimesformerConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __SCREAMING_SNAKE_CASE :str = [ '''TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TimesformerModel''', '''TimesformerForVideoClassification''', '''TimesformerPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_timesformer import ( TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TimesformerForVideoClassification, TimesformerModel, TimesformerPreTrainedModel, ) else: import sys __SCREAMING_SNAKE_CASE :Optional[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
22
'''simple docstring''' import math def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' return math.sqrt(__lowercase ) * math.sqrt(__lowercase ) == num def UpperCAmelCase_ ( __lowercase : int ) -> bool: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = n while left <= right: _UpperCAmelCase = (left + right) // 2 if mid**2 == n: return True elif mid**2 > n: _UpperCAmelCase = mid - 1 else: _UpperCAmelCase = mid + 1 return False if __name__ == "__main__": import doctest doctest.testmod()
22
1
'''simple docstring''' import copy import os from typing import TYPE_CHECKING, List, Union if TYPE_CHECKING: pass from ...configuration_utils import PretrainedConfig from ...utils import logging __SCREAMING_SNAKE_CASE :List[Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''kakaobrain/align-base''': '''https://huggingface.co/kakaobrain/align-base/resolve/main/config.json''', } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """align_text_model""" def __init__( self : str , snake_case_ : Any=3_0_5_2_2 , snake_case_ : Dict=7_6_8 , snake_case_ : Union[str, Any]=1_2 , snake_case_ : Dict=1_2 , snake_case_ : Optional[int]=3_0_7_2 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[str]=0.1 , snake_case_ : Tuple=0.1 , snake_case_ : Dict=5_1_2 , snake_case_ : Optional[Any]=2 , snake_case_ : int=0.0_2 , snake_case_ : Dict=1e-12 , snake_case_ : List[Any]=0 , snake_case_ : Optional[Any]="absolute" , snake_case_ : Dict=True , **snake_case_ : Dict , ): super().__init__(**snake_case_ ) _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = position_embedding_type _UpperCAmelCase = use_cache _UpperCAmelCase = pad_token_id @classmethod def lowercase ( cls : Optional[int] , snake_case_ : Union[str, os.PathLike] , **snake_case_ : Optional[int] ): cls._set_token_in_kwargs(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = cls.get_config_dict(snake_case_ , **snake_case_ ) # get the text config dict if we are loading from AlignConfig if config_dict.get("model_type" ) == "align": _UpperCAmelCase = config_dict["text_config"] if "model_type" in config_dict and hasattr(cls , "model_type" ) and config_dict["model_type"] != cls.model_type: logger.warning( f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type ' f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.' ) return cls.from_dict(snake_case_ , **snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """align_vision_model""" def __init__( self : int , snake_case_ : int = 3 , snake_case_ : int = 6_0_0 , snake_case_ : float = 2.0 , snake_case_ : float = 3.1 , snake_case_ : int = 8 , snake_case_ : List[int] = [3, 3, 5, 3, 5, 5, 3] , snake_case_ : List[int] = [3_2, 1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2] , snake_case_ : List[int] = [1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2, 3_2_0] , snake_case_ : List[int] = [] , snake_case_ : List[int] = [1, 2, 2, 2, 1, 2, 1] , snake_case_ : List[int] = [1, 2, 2, 3, 3, 4, 1] , snake_case_ : List[int] = [1, 6, 6, 6, 6, 6, 6] , snake_case_ : float = 0.2_5 , snake_case_ : str = "swish" , snake_case_ : int = 2_5_6_0 , snake_case_ : str = "mean" , snake_case_ : float = 0.0_2 , snake_case_ : float = 0.0_0_1 , snake_case_ : float = 0.9_9 , snake_case_ : float = 0.2 , **snake_case_ : Dict , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_channels _UpperCAmelCase = image_size _UpperCAmelCase = width_coefficient _UpperCAmelCase = depth_coefficient _UpperCAmelCase = depth_divisor _UpperCAmelCase = kernel_sizes _UpperCAmelCase = in_channels _UpperCAmelCase = out_channels _UpperCAmelCase = depthwise_padding _UpperCAmelCase = strides _UpperCAmelCase = num_block_repeats _UpperCAmelCase = expand_ratios _UpperCAmelCase = squeeze_expansion_ratio _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dim _UpperCAmelCase = pooling_type _UpperCAmelCase = initializer_range _UpperCAmelCase = batch_norm_eps _UpperCAmelCase = batch_norm_momentum _UpperCAmelCase = drop_connect_rate _UpperCAmelCase = sum(snake_case_ ) * 4 @classmethod def lowercase ( cls : int , snake_case_ : Union[str, os.PathLike] , **snake_case_ : Tuple ): cls._set_token_in_kwargs(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = cls.get_config_dict(snake_case_ , **snake_case_ ) # get the vision config dict if we are loading from AlignConfig if config_dict.get("model_type" ) == "align": _UpperCAmelCase = config_dict["vision_config"] if "model_type" in config_dict and hasattr(cls , "model_type" ) and config_dict["model_type"] != cls.model_type: logger.warning( f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type ' f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.' ) return cls.from_dict(snake_case_ , **snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """align""" _lowerCamelCase : Any = True def __init__( self : Tuple , snake_case_ : Dict=None , snake_case_ : Dict=None , snake_case_ : Tuple=6_4_0 , snake_case_ : List[str]=1.0 , snake_case_ : Dict=0.0_2 , **snake_case_ : Optional[int] , ): super().__init__(**snake_case_ ) if text_config is None: _UpperCAmelCase = {} logger.info("text_config is None. Initializing the AlignTextConfig with default values." ) if vision_config is None: _UpperCAmelCase = {} logger.info("vision_config is None. Initializing the AlignVisionConfig with default values." ) _UpperCAmelCase = AlignTextConfig(**snake_case_ ) _UpperCAmelCase = AlignVisionConfig(**snake_case_ ) _UpperCAmelCase = projection_dim _UpperCAmelCase = temperature_init_value _UpperCAmelCase = initializer_range @classmethod def lowercase ( cls : Optional[Any] , snake_case_ : AlignTextConfig , snake_case_ : AlignVisionConfig , **snake_case_ : Union[str, Any] ): return cls(text_config=text_config.to_dict() , vision_config=vision_config.to_dict() , **snake_case_ ) def lowercase ( self : List[Any] ): _UpperCAmelCase = copy.deepcopy(self.__dict__ ) _UpperCAmelCase = self.text_config.to_dict() _UpperCAmelCase = self.vision_config.to_dict() _UpperCAmelCase = self.__class__.model_type return output
22
'''simple docstring''' import inspect import tempfile import unittest from huggingface_hub import hf_hub_download from transformers import is_torch_available from transformers.testing_utils import is_flaky, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin __SCREAMING_SNAKE_CASE :Dict = 1e-4 if is_torch_available(): import torch from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder @require_torch class A_ : def __init__( self : List[Any] , snake_case_ : int , snake_case_ : Dict=1_6 , snake_case_ : Dict=1_3 , snake_case_ : int=7 , snake_case_ : Any=1_4 , snake_case_ : int=1_0 , snake_case_ : Any=1_9 , snake_case_ : int=5 , snake_case_ : Any=4 , snake_case_ : Tuple=True , snake_case_ : Optional[int]=1_6 , snake_case_ : List[str]=2 , snake_case_ : Any=4 , snake_case_ : List[Any]=4 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Optional[int]=0.1 , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Tuple=[1, 2, 3, 4, 5] , snake_case_ : str=2_5 , snake_case_ : Any=5 , ): _UpperCAmelCase = d_model _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = prediction_length _UpperCAmelCase = context_length _UpperCAmelCase = cardinality _UpperCAmelCase = num_time_features _UpperCAmelCase = lags_sequence _UpperCAmelCase = embedding_dimension _UpperCAmelCase = is_training _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = context_length _UpperCAmelCase = prediction_length + label_length _UpperCAmelCase = label_length _UpperCAmelCase = moving_average _UpperCAmelCase = autocorrelation_factor def lowercase ( self : Union[str, Any] ): return AutoformerConfig( d_model=self.d_model , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , prediction_length=self.prediction_length , context_length=self.context_length , label_length=self.label_length , lags_sequence=self.lags_sequence , num_time_features=self.num_time_features , num_static_categorical_features=1 , cardinality=[self.cardinality] , embedding_dimension=[self.embedding_dimension] , moving_average=self.moving_average , ) def lowercase ( self : int , snake_case_ : Optional[Any] ): _UpperCAmelCase = config.context_length + max(config.lags_sequence ) _UpperCAmelCase = ids_tensor([self.batch_size, 1] , config.cardinality[0] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) _UpperCAmelCase = floats_tensor([self.batch_size, _past_length] ) > 0.5 # decoder inputs _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length, config.num_time_features] ) _UpperCAmelCase = floats_tensor([self.batch_size, config.prediction_length] ) _UpperCAmelCase = { "past_values": past_values, "static_categorical_features": static_categorical_features, "past_time_features": past_time_features, "past_observed_mask": past_observed_mask, "future_time_features": future_time_features, "future_values": future_values, } return inputs_dict def lowercase ( self : List[Any] ): _UpperCAmelCase = self.get_config() _UpperCAmelCase = self.prepare_autoformer_inputs_dict(snake_case_ ) return config, inputs_dict def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def lowercase ( self : Optional[Any] , snake_case_ : int , snake_case_ : Optional[int] ): _UpperCAmelCase = AutoformerModel(config=snake_case_ ).to(snake_case_ ).eval() _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = outputs.encoder_last_hidden_state _UpperCAmelCase = outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_encoder() encoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerEncoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = model.create_network_inputs(**snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...] ) _UpperCAmelCase = torch.cat( (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...]) , dim=-1 , ) _UpperCAmelCase = encoder(inputs_embeds=snake_case_ )[0] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) _UpperCAmelCase = ( torch.mean(transformer_inputs[:, : config.context_length, ...] , dim=1 ) .unsqueeze(1 ) .repeat(1 , config.prediction_length , 1 ) ) _UpperCAmelCase = torch.zeros( [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]] , device=enc_input.device , ) _UpperCAmelCase = torch.cat( ( torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) _UpperCAmelCase = torch.cat( ( torch.cat((trend_input[:, -config.label_length :, ...], mean) , dim=1 ), feature[:, config.context_length - config.label_length :, ...], ) , dim=-1 , ) with tempfile.TemporaryDirectory() as tmpdirname: _UpperCAmelCase = model.get_decoder() decoder.save_pretrained(snake_case_ ) _UpperCAmelCase = AutoformerDecoder.from_pretrained(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = decoder( trend=snake_case_ , inputs_embeds=snake_case_ , encoder_hidden_states=snake_case_ , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : List[Any] = (AutoformerModel, AutoformerForPrediction) if is_torch_available() else () _lowerCamelCase : Tuple = (AutoformerForPrediction,) if is_torch_available() else () _lowerCamelCase : List[Any] = {"""feature-extraction""": AutoformerModel} if is_torch_available() else {} _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Tuple = False _lowerCamelCase : int = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Optional[Any] = False _lowerCamelCase : List[Any] = False def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(snake_case_ ) _UpperCAmelCase , _UpperCAmelCase = model_class.from_pretrained(snake_case_ , output_loading_info=snake_case_ ) self.assertEqual(info["missing_keys"] , [] ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*snake_case_ ) @unittest.skip(reason="Model has no tokens embeddings" ) def lowercase ( self : Optional[int] ): pass def lowercase ( self : Optional[int] ): _UpperCAmelCase = inspect.signature(getattr(snake_case_ , "forward" ) ) # The main input is the name of the argument after `self` _UpperCAmelCase = list(model_signature.parameters.keys() )[1] self.assertEqual(AutoformerModel.main_input_name , snake_case_ ) def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ "past_values", "past_time_features", "past_observed_mask", "static_categorical_features", "static_real_features", "future_values", "future_time_features", ] if model.__class__.__name__ in ["AutoformerForPrediction"]: expected_arg_names.append("future_observed_mask" ) expected_arg_names.extend( [ "decoder_attention_mask", "head_mask", "decoder_head_mask", "cross_attn_head_mask", "encoder_outputs", "past_key_values", "output_hidden_states", "output_attentions", "use_cache", "return_dict", ] ) self.assertListEqual(arg_names[: len(snake_case_ )] , snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True _UpperCAmelCase = getattr(self.model_tester , "seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "decoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "encoder_seq_length" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "d_model" , snake_case_ ) _UpperCAmelCase = getattr(self.model_tester , "num_attention_heads" , snake_case_ ) _UpperCAmelCase = d_model // num_attention_heads for model_class in self.all_model_classes: _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) _UpperCAmelCase = len(snake_case_ ) _UpperCAmelCase = 7 if "last_hidden_state" in outputs: correct_outlen += 1 if "trend" in outputs: correct_outlen += 1 if "past_key_values" in outputs: correct_outlen += 1 # past_key_values have been returned if "loss" in outputs: correct_outlen += 1 if "params" in outputs: correct_outlen += 1 self.assertEqual(snake_case_ , snake_case_ ) # decoder attentions _UpperCAmelCase = outputs.decoder_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(decoder_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # cross attentions _UpperCAmelCase = outputs.cross_attentions self.assertIsInstance(snake_case_ , (list, tuple) ) self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(cross_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, decoder_seq_length, dim] , ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) self.assertEqual(out_len + 2 , len(snake_case_ ) ) _UpperCAmelCase = outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions self.assertEqual(len(snake_case_ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, encoder_seq_length, dim] , ) @is_flaky() def lowercase ( self : Dict ): super().test_retain_grad_hidden_states_attentions() def UpperCAmelCase_ ( __lowercase : str="train-batch.pt" ) -> List[str]: '''simple docstring''' _UpperCAmelCase = hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" , filename=__lowercase , repo_type="dataset" ) _UpperCAmelCase = torch.load(__lowercase , map_location=__lowercase ) return batch @require_torch @slow class A_ ( unittest.TestCase ): def lowercase ( self : Optional[int] ): _UpperCAmelCase = AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch() with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , future_values=batch["future_values"] , future_time_features=batch["future_time_features"] , )[0] _UpperCAmelCase = torch.Size( (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model( past_values=batch["past_values"] , past_time_features=batch["past_time_features"] , past_observed_mask=batch["past_observed_mask"] , static_categorical_features=batch["static_categorical_features"] , ).encoder_last_hidden_state _UpperCAmelCase = torch.Size((6_4, model.config.context_length, model.config.d_model) ) self.assertEqual(output.shape , snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]] , device=snake_case_ ) self.assertTrue(torch.allclose(output[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly" ).to(snake_case_ ) _UpperCAmelCase = prepare_batch("val-batch.pt" ) with torch.no_grad(): _UpperCAmelCase = model.generate( static_categorical_features=batch["static_categorical_features"] , past_time_features=batch["past_time_features"] , past_values=batch["past_values"] , future_time_features=batch["future_time_features"] , past_observed_mask=batch["past_observed_mask"] , ) _UpperCAmelCase = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length) ) self.assertEqual(outputs.sequences.shape , snake_case_ ) _UpperCAmelCase = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6] , device=snake_case_ ) _UpperCAmelCase = outputs.sequences.mean(dim=1 ) self.assertTrue(torch.allclose(mean_prediction[0, -3:] , snake_case_ , rtol=1e-1 ) )
22
1
'''simple docstring''' import argparse import fairseq import torch from transformers import UniSpeechSatConfig, UniSpeechSatForCTC, UniSpeechSatForPreTraining, logging logging.set_verbosity_info() __SCREAMING_SNAKE_CASE :str = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Union[str, Any] = { '''post_extract_proj''': '''feature_projection.projection''', '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''', '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''', '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''', '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''', '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''', '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''', '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''', '''fc2''': '''encoder.layers.*.feed_forward.output_dense''', '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''', '''encoder.layer_norm''': '''encoder.layer_norm''', '''encoder.layer_norm_for_extract''': '''layer_norm_for_extract''', '''w2v_model.layer_norm''': '''feature_projection.layer_norm''', '''quantizer.weight_proj''': '''quantizer.weight_proj''', '''quantizer.vars''': '''quantizer.codevectors''', '''project_q''': '''project_q''', '''final_proj''': '''project_hid''', '''w2v_encoder.proj''': '''lm_head''', '''label_embs_concat''': '''label_embeddings_concat''', '''mask_emb''': '''masked_spec_embed''', '''spk_proj''': '''speaker_proj''', } __SCREAMING_SNAKE_CASE :int = [ '''lm_head''', '''quantizer.weight_proj''', '''quantizer.codevectors''', '''project_q''', '''project_hid''', '''label_embeddings_concat''', '''speaker_proj''', '''layer_norm_for_extract''', ] def UpperCAmelCase_ ( __lowercase : str , __lowercase : Any , __lowercase : int , __lowercase : Optional[int] , __lowercase : Union[str, Any] ) -> int: '''simple docstring''' for attribute in key.split("." ): _UpperCAmelCase = getattr(__lowercase , __lowercase ) if weight_type is not None: _UpperCAmelCase = getattr(__lowercase , __lowercase ).shape else: _UpperCAmelCase = hf_pointer.shape if hf_shape != value.shape: raise ValueError( f'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be' f' {value.shape} for {full_name}' ) if weight_type == "weight": _UpperCAmelCase = value elif weight_type == "weight_g": _UpperCAmelCase = value elif weight_type == "weight_v": _UpperCAmelCase = value elif weight_type == "bias": _UpperCAmelCase = value else: _UpperCAmelCase = value logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.' ) def UpperCAmelCase_ ( __lowercase : int , __lowercase : Optional[Any] ) -> List[str]: '''simple docstring''' _UpperCAmelCase = [] _UpperCAmelCase = fairseq_model.state_dict() _UpperCAmelCase = hf_model.unispeech_sat.feature_extractor for name, value in fairseq_dict.items(): _UpperCAmelCase = False if "conv_layers" in name: load_conv_layer( __lowercase , __lowercase , __lowercase , __lowercase , hf_model.config.feat_extract_norm == "group" , ) _UpperCAmelCase = True else: for key, mapped_key in MAPPING.items(): _UpperCAmelCase = "unispeech_sat." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if key in name or key.split("w2v_model." )[-1] == name.split("." )[0]: if "layer_norm_for_extract" in name and (".".join(name.split("." )[:-1] ) != key): # special case since naming is very similar continue _UpperCAmelCase = True if "*" in mapped_key: _UpperCAmelCase = name.split(__lowercase )[0].split("." )[-2] _UpperCAmelCase = mapped_key.replace("*" , __lowercase ) if "weight_g" in name: _UpperCAmelCase = "weight_g" elif "weight_v" in name: _UpperCAmelCase = "weight_v" elif "bias" in name: _UpperCAmelCase = "bias" elif "weight" in name: # TODO: don't match quantizer.weight_proj _UpperCAmelCase = "weight" else: _UpperCAmelCase = None set_recursively(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase ) continue if not is_used: unused_weights.append(__lowercase ) logger.warning(f'Unused weights: {unused_weights}' ) def UpperCAmelCase_ ( __lowercase : Union[str, Any] , __lowercase : Any , __lowercase : Any , __lowercase : List[Any] , __lowercase : Optional[Any] ) -> Tuple: '''simple docstring''' _UpperCAmelCase = full_name.split("conv_layers." )[-1] _UpperCAmelCase = name.split("." ) _UpperCAmelCase = int(items[0] ) _UpperCAmelCase = int(items[1] ) if type_id == 0: if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape: raise ValueError( f'{full_name} has size {value.shape}, but' f' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.' ) _UpperCAmelCase = value logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.' ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape: raise ValueError( f'{full_name} has size {value.shape}, but' f' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.' ) _UpperCAmelCase = value logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.' ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape: raise ValueError( f'{full_name} has size {value.shape}, but' f' {feature_extractor[layer_id].layer_norm.bias.data.shape} was found.' ) _UpperCAmelCase = value logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.' ) elif "weight" in name: if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape: raise ValueError( f'{full_name} has size {value.shape}, but' f' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.' ) _UpperCAmelCase = value logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.' ) else: unused_weights.append(__lowercase ) @torch.no_grad() def UpperCAmelCase_ ( __lowercase : Optional[Any] , __lowercase : Optional[int] , __lowercase : Dict=None , __lowercase : List[str]=None , __lowercase : Union[str, Any]=True ) -> int: '''simple docstring''' if config_path is not None: _UpperCAmelCase = UniSpeechSatConfig.from_pretrained(__lowercase ) else: _UpperCAmelCase = UniSpeechSatConfig() _UpperCAmelCase = "" if is_finetuned: _UpperCAmelCase = UniSpeechSatForCTC(__lowercase ) else: _UpperCAmelCase = UniSpeechSatForPreTraining(__lowercase ) _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={"data": "/".join(dict_path.split("/" )[:-1] )} ) _UpperCAmelCase = model[0].eval() recursively_load_weights(__lowercase , __lowercase ) hf_wavavec.save_pretrained(__lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :int = argparse.ArgumentParser() parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''') parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''') parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''') parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''') parser.add_argument( '''--not_finetuned''', action='''store_true''', help='''Whether the model to convert is a fine-tuned model or not''' ) __SCREAMING_SNAKE_CASE :Tuple = parser.parse_args() convert_unispeech_sat_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
22
'''simple docstring''' from .integrations import ( is_optuna_available, is_ray_available, is_sigopt_available, is_wandb_available, run_hp_search_optuna, run_hp_search_ray, run_hp_search_sigopt, run_hp_search_wandb, ) from .trainer_utils import ( HPSearchBackend, default_hp_space_optuna, default_hp_space_ray, default_hp_space_sigopt, default_hp_space_wandb, ) from .utils import logging __SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) class A_ : _lowerCamelCase : str _lowerCamelCase : str = None @staticmethod def lowercase ( ): raise NotImplementedError def lowercase ( self : Union[str, Any] , snake_case_ : Optional[int] , snake_case_ : int , snake_case_ : str , **snake_case_ : List[Any] ): raise NotImplementedError def lowercase ( self : Any , snake_case_ : int ): raise NotImplementedError def lowercase ( self : List[str] ): if not self.is_available(): raise RuntimeError( f'You picked the {self.name} backend, but it is not installed. Run {self.pip_install()}.' ) @classmethod def lowercase ( cls : List[Any] ): return f'`pip install {cls.pip_package or cls.name}`' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """optuna""" @staticmethod def lowercase ( ): return is_optuna_available() def lowercase ( self : List[str] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : Tuple ): return run_hp_search_optuna(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : int , snake_case_ : Optional[int] ): return default_hp_space_optuna(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Any = """ray""" _lowerCamelCase : Tuple = """'ray[tune]'""" @staticmethod def lowercase ( ): return is_ray_available() def lowercase ( self : Optional[Any] , snake_case_ : Any , snake_case_ : int , snake_case_ : str , **snake_case_ : List[str] ): return run_hp_search_ray(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : str ): return default_hp_space_ray(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """sigopt""" @staticmethod def lowercase ( ): return is_sigopt_available() def lowercase ( self : Any , snake_case_ : int , snake_case_ : int , snake_case_ : str , **snake_case_ : Dict ): return run_hp_search_sigopt(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Dict , snake_case_ : Optional[Any] ): return default_hp_space_sigopt(snake_case_ ) class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """wandb""" @staticmethod def lowercase ( ): return is_wandb_available() def lowercase ( self : Optional[Any] , snake_case_ : Optional[Any] , snake_case_ : int , snake_case_ : str , **snake_case_ : Optional[Any] ): return run_hp_search_wandb(snake_case_ , snake_case_ , snake_case_ , **snake_case_ ) def lowercase ( self : Any , snake_case_ : Union[str, Any] ): return default_hp_space_wandb(snake_case_ ) __SCREAMING_SNAKE_CASE :Dict = { HPSearchBackend(backend.name): backend for backend in [OptunaBackend, RayTuneBackend, SigOptBackend, WandbBackend] } def UpperCAmelCase_ ( ) -> str: '''simple docstring''' _UpperCAmelCase = [backend for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() if backend.is_available()] if len(__lowercase ) > 0: _UpperCAmelCase = available_backends[0].name if len(__lowercase ) > 1: logger.info( f'{len(__lowercase )} hyperparameter search backends available. Using {name} as the default.' ) return name raise RuntimeError( "No hyperparameter search backend available.\n" + "\n".join( f' - To install {backend.name} run {backend.pip_install()}' for backend in ALL_HYPERPARAMETER_SEARCH_BACKENDS.values() ) )
22
1
'''simple docstring''' import argparse import json import re from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileNetVaConfig, MobileNetVaForImageClassification, MobileNetVaImageProcessor, load_tf_weights_in_mobilenet_va, ) from transformers.utils import logging logging.set_verbosity_info() __SCREAMING_SNAKE_CASE :Any = logging.get_logger(__name__) def UpperCAmelCase_ ( __lowercase : Union[str, Any] ) -> Any: '''simple docstring''' _UpperCAmelCase = MobileNetVaConfig(layer_norm_eps=0.001 ) if "_quant" in model_name: raise ValueError("Quantized models are not supported." ) _UpperCAmelCase = re.match(r"^mobilenet_v1_([^_]*)_([^_]*)$" , __lowercase ) if matches: _UpperCAmelCase = float(matches[1] ) _UpperCAmelCase = int(matches[2] ) # The TensorFlow version of MobileNetV1 predicts 1001 classes instead of # the usual 1000. The first class (index 0) is "background". _UpperCAmelCase = 1001 _UpperCAmelCase = "imagenet-1k-id2label.json" _UpperCAmelCase = "huggingface/label-files" _UpperCAmelCase = json.load(open(hf_hub_download(__lowercase , __lowercase , repo_type="dataset" ) , "r" ) ) _UpperCAmelCase = {int(__lowercase ) + 1: v for k, v in idalabel.items()} _UpperCAmelCase = "background" _UpperCAmelCase = idalabel _UpperCAmelCase = {v: k for k, v in idalabel.items()} return config def UpperCAmelCase_ ( ) -> Optional[Any]: '''simple docstring''' _UpperCAmelCase = "http://images.cocodataset.org/val2017/000000039769.jpg" _UpperCAmelCase = Image.open(requests.get(__lowercase , stream=__lowercase ).raw ) return im @torch.no_grad() def UpperCAmelCase_ ( __lowercase : Dict , __lowercase : Optional[int] , __lowercase : int , __lowercase : Optional[Any]=False ) -> List[str]: '''simple docstring''' _UpperCAmelCase = get_mobilenet_va_config(__lowercase ) # Load 🤗 model _UpperCAmelCase = MobileNetVaForImageClassification(__lowercase ).eval() # Load weights from TensorFlow checkpoint load_tf_weights_in_mobilenet_va(__lowercase , __lowercase , __lowercase ) # Check outputs on an image, prepared by MobileNetV1ImageProcessor _UpperCAmelCase = MobileNetVaImageProcessor( crop_size={"width": config.image_size, "height": config.image_size} , size={"shortest_edge": config.image_size + 32} , ) _UpperCAmelCase = image_processor(images=prepare_img() , return_tensors="pt" ) _UpperCAmelCase = model(**__lowercase ) _UpperCAmelCase = outputs.logits assert logits.shape == (1, 1001) if model_name == "mobilenet_v1_1.0_224": _UpperCAmelCase = torch.tensor([-4.1739, -1.1233, 3.1205] ) elif model_name == "mobilenet_v1_0.75_192": _UpperCAmelCase = torch.tensor([-3.9440, -2.3141, -0.3333] ) else: _UpperCAmelCase = None if expected_logits is not None: assert torch.allclose(logits[0, :3] , __lowercase , atol=1E-4 ) Path(__lowercase ).mkdir(exist_ok=__lowercase ) print(f'Saving model {model_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(__lowercase ) print(f'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(__lowercase ) if push_to_hub: print("Pushing to the hub..." ) _UpperCAmelCase = "google/" + model_name image_processor.push_to_hub(__lowercase ) model.push_to_hub(__lowercase ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--model_name''', default='''mobilenet_v1_1.0_224''', type=str, help='''Name of the MobileNetV1 model you\'d like to convert. Should in the form \'mobilenet_v1_<depth>_<size>\'.''', ) parser.add_argument( '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).''' ) parser.add_argument( '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.''' ) parser.add_argument( '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_movilevit_checkpoint( args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub )
22
'''simple docstring''' __SCREAMING_SNAKE_CASE :List[str] = '''0.18.2''' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
22
1
'''simple docstring''' # DISCLAIMER: This file is strongly influenced by https://github.com/yang-song/score_sde_pytorch import math from dataclasses import dataclass from typing import Optional, Tuple, Union import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin, SchedulerOutput @dataclass class A_ ( lowerCAmelCase_ ): _lowerCamelCase : torch.FloatTensor _lowerCamelCase : torch.FloatTensor class A_ ( lowerCAmelCase_ , lowerCAmelCase_ ): _lowerCamelCase : Tuple = 1 @register_to_config def __init__( self : Dict , snake_case_ : int = 2_0_0_0 , snake_case_ : float = 0.1_5 , snake_case_ : float = 0.0_1 , snake_case_ : float = 1_3_4_8.0 , snake_case_ : float = 1e-5 , snake_case_ : int = 1 , ): # standard deviation of the initial noise distribution _UpperCAmelCase = sigma_max # setable values _UpperCAmelCase = None self.set_sigmas(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) def lowercase ( self : Union[str, Any] , snake_case_ : torch.FloatTensor , snake_case_ : Optional[int] = None ): return sample def lowercase ( self : Tuple , snake_case_ : int , snake_case_ : float = None , snake_case_ : Union[str, torch.device] = None ): _UpperCAmelCase = sampling_eps if sampling_eps is not None else self.config.sampling_eps _UpperCAmelCase = torch.linspace(1 , snake_case_ , snake_case_ , device=snake_case_ ) def lowercase ( self : Any , snake_case_ : int , snake_case_ : float = None , snake_case_ : float = None , snake_case_ : float = None ): _UpperCAmelCase = sigma_min if sigma_min is not None else self.config.sigma_min _UpperCAmelCase = sigma_max if sigma_max is not None else self.config.sigma_max _UpperCAmelCase = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(snake_case_ , snake_case_ ) _UpperCAmelCase = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) _UpperCAmelCase = torch.exp(torch.linspace(math.log(snake_case_ ) , math.log(snake_case_ ) , snake_case_ ) ) _UpperCAmelCase = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def lowercase ( self : Optional[int] , snake_case_ : Union[str, Any] , snake_case_ : int ): return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def lowercase ( self : Union[str, Any] , snake_case_ : torch.FloatTensor , snake_case_ : int , snake_case_ : torch.FloatTensor , snake_case_ : Optional[torch.Generator] = None , snake_case_ : bool = True , ): if self.timesteps is None: raise ValueError( "`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler" ) _UpperCAmelCase = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) _UpperCAmelCase = (timestep * (len(self.timesteps ) - 1)).long() # mps requires indices to be in the same device, so we use cpu as is the default with cuda _UpperCAmelCase = timesteps.to(self.discrete_sigmas.device ) _UpperCAmelCase = self.discrete_sigmas[timesteps].to(sample.device ) _UpperCAmelCase = self.get_adjacent_sigma(snake_case_ , snake_case_ ).to(sample.device ) _UpperCAmelCase = torch.zeros_like(snake_case_ ) _UpperCAmelCase = (sigma**2 - adjacent_sigma**2) ** 0.5 # equation 6 in the paper: the model_output modeled by the network is grad_x log pt(x) # also equation 47 shows the analog from SDE models to ancestral sampling methods _UpperCAmelCase = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): _UpperCAmelCase = diffusion.unsqueeze(-1 ) _UpperCAmelCase = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of _UpperCAmelCase = randn_tensor( sample.shape , layout=sample.layout , generator=snake_case_ , device=sample.device , dtype=sample.dtype ) _UpperCAmelCase = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? _UpperCAmelCase = prev_sample_mean + diffusion * noise # add impact of diffusion field g if not return_dict: return (prev_sample, prev_sample_mean) return SdeVeOutput(prev_sample=snake_case_ , prev_sample_mean=snake_case_ ) def lowercase ( self : str , snake_case_ : torch.FloatTensor , snake_case_ : torch.FloatTensor , snake_case_ : Optional[torch.Generator] = None , snake_case_ : bool = True , ): if self.timesteps is None: raise ValueError( "`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler" ) # For small batch sizes, the paper "suggest replacing norm(z) with sqrt(d), where d is the dim. of z" # sample noise for correction _UpperCAmelCase = randn_tensor(sample.shape , layout=sample.layout , generator=snake_case_ ).to(sample.device ) # compute step size from the model_output, the noise, and the snr _UpperCAmelCase = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() _UpperCAmelCase = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() _UpperCAmelCase = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 _UpperCAmelCase = step_size * torch.ones(sample.shape[0] ).to(sample.device ) # self.repeat_scalar(step_size, sample.shape[0]) # compute corrected sample: model_output term and noise term _UpperCAmelCase = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): _UpperCAmelCase = step_size.unsqueeze(-1 ) _UpperCAmelCase = sample + step_size * model_output _UpperCAmelCase = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=snake_case_ ) def lowercase ( self : Any , snake_case_ : torch.FloatTensor , snake_case_ : torch.FloatTensor , snake_case_ : torch.FloatTensor , ): # Make sure sigmas and timesteps have the same device and dtype as original_samples _UpperCAmelCase = timesteps.to(original_samples.device ) _UpperCAmelCase = self.discrete_sigmas.to(original_samples.device )[timesteps] _UpperCAmelCase = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(snake_case_ ) * sigmas[:, None, None, None] ) _UpperCAmelCase = noise + original_samples return noisy_samples def __len__( self : Dict ): return self.config.num_train_timesteps
22
'''simple docstring''' import re from filelock import FileLock try: import nltk __SCREAMING_SNAKE_CASE :Optional[int] = True except (ImportError, ModuleNotFoundError): __SCREAMING_SNAKE_CASE :str = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def UpperCAmelCase_ ( __lowercase : str ) -> str: '''simple docstring''' re.sub("<n>" , "" , __lowercase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__lowercase ) )
22
1
'''simple docstring''' # Usage: # ./gen-card-facebook-wmt19.py import os from pathlib import Path def UpperCAmelCase_ ( __lowercase : int , __lowercase : Optional[int] , __lowercase : Union[str, Any] ) -> str: '''simple docstring''' _UpperCAmelCase = { "en": "Machine learning is great, isn't it?", "ru": "Машинное обучение - это здорово, не так ли?", "de": "Maschinelles Lernen ist großartig, oder?", } # BLUE scores as follows: # "pair": [fairseq, transformers] _UpperCAmelCase = { "ru-en": ["[41.3](http://matrix.statmt.org/matrix/output/1907?run_id=6937)", "39.20"], "en-ru": ["[36.4](http://matrix.statmt.org/matrix/output/1914?run_id=6724)", "33.47"], "en-de": ["[43.1](http://matrix.statmt.org/matrix/output/1909?run_id=6862)", "42.83"], "de-en": ["[42.3](http://matrix.statmt.org/matrix/output/1902?run_id=6750)", "41.35"], } _UpperCAmelCase = f'{src_lang}-{tgt_lang}' _UpperCAmelCase = f'\n---\nlanguage: \n- {src_lang}\n- {tgt_lang}\nthumbnail:\ntags:\n- translation\n- wmt19\n- facebook\nlicense: apache-2.0\ndatasets:\n- wmt19\nmetrics:\n- bleu\n---\n\n# FSMT\n\n## Model description\n\nThis is a ported version of [fairseq wmt19 transformer](https://github.com/pytorch/fairseq/blob/master/examples/wmt19/README.md) for {src_lang}-{tgt_lang}.\n\nFor more details, please see, [Facebook FAIR\'s WMT19 News Translation Task Submission](https://arxiv.org/abs/1907.06616).\n\nThe abbreviation FSMT stands for FairSeqMachineTranslation\n\nAll four models are available:\n\n* [wmt19-en-ru](https://huggingface.co/facebook/wmt19-en-ru)\n* [wmt19-ru-en](https://huggingface.co/facebook/wmt19-ru-en)\n* [wmt19-en-de](https://huggingface.co/facebook/wmt19-en-de)\n* [wmt19-de-en](https://huggingface.co/facebook/wmt19-de-en)\n\n## Intended uses & limitations\n\n#### How to use\n\n```python\nfrom transformers import FSMTForConditionalGeneration, FSMTTokenizer\nmname = "facebook/wmt19-{src_lang}-{tgt_lang}"\ntokenizer = FSMTTokenizer.from_pretrained(mname)\nmodel = FSMTForConditionalGeneration.from_pretrained(mname)\n\ninput = "{texts[src_lang]}"\ninput_ids = tokenizer.encode(input, return_tensors="pt")\noutputs = model.generate(input_ids)\ndecoded = tokenizer.decode(outputs[0], skip_special_tokens=True)\nprint(decoded) # {texts[tgt_lang]}\n\n```\n\n#### Limitations and bias\n\n- The original (and this ported model) doesn\'t seem to handle well inputs with repeated sub-phrases, [content gets truncated](https://discuss.huggingface.co/t/issues-with-translating-inputs-containing-repeated-phrases/981)\n\n## Training data\n\nPretrained weights were left identical to the original model released by fairseq. For more details, please, see the [paper](https://arxiv.org/abs/1907.06616).\n\n## Eval results\n\npair | fairseq | transformers\n-------|---------|----------\n{pair} | {scores[pair][0]} | {scores[pair][1]}\n\nThe score is slightly below the score reported by `fairseq`, since `transformers`` currently doesn\'t support:\n- model ensemble, therefore the best performing checkpoint was ported (``model4.pt``).\n- re-ranking\n\nThe score was calculated using this code:\n\n```bash\ngit clone https://github.com/huggingface/transformers\ncd transformers\nexport PAIR={pair}\nexport DATA_DIR=data/$PAIR\nexport SAVE_DIR=data/$PAIR\nexport BS=8\nexport NUM_BEAMS=15\nmkdir -p $DATA_DIR\nsacrebleu -t wmt19 -l $PAIR --echo src > $DATA_DIR/val.source\nsacrebleu -t wmt19 -l $PAIR --echo ref > $DATA_DIR/val.target\necho $PAIR\nPYTHONPATH="src:examples/seq2seq" python examples/seq2seq/run_eval.py facebook/wmt19-$PAIR $DATA_DIR/val.source $SAVE_DIR/test_translations.txt --reference_path $DATA_DIR/val.target --score_path $SAVE_DIR/test_bleu.json --bs $BS --task translation --num_beams $NUM_BEAMS\n```\nnote: fairseq reports using a beam of 50, so you should get a slightly higher score if re-run with `--num_beams 50`.\n\n## Data Sources\n\n- [training, etc.](http://www.statmt.org/wmt19/)\n- [test set](http://matrix.statmt.org/test_sets/newstest2019.tgz?1556572561)\n\n\n### BibTeX entry and citation info\n\n```bibtex\n@inproceedings{{...,\n year={{2020}},\n title={{Facebook FAIR\'s WMT19 News Translation Task Submission}},\n author={{Ng, Nathan and Yee, Kyra and Baevski, Alexei and Ott, Myle and Auli, Michael and Edunov, Sergey}},\n booktitle={{Proc. of WMT}},\n}}\n```\n\n\n## TODO\n\n- port model ensemble (fairseq uses 4 model checkpoints)\n\n' os.makedirs(__lowercase , exist_ok=__lowercase ) _UpperCAmelCase = os.path.join(__lowercase , "README.md" ) print(f'Generating {path}' ) with open(__lowercase , "w" , encoding="utf-8" ) as f: f.write(__lowercase ) # make sure we are under the root of the project __SCREAMING_SNAKE_CASE :Optional[Any] = Path(__file__).resolve().parent.parent.parent __SCREAMING_SNAKE_CASE :Any = repo_dir / '''model_cards''' for model_name in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]: __SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE :Optional[Any] = model_name.split('''-''') __SCREAMING_SNAKE_CASE :List[str] = model_cards_dir / '''facebook''' / model_name write_model_card(model_card_dir, src_lang=src_lang, tgt_lang=tgt_lang)
22
'''simple docstring''' import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel if is_vision_available(): from transformers import MaskFormerImageProcessor if is_vision_available(): from PIL import Image class A_ : def __init__( self : str , snake_case_ : int , snake_case_ : Union[str, Any]=2 , snake_case_ : List[Any]=True , snake_case_ : str=False , snake_case_ : str=1_0 , snake_case_ : str=3 , snake_case_ : Dict=3_2 * 4 , snake_case_ : Any=3_2 * 6 , snake_case_ : Optional[Any]=4 , snake_case_ : Optional[int]=3_2 , ): _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = is_training _UpperCAmelCase = use_auxiliary_loss _UpperCAmelCase = num_queries _UpperCAmelCase = num_channels _UpperCAmelCase = min_size _UpperCAmelCase = max_size _UpperCAmelCase = num_labels _UpperCAmelCase = mask_feature_size def lowercase ( self : Union[str, Any] ): _UpperCAmelCase = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( snake_case_ ) _UpperCAmelCase = torch.ones([self.batch_size, self.min_size, self.max_size] , device=snake_case_ ) _UpperCAmelCase = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=snake_case_ ) > 0.5 ).float() _UpperCAmelCase = (torch.rand((self.batch_size, self.num_labels) , device=snake_case_ ) > 0.5).long() _UpperCAmelCase = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def lowercase ( self : List[Any] ): return MaskFormerConfig.from_backbone_and_decoder_configs( backbone_config=SwinConfig( depths=[1, 1, 1, 1] , ) , decoder_config=DetrConfig( decoder_ffn_dim=1_2_8 , num_queries=self.num_queries , decoder_attention_heads=2 , d_model=self.mask_feature_size , ) , mask_feature_size=self.mask_feature_size , fpn_feature_size=self.mask_feature_size , num_channels=self.num_channels , num_labels=self.num_labels , ) def lowercase ( self : Optional[Any] ): _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.prepare_config_and_inputs() _UpperCAmelCase = {"pixel_values": pixel_values, "pixel_mask": pixel_mask} return config, inputs_dict def lowercase ( self : List[Any] , snake_case_ : Optional[Any] , snake_case_ : Optional[Any] ): _UpperCAmelCase = output.encoder_hidden_states _UpperCAmelCase = output.pixel_decoder_hidden_states _UpperCAmelCase = output.transformer_decoder_hidden_states self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(snake_case_ ) , config.decoder_config.decoder_layers ) def lowercase ( self : Tuple , snake_case_ : str , snake_case_ : Optional[int] , snake_case_ : Any , snake_case_ : Optional[Any]=False ): with torch.no_grad(): _UpperCAmelCase = MaskFormerModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ , output_hidden_states=snake_case_ ) # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the # encoder and pixel decoder self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.mask_feature_size) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(snake_case_ , snake_case_ ) def lowercase ( self : Any , snake_case_ : List[str] , snake_case_ : List[Any] , snake_case_ : int , snake_case_ : str , snake_case_ : List[Any] ): _UpperCAmelCase = MaskFormerForInstanceSegmentation(config=snake_case_ ) model.to(snake_case_ ) model.eval() def comm_check_on_output(snake_case_ : int ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): _UpperCAmelCase = model(pixel_values=snake_case_ , pixel_mask=snake_case_ ) _UpperCAmelCase = model(snake_case_ ) comm_check_on_output(snake_case_ ) _UpperCAmelCase = model( pixel_values=snake_case_ , pixel_mask=snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) comm_check_on_output(snake_case_ ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class A_ ( lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase ): _lowerCamelCase : Dict = (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else () _lowerCamelCase : Tuple = ( {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation} if is_torch_available() else {} ) _lowerCamelCase : Optional[Any] = False _lowerCamelCase : Dict = False _lowerCamelCase : Any = False _lowerCamelCase : List[Any] = False def lowercase ( self : Optional[int] ): _UpperCAmelCase = MaskFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=snake_case_ , has_text_modality=snake_case_ ) def lowercase ( self : Optional[Any] ): self.config_tester.run_common_tests() def lowercase ( self : Union[str, Any] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : int ): _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case_ ) @unittest.skip(reason="MaskFormer does not use inputs_embeds" ) def lowercase ( self : Any ): pass @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer is not a generative model" ) def lowercase ( self : List[str] ): pass @unittest.skip(reason="MaskFormer does not use token embeddings" ) def lowercase ( self : List[Any] ): pass @require_torch_multi_gpu @unittest.skip( reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`" ) def lowercase ( self : Any ): pass @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def lowercase ( self : Union[str, Any] ): pass def lowercase ( self : List[str] ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case_ ) @slow def lowercase ( self : Optional[int] ): for model_name in ["facebook/maskformer-swin-small-coco"]: _UpperCAmelCase = MaskFormerModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowercase ( self : Optional[int] ): _UpperCAmelCase = (self.model_tester.min_size,) * 2 _UpperCAmelCase = { "pixel_values": torch.randn((2, 3, *size) , device=snake_case_ ), "mask_labels": torch.randn((2, 1_0, *size) , device=snake_case_ ), "class_labels": torch.zeros(2 , 1_0 , device=snake_case_ ).long(), } _UpperCAmelCase = MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None ) def lowercase ( self : Dict ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskformer_model(snake_case_ , **snake_case_ , output_hidden_states=snake_case_ ) def lowercase ( self : Any ): _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(snake_case_ ).to(snake_case_ ) _UpperCAmelCase = model(**snake_case_ , output_attentions=snake_case_ ) self.assertTrue(outputs.attentions is not None ) def lowercase ( self : int ): if not self.model_tester.is_training: return # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ).loss loss.backward() def lowercase ( self : int ): # only MaskFormerForInstanceSegmentation has the loss _UpperCAmelCase = self.all_model_classes[1] _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(snake_case_ ) model.to(snake_case_ ) model.train() _UpperCAmelCase = model(snake_case_ , mask_labels=snake_case_ , class_labels=snake_case_ ) _UpperCAmelCase = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't _UpperCAmelCase = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() _UpperCAmelCase = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=snake_case_ ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) __SCREAMING_SNAKE_CASE :Dict = 1e-4 def UpperCAmelCase_ ( ) -> List[str]: '''simple docstring''' _UpperCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) return image @require_vision @slow class A_ ( unittest.TestCase ): @cached_property def lowercase ( self : Dict ): return ( MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" ) if is_vision_available() else None ) def lowercase ( self : List[Any] ): _UpperCAmelCase = MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(snake_case_ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) _UpperCAmelCase = torch.tensor( [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) _UpperCAmelCase = torch.tensor( [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]] ).to(snake_case_ ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : Tuple ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [ [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3], [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5], [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2], ] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [ [1.6_512e00, -5.2_572e00, -3.3_519e00], [3.6_169e-02, -5.9_025e00, -2.9_313e00], [1.0_766e-04, -7.7_630e00, -5.1_263e00], ] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : int ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(snake_case_ , return_tensors="pt" ).to(snake_case_ ) _UpperCAmelCase = inputs["pixel_values"].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0 ) # check size self.assertEqual(snake_case_ , (1, 3, 8_0_0, 1_0_8_8) ) with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) # masks_queries_logits _UpperCAmelCase = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) , ) _UpperCAmelCase = [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]] _UpperCAmelCase = torch.tensor(snake_case_ ).to(snake_case_ ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , snake_case_ , atol=snake_case_ ) ) # class_queries_logits _UpperCAmelCase = outputs.class_queries_logits self.assertEqual( class_queries_logits.shape , (1, model.config.decoder_config.num_queries, model.config.num_labels + 1) ) _UpperCAmelCase = torch.tensor( [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , snake_case_ , atol=snake_case_ ) ) def lowercase ( self : List[Any] ): _UpperCAmelCase = ( MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" ) .to(snake_case_ ) .eval() ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = image_processor( [np.zeros((3, 8_0_0, 1_3_3_3) ), np.zeros((3, 8_0_0, 1_3_3_3) )] , segmentation_maps=[np.zeros((3_8_4, 3_8_4) ).astype(np.floataa ), np.zeros((3_8_4, 3_8_4) ).astype(np.floataa )] , return_tensors="pt" , ) _UpperCAmelCase = inputs["pixel_values"].to(snake_case_ ) _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["mask_labels"]] _UpperCAmelCase = [el.to(snake_case_ ) for el in inputs["class_labels"]] with torch.no_grad(): _UpperCAmelCase = model(**snake_case_ ) self.assertTrue(outputs.loss is not None )
22
1
'''simple docstring''' from math import factorial def UpperCAmelCase_ ( __lowercase : int = 20 ) -> int: '''simple docstring''' _UpperCAmelCase = 2 * n # middle entry of odd rows starting at row 3 is the solution for n = 1, # 2, 3,... _UpperCAmelCase = n // 2 return int(factorial(__lowercase ) / (factorial(__lowercase ) * factorial(n - k )) ) if __name__ == "__main__": import sys if len(sys.argv) == 1: print(solution(20)) else: try: __SCREAMING_SNAKE_CASE :Optional[Any] = int(sys.argv[1]) print(solution(n)) except ValueError: print('''Invalid entry - please enter a number.''')
22
'''simple docstring''' 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: __SCREAMING_SNAKE_CASE :List[Any] = None __SCREAMING_SNAKE_CASE :Union[str, Any] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :List[str] = {'''vocab_file''': '''spiece.model''', '''tokenizer_file''': '''tokenizer.json'''} __SCREAMING_SNAKE_CASE :List[Any] = { '''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''', }, } __SCREAMING_SNAKE_CASE :Optional[Any] = { '''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, } __SCREAMING_SNAKE_CASE :Optional[int] = '''▁''' class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = VOCAB_FILES_NAMES _lowerCamelCase : Any = PRETRAINED_VOCAB_FILES_MAP _lowerCamelCase : Tuple = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCamelCase : int = AlbertTokenizer def __init__( self : Optional[Any] , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=None , snake_case_ : Optional[Any]=True , snake_case_ : str=True , snake_case_ : Tuple=False , snake_case_ : List[Any]="[CLS]" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : str="<unk>" , snake_case_ : Union[str, Any]="[SEP]" , snake_case_ : List[Any]="<pad>" , snake_case_ : List[str]="[CLS]" , snake_case_ : int="[MASK]" , **snake_case_ : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. _UpperCAmelCase = ( AddedToken(snake_case_ , lstrip=snake_case_ , rstrip=snake_case_ , normalized=snake_case_ ) if isinstance(snake_case_ , snake_case_ ) else mask_token ) super().__init__( snake_case_ , tokenizer_file=snake_case_ , do_lower_case=snake_case_ , remove_space=snake_case_ , keep_accents=snake_case_ , bos_token=snake_case_ , eos_token=snake_case_ , unk_token=snake_case_ , sep_token=snake_case_ , pad_token=snake_case_ , cls_token=snake_case_ , mask_token=snake_case_ , **snake_case_ , ) _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = False if not self.vocab_file else True def lowercase ( self : Union[str, Any] , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Dict , snake_case_ : List[int] , snake_case_ : Optional[List[int]] = None ): _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : Optional[Any] , snake_case_ : str , snake_case_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(snake_case_ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return _UpperCAmelCase = os.path.join( snake_case_ , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(snake_case_ ): copyfile(self.vocab_file , snake_case_ ) return (out_vocab_file,)
22
1
'''simple docstring''' from collections import OrderedDict from typing import TYPE_CHECKING, Any, Mapping, Optional from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...utils import logging if TYPE_CHECKING: from ...processing_utils import ProcessorMixin from ...utils import TensorType __SCREAMING_SNAKE_CASE :Optional[int] = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :Dict = { '''microsoft/layoutlmv3-base''': '''https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json''', } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Optional[int] = """layoutlmv3""" def __init__( self : int , snake_case_ : List[Any]=5_0_2_6_5 , snake_case_ : int=7_6_8 , snake_case_ : Optional[int]=1_2 , snake_case_ : Dict=1_2 , snake_case_ : Union[str, Any]=3_0_7_2 , snake_case_ : Optional[Any]="gelu" , snake_case_ : Union[str, Any]=0.1 , snake_case_ : Optional[Any]=0.1 , snake_case_ : List[Any]=5_1_2 , snake_case_ : Any=2 , snake_case_ : Any=0.0_2 , snake_case_ : Union[str, Any]=1e-5 , snake_case_ : Tuple=1 , snake_case_ : Any=0 , snake_case_ : Optional[int]=2 , snake_case_ : List[str]=1_0_2_4 , snake_case_ : int=1_2_8 , snake_case_ : List[Any]=1_2_8 , snake_case_ : List[str]=True , snake_case_ : int=3_2 , snake_case_ : Union[str, Any]=1_2_8 , snake_case_ : Dict=6_4 , snake_case_ : int=2_5_6 , snake_case_ : Tuple=True , snake_case_ : str=True , snake_case_ : Tuple=True , snake_case_ : Optional[Any]=2_2_4 , snake_case_ : List[str]=3 , snake_case_ : Tuple=1_6 , snake_case_ : Any=None , **snake_case_ : Union[str, Any] , ): super().__init__( vocab_size=snake_case_ , hidden_size=snake_case_ , num_hidden_layers=snake_case_ , num_attention_heads=snake_case_ , intermediate_size=snake_case_ , hidden_act=snake_case_ , hidden_dropout_prob=snake_case_ , attention_probs_dropout_prob=snake_case_ , max_position_embeddings=snake_case_ , type_vocab_size=snake_case_ , initializer_range=snake_case_ , layer_norm_eps=snake_case_ , pad_token_id=snake_case_ , bos_token_id=snake_case_ , eos_token_id=snake_case_ , **snake_case_ , ) _UpperCAmelCase = max_ad_position_embeddings _UpperCAmelCase = coordinate_size _UpperCAmelCase = shape_size _UpperCAmelCase = has_relative_attention_bias _UpperCAmelCase = rel_pos_bins _UpperCAmelCase = max_rel_pos _UpperCAmelCase = has_spatial_attention_bias _UpperCAmelCase = rel_ad_pos_bins _UpperCAmelCase = max_rel_ad_pos _UpperCAmelCase = text_embed _UpperCAmelCase = visual_embed _UpperCAmelCase = input_size _UpperCAmelCase = num_channels _UpperCAmelCase = patch_size _UpperCAmelCase = classifier_dropout class A_ ( lowerCAmelCase_ ): _lowerCamelCase : Tuple = version.parse("""1.12""" ) @property def lowercase ( self : List[str] ): # The order of inputs is different for question answering and sequence classification if self.task in ["question-answering", "sequence-classification"]: return OrderedDict( [ ("input_ids", {0: "batch", 1: "sequence"}), ("attention_mask", {0: "batch", 1: "sequence"}), ("bbox", {0: "batch", 1: "sequence"}), ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}), ] ) else: return OrderedDict( [ ("input_ids", {0: "batch", 1: "sequence"}), ("bbox", {0: "batch", 1: "sequence"}), ("attention_mask", {0: "batch", 1: "sequence"}), ("pixel_values", {0: "batch", 1: "num_channels"}), ] ) @property def lowercase ( self : Union[str, Any] ): return 1e-5 @property def lowercase ( self : Dict ): return 1_2 def lowercase ( self : Optional[Any] , snake_case_ : "ProcessorMixin" , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional["TensorType"] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): setattr(processor.image_processor , "apply_ocr" , snake_case_ ) # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = processor.tokenizer.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [[" ".join([processor.tokenizer.unk_token] ) * seq_length]] * batch_size # Generate dummy bounding boxes _UpperCAmelCase = [[[4_8, 8_4, 7_3, 1_2_8]]] * batch_size # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX # batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict( processor( snake_case_ , text=snake_case_ , boxes=snake_case_ , return_tensors=snake_case_ , ) ) return inputs
22
'''simple docstring''' from collections import OrderedDict from typing import Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...feature_extraction_utils import FeatureExtractionMixin from ...onnx import OnnxConfig from ...onnx.utils import compute_effective_axis_dimension from ...tokenization_utils_base import PreTrainedTokenizerBase from ...utils import TensorType, logging __SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) __SCREAMING_SNAKE_CASE :int = { '''deepmind/language-perceiver''': '''https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json''', # See all Perceiver models at https://huggingface.co/models?filter=perceiver } class A_ ( lowerCAmelCase_ ): _lowerCamelCase : int = """perceiver""" def __init__( self : Any , snake_case_ : List[Any]=2_5_6 , snake_case_ : str=1_2_8_0 , snake_case_ : Optional[int]=7_6_8 , snake_case_ : int=1 , snake_case_ : List[Any]=2_6 , snake_case_ : Dict=8 , snake_case_ : List[Any]=8 , snake_case_ : Tuple=None , snake_case_ : Tuple=None , snake_case_ : Any="kv" , snake_case_ : Any=1 , snake_case_ : List[str]=1 , snake_case_ : Optional[int]="gelu" , snake_case_ : List[Any]=0.1 , snake_case_ : Dict=0.0_2 , snake_case_ : int=1e-12 , snake_case_ : List[str]=True , snake_case_ : str=2_6_2 , snake_case_ : Optional[Any]=2_0_4_8 , snake_case_ : Union[str, Any]=5_6 , snake_case_ : Dict=[3_6_8, 4_9_6] , snake_case_ : Tuple=1_6 , snake_case_ : Union[str, Any]=1_9_2_0 , snake_case_ : List[Any]=1_6 , snake_case_ : Tuple=[1, 1_6, 2_2_4, 2_2_4] , **snake_case_ : List[Any] , ): super().__init__(**snake_case_ ) _UpperCAmelCase = num_latents _UpperCAmelCase = d_latents _UpperCAmelCase = d_model _UpperCAmelCase = num_blocks _UpperCAmelCase = num_self_attends_per_block _UpperCAmelCase = num_self_attention_heads _UpperCAmelCase = num_cross_attention_heads _UpperCAmelCase = qk_channels _UpperCAmelCase = v_channels _UpperCAmelCase = cross_attention_shape_for_attention _UpperCAmelCase = self_attention_widening_factor _UpperCAmelCase = cross_attention_widening_factor _UpperCAmelCase = hidden_act _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_query_residual # masked language modeling attributes _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings # image classification attributes _UpperCAmelCase = image_size # flow attributes _UpperCAmelCase = train_size # multimodal autoencoding attributes _UpperCAmelCase = num_frames _UpperCAmelCase = audio_samples_per_frame _UpperCAmelCase = samples_per_patch _UpperCAmelCase = output_shape class A_ ( lowerCAmelCase_ ): @property def lowercase ( self : int ): if self.task == "multiple-choice": _UpperCAmelCase = {0: "batch", 1: "choice", 2: "sequence"} else: _UpperCAmelCase = {0: "batch", 1: "sequence"} return OrderedDict( [ ("inputs", dynamic_axis), ("attention_mask", dynamic_axis), ] ) @property def lowercase ( self : Optional[Any] ): return 1e-4 def lowercase ( self : List[str] , snake_case_ : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : int = -1 , snake_case_ : bool = False , snake_case_ : Optional[TensorType] = None , snake_case_ : int = 3 , snake_case_ : int = 4_0 , snake_case_ : int = 4_0 , ): # copied from `transformers.onnx.config.OnnxConfig` and slightly altered/simplified if isinstance(snake_case_ , snake_case_ ): # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch , num_token_to_add=0 ) # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX _UpperCAmelCase = preprocessor.num_special_tokens_to_add(snake_case_ ) _UpperCAmelCase = compute_effective_axis_dimension( snake_case_ , fixed_dimension=OnnxConfig.default_fixed_sequence , num_token_to_add=snake_case_ ) # Generate dummy inputs according to compute batch and sequence _UpperCAmelCase = [" ".join(["a"] ) * seq_length] * batch_size _UpperCAmelCase = dict(preprocessor(snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("input_ids" ) return inputs elif isinstance(snake_case_ , snake_case_ ) and preprocessor.model_input_names[0] == "pixel_values": # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX _UpperCAmelCase = compute_effective_axis_dimension(snake_case_ , fixed_dimension=OnnxConfig.default_fixed_batch ) _UpperCAmelCase = self._generate_dummy_images(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) _UpperCAmelCase = dict(preprocessor(images=snake_case_ , return_tensors=snake_case_ ) ) _UpperCAmelCase = inputs.pop("pixel_values" ) return inputs else: raise ValueError( "Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor." )
22
1