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
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate, # specifically showcasing how to properly calculate the metrics on the # validation dataset when in a distributed system, and builds off the # `nlp_example.py` script. # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## SCREAMING_SNAKE_CASE : Optional[int] = 16 SCREAMING_SNAKE_CASE : List[Any] = 32 def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ = 16 ) -> Dict: _lowercase : Any = AutoTokenizer.from_pretrained('bert-base-cased' ) _lowercase : int = load_dataset('glue' , 'mrpc' ) def tokenize_function(lowerCamelCase_ ): # max_length=None => use the model max length (it's actually the default) _lowercase : Any = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=lowerCamelCase_ , max_length=lowerCamelCase_ ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): _lowercase : int = datasets.map( lowerCamelCase_ , batched=lowerCamelCase_ , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library _lowercase : Any = tokenized_datasets.rename_column('label' , 'labels' ) def collate_fn(lowerCamelCase_ ): # On TPU it's best to pad everything to the same length or training will be very slow. _lowercase : Optional[Any] = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": _lowercase : Tuple = 16 elif accelerator.mixed_precision != "no": _lowercase : Tuple = 8 else: _lowercase : Optional[int] = None return tokenizer.pad( lowerCamelCase_ , padding='longest' , max_length=lowerCamelCase_ , pad_to_multiple_of=lowerCamelCase_ , return_tensors='pt' , ) # Instantiate dataloaders. _lowercase : Dict = DataLoader( tokenized_datasets['train'] , shuffle=lowerCamelCase_ , collate_fn=lowerCamelCase_ , batch_size=lowerCamelCase_ ) _lowercase : Optional[Any] = DataLoader( tokenized_datasets['validation'] , shuffle=lowerCamelCase_ , collate_fn=lowerCamelCase_ , batch_size=lowerCamelCase_ ) return train_dataloader, eval_dataloader # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS", None) == "1": from accelerate.test_utils.training import mocked_dataloaders SCREAMING_SNAKE_CASE : Tuple = mocked_dataloaders # noqa: F811 def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , lowerCamelCase_ ) == "1": _lowercase : int = 2 # Initialize accelerator _lowercase : List[Any] = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs _lowercase : Dict = config['lr'] _lowercase : Optional[Any] = int(config['num_epochs'] ) _lowercase : Optional[Any] = int(config['seed'] ) _lowercase : List[str] = int(config['batch_size'] ) _lowercase : int = evaluate.load('glue' , 'mrpc' ) # If the batch size is too big we use gradient accumulation _lowercase : Optional[int] = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: _lowercase : Any = batch_size // MAX_GPU_BATCH_SIZE _lowercase : List[str] = MAX_GPU_BATCH_SIZE set_seed(lowerCamelCase_ ) _lowercase , _lowercase : Any = get_dataloaders(lowerCamelCase_ , lowerCamelCase_ ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) _lowercase : Union[str, Any] = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=lowerCamelCase_ ) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). _lowercase : List[str] = model.to(accelerator.device ) # Instantiate optimizer _lowercase : int = AdamW(params=model.parameters() , lr=lowerCamelCase_ ) # Instantiate scheduler _lowercase : Union[str, Any] = get_linear_schedule_with_warmup( optimizer=lowerCamelCase_ , num_warmup_steps=100 , num_training_steps=(len(lowerCamelCase_ ) * num_epochs) // gradient_accumulation_steps , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. _lowercase , _lowercase , _lowercase , _lowercase , _lowercase : int = accelerator.prepare( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # Now we train the model for epoch in range(lowerCamelCase_ ): model.train() for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) _lowercase : List[Any] = model(**lowerCamelCase_ ) _lowercase : Tuple = outputs.loss _lowercase : int = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase_ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() _lowercase : Tuple = 0 for step, batch in enumerate(lowerCamelCase_ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) with torch.no_grad(): _lowercase : List[str] = model(**lowerCamelCase_ ) _lowercase : Union[str, Any] = outputs.logits.argmax(dim=-1 ) _lowercase , _lowercase : Optional[Any] = accelerator.gather((predictions, batch['labels']) ) # New Code # # First we check if it's a distributed system if accelerator.use_distributed: # Then see if we're on the last batch of our eval dataloader if step == len(lowerCamelCase_ ) - 1: # Last batch needs to be truncated on distributed systems as it contains additional samples _lowercase : List[Any] = predictions[: len(eval_dataloader.dataset ) - samples_seen] _lowercase : Dict = references[: len(eval_dataloader.dataset ) - samples_seen] else: # Otherwise we add the number of samples seen samples_seen += references.shape[0] # All of this can be avoided if you use `Accelerator.gather_for_metrics` instead of `Accelerator.gather`: # accelerator.gather_for_metrics((predictions, batch["labels"])) metric.add_batch( predictions=lowerCamelCase_ , references=lowerCamelCase_ , ) _lowercase : List[str] = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'''epoch {epoch}:''' , lowerCamelCase_ ) def UpperCamelCase_( ) -> Union[str, Any]: _lowercase : List[Any] = argparse.ArgumentParser(description='Simple example of training script.' ) parser.add_argument( '--mixed_precision' , type=lowerCamelCase_ , default=lowerCamelCase_ , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.' ) _lowercase : str = parser.parse_args() _lowercase : Dict = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(lowerCamelCase_ , lowerCamelCase_ ) if __name__ == "__main__": main()
21
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
1
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> int: return x if y == 0 else greatest_common_divisor(lowerCamelCase_ , x % y ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> int: return (x * y) // greatest_common_divisor(lowerCamelCase_ , lowerCamelCase_ ) def UpperCamelCase_( lowerCamelCase_ = 20 ) -> int: _lowercase : Tuple = 1 for i in range(1 , n + 1 ): _lowercase : Dict = lcm(lowerCamelCase_ , lowerCamelCase_ ) return g if __name__ == "__main__": print(F"{solution() = }")
21
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
1
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.') if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
1
import datasets from .nmt_bleu import compute_bleu # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py SCREAMING_SNAKE_CASE : Dict = "\\n@INPROCEEDINGS{Papineni02bleu:a,\n author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},\n title = {BLEU: a Method for Automatic Evaluation of Machine Translation},\n booktitle = {},\n year = {2002},\n pages = {311--318}\n}\n@inproceedings{lin-och-2004-orange,\n title = \"{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation\",\n author = \"Lin, Chin-Yew and\n Och, Franz Josef\",\n booktitle = \"{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics\",\n month = \"aug 23{--}aug 27\",\n year = \"2004\",\n address = \"Geneva, Switzerland\",\n publisher = \"COLING\",\n url = \"https://www.aclweb.org/anthology/C04-1072\",\n pages = \"501--507\",\n}\n" SCREAMING_SNAKE_CASE : List[str] = "\\nBLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.\nQuality is considered to be the correspondence between a machine's output and that of a human: \"the closer a machine translation is to a professional human translation,\nthe better it is\" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and\nremains one of the most popular automated and inexpensive metrics.\n\nScores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.\nThose scores are then averaged over the whole corpus to reach an estimate of the translation's overall quality. Intelligibility or grammatical correctness\nare not taken into account[citation needed].\n\nBLEU's output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1\nrepresenting more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the\nreference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional\nreference translations will increase the BLEU score.\n" SCREAMING_SNAKE_CASE : str = "\nComputes BLEU score of translated segments against one or more references.\nArgs:\n predictions: list of translations to score.\n Each translation should be tokenized into a list of tokens.\n references: list of lists of references for each translation.\n Each reference should be tokenized into a list of tokens.\n max_order: Maximum n-gram order to use when computing BLEU score.\n smooth: Whether or not to apply Lin et al. 2004 smoothing.\nReturns:\n 'bleu': bleu score,\n 'precisions': geometric mean of n-gram precisions,\n 'brevity_penalty': brevity penalty,\n 'length_ratio': ratio of lengths,\n 'translation_length': translation_length,\n 'reference_length': reference_length\nExamples:\n\n >>> predictions = [\n ... [\"hello\", \"there\", \"general\", \"kenobi\"], # tokenized prediction of the first sample\n ... [\"foo\", \"bar\", \"foobar\"] # tokenized prediction of the second sample\n ... ]\n >>> references = [\n ... [[\"hello\", \"there\", \"general\", \"kenobi\"], [\"hello\", \"there\", \"!\"]], # tokenized references for the first sample (2 references)\n ... [[\"foo\", \"bar\", \"foobar\"]] # tokenized references for the second sample (1 reference)\n ... ]\n >>> bleu = datasets.load_metric(\"bleu\")\n >>> results = bleu.compute(predictions=predictions, references=references)\n >>> print(results[\"bleu\"])\n 1.0\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION ) class _lowerCamelCase( datasets.Metric ): def UpperCamelCase ( self) -> str: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('string', id='token'), id='sequence'), 'references': datasets.Sequence( datasets.Sequence(datasets.Value('string', id='token'), id='sequence'), id='references'), }), codebase_urls=['https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py'], reference_urls=[ 'https://en.wikipedia.org/wiki/BLEU', 'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213', ], ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase=4, lowerCamelCase=False) -> str: """simple docstring""" _lowercase : List[Any] = compute_bleu( reference_corpus=lowerCamelCase, translation_corpus=lowerCamelCase, max_order=lowerCamelCase, smooth=lowerCamelCase) ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Optional[Any] = score return { "bleu": bleu, "precisions": precisions, "brevity_penalty": bp, "length_ratio": ratio, "translation_length": translation_length, "reference_length": reference_length, }
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
from __future__ import annotations class _lowerCamelCase: def __init__( self, lowerCamelCase=None) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = data _lowercase : List[str] = None def __repr__( self) -> Optional[int]: """simple docstring""" _lowercase : Tuple = [] _lowercase : Dict = self while temp: string_rep.append(F'''{temp.data}''') _lowercase : int = temp.next return "->".join(lowerCamelCase) def UpperCamelCase_( lowerCamelCase_ ) -> List[str]: if not elements_list: raise Exception('The Elements List is empty' ) _lowercase : List[str] = Node(elements_list[0] ) for i in range(1 , len(lowerCamelCase_ ) ): _lowercase : Optional[int] = Node(elements_list[i] ) _lowercase : str = current.next return head def UpperCamelCase_( lowerCamelCase_ ) -> None: if head_node is not None and isinstance(lowerCamelCase_ , lowerCamelCase_ ): print_reverse(head_node.next ) print(head_node.data ) def UpperCamelCase_( ) -> Dict: from doctest import testmod testmod() _lowercase : str = make_linked_list([14, 52, 14, 12, 43] ) print('Linked List:' ) print(lowerCamelCase_ ) print('Elements in Reverse:' ) print_reverse(lowerCamelCase_ ) if __name__ == "__main__": main()
21
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
1
from collections import defaultdict from math import gcd def UpperCamelCase_( lowerCamelCase_ = 150_0000 ) -> int: _lowercase : defaultdict = defaultdict(lowerCamelCase_ ) _lowercase : Tuple = 2 while 2 * euclid_m * (euclid_m + 1) <= limit: for euclid_n in range((euclid_m % 2) + 1 , lowerCamelCase_ , 2 ): if gcd(lowerCamelCase_ , lowerCamelCase_ ) > 1: continue _lowercase : Union[str, Any] = 2 * euclid_m * (euclid_m + euclid_n) for perimeter in range(lowerCamelCase_ , limit + 1 , lowerCamelCase_ ): frequencies[perimeter] += 1 euclid_m += 1 return sum(1 for frequency in frequencies.values() if frequency == 1 ) if __name__ == "__main__": print(F"{solution() = }")
21
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
1
import argparse from pathlib import Path from transformers import AutoConfig, AutoTokenizer, RagConfig, RagSequenceForGeneration, RagTokenForGeneration def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = None , lowerCamelCase_ = None , lowerCamelCase_ = None , ) -> Any: if config_name_or_path is None: _lowercase : Optional[int] = 'facebook/rag-token-base' if model_type == 'rag_token' else 'facebook/rag-sequence-base' if generator_tokenizer_name_or_path is None: _lowercase : List[str] = generator_name_or_path if question_encoder_tokenizer_name_or_path is None: _lowercase : Optional[Any] = question_encoder_name_or_path _lowercase : Dict = RagTokenForGeneration if model_type == 'rag_token' else RagSequenceForGeneration # Save model. _lowercase : Any = RagConfig.from_pretrained(lowerCamelCase_ ) _lowercase : Tuple = AutoConfig.from_pretrained(lowerCamelCase_ ) _lowercase : int = AutoConfig.from_pretrained(lowerCamelCase_ ) _lowercase : List[Any] = gen_config _lowercase : List[Any] = question_encoder_config _lowercase : List[Any] = model_class.from_pretrained_question_encoder_generator( lowerCamelCase_ , lowerCamelCase_ , config=lowerCamelCase_ ) rag_model.save_pretrained(lowerCamelCase_ ) # Sanity check. model_class.from_pretrained(lowerCamelCase_ ) # Save tokenizers. _lowercase : List[Any] = AutoTokenizer.from_pretrained(lowerCamelCase_ ) gen_tokenizer.save_pretrained(dest_dir / 'generator_tokenizer/' ) _lowercase : Any = AutoTokenizer.from_pretrained(lowerCamelCase_ ) question_encoder_tokenizer.save_pretrained(dest_dir / 'question_encoder_tokenizer/' ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : Any = argparse.ArgumentParser() parser.add_argument( "--model_type", choices=["rag_sequence", "rag_token"], required=True, type=str, help="RAG model type: rag_sequence, rag_token", ) parser.add_argument("--dest", type=str, required=True, help="Path to the output checkpoint directory.") parser.add_argument("--generator_name_or_path", type=str, required=True, help="Generator model identifier") parser.add_argument( "--question_encoder_name_or_path", type=str, required=True, help="Question encoder model identifier" ) parser.add_argument( "--generator_tokenizer_name_or_path", type=str, help="Generator tokenizer identifier, if not specified, resolves to ``generator_name_or_path``", ) parser.add_argument( "--question_encoder_tokenizer_name_or_path", type=str, help="Question encoder tokenizer identifier, if not specified, resolves to ``question_encoder_name_or_path``", ) parser.add_argument( "--config_name_or_path", type=str, help=( "Identifier of the model config to use, if not provided, resolves to a base config for a given" " ``model_type``" ), ) SCREAMING_SNAKE_CASE : List[str] = parser.parse_args() SCREAMING_SNAKE_CASE : Any = Path(args.dest) dest_dir.mkdir(exist_ok=True) consolidate( args.model_type, args.generator_name_or_path, args.question_encoder_name_or_path, dest_dir, args.config_name_or_path, args.generator_tokenizer_name_or_path, args.question_encoder_tokenizer_name_or_path, )
21
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
1
import argparse import torch from torch import nn from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration def UpperCamelCase_( lowerCamelCase_ ) -> Any: _lowercase : Any = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', 'decoder.output_projection.weight', '_float_tensor', 'encoder.embed_positions._float_tensor', 'decoder.embed_positions._float_tensor', ] for k in ignore_keys: state_dict.pop(lowerCamelCase_ , lowerCamelCase_ ) def UpperCamelCase_( lowerCamelCase_ ) -> str: _lowercase , _lowercase : List[str] = emb.weight.shape _lowercase : int = nn.Linear(lowerCamelCase_ , lowerCamelCase_ , bias=lowerCamelCase_ ) _lowercase : List[Any] = emb.weight.data return lin_layer def UpperCamelCase_( lowerCamelCase_ ) -> Dict: _lowercase : Optional[Any] = torch.load(lowerCamelCase_ , map_location='cpu' ) _lowercase : Union[str, Any] = mam_aaa['args'] or mam_aaa['cfg']['model'] _lowercase : Any = mam_aaa['model'] remove_ignore_keys_(lowerCamelCase_ ) _lowercase : List[Any] = state_dict['encoder.embed_tokens.weight'].shape[0] _lowercase : List[Any] = MaMaaaConfig( vocab_size=lowerCamelCase_ , max_position_embeddings=1024 , encoder_layers=args.encoder_layers , decoder_layers=args.decoder_layers , encoder_attention_heads=args.encoder_attention_heads , decoder_attention_heads=args.decoder_attention_heads , encoder_ffn_dim=args.encoder_ffn_embed_dim , decoder_ffn_dim=args.decoder_ffn_embed_dim , d_model=args.encoder_embed_dim , encoder_layerdrop=args.encoder_layerdrop , decoder_layerdrop=args.decoder_layerdrop , dropout=args.dropout , attention_dropout=args.attention_dropout , activation_dropout=args.activation_dropout , activation_function='relu' , ) _lowercase : Optional[Any] = state_dict['decoder.embed_tokens.weight'] _lowercase : Optional[int] = MaMaaaForConditionalGeneration(lowerCamelCase_ ) model.model.load_state_dict(lowerCamelCase_ , strict=lowerCamelCase_ ) _lowercase : List[str] = make_linear_from_emb(model.model.shared ) return model if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = argparse.ArgumentParser() # Required parameters parser.add_argument("fairseq_path", type=str, help="path to a model.pt on local filesystem.") parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") SCREAMING_SNAKE_CASE : Optional[Any] = parser.parse_args() SCREAMING_SNAKE_CASE : Tuple = convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß) model.save_pretrained(args.pytorch_dump_folder_path)
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
from sklearn.metrics import fa_score import datasets SCREAMING_SNAKE_CASE : Any = "\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n" SCREAMING_SNAKE_CASE : List[Any] = "\nArgs:\n predictions (`list` of `int`): Predicted labels.\n references (`list` of `int`): Ground truth labels.\n labels (`list` of `int`): The set of labels to include when `average` is not set to `'binary'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.\n\n - 'binary': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n - 'micro': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n - 'macro': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n - 'weighted': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n - 'samples': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n Example 1-A simple binary example\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n >>> print(results)\n {'f1': 0.5}\n\n Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n >>> print(round(results['f1'], 2))\n 0.67\n\n Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n >>> f1_metric = datasets.load_metric(\"f1\")\n >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n >>> print(round(results['f1'], 2))\n 0.35\n\n Example 4-A multiclass example, with different values for the `average` input.\n >>> predictions = [0, 2, 1, 0, 0, 1]\n >>> references = [0, 1, 2, 0, 1, 2]\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"macro\")\n >>> print(round(results['f1'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"micro\")\n >>> print(round(results['f1'], 2))\n 0.33\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=\"weighted\")\n >>> print(round(results['f1'], 2))\n 0.27\n >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n >>> print(results)\n {'f1': array([0.8, 0. , 0. ])}\n" SCREAMING_SNAKE_CASE : List[Any] = "\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION ) class _lowerCamelCase( datasets.Metric ): def UpperCamelCase ( self) -> Dict: """simple docstring""" return datasets.MetricInfo( description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features( { 'predictions': datasets.Sequence(datasets.Value('int32')), 'references': datasets.Sequence(datasets.Value('int32')), } if self.config_name == 'multilabel' else { 'predictions': datasets.Value('int32'), 'references': datasets.Value('int32'), }), reference_urls=['https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html'], ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=1, lowerCamelCase="binary", lowerCamelCase=None) -> Union[str, Any]: """simple docstring""" _lowercase : int = fa_score( lowerCamelCase, lowerCamelCase, labels=lowerCamelCase, pos_label=lowerCamelCase, average=lowerCamelCase, sample_weight=lowerCamelCase) return {"f1": float(lowerCamelCase) if score.size == 1 else score}
21
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
1
from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class _lowerCamelCase( _a ): lowercase_ : Optional[Any] = DistilBertTokenizer lowercase_ : Optional[int] = DistilBertTokenizerFast lowercase_ : Any = True @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : int = DistilBertTokenizer.from_pretrained('distilbert-base-uncased') _lowercase : Union[str, Any] = tokenizer.encode('sequence builders', add_special_tokens=lowerCamelCase) _lowercase : Tuple = tokenizer.encode('multi-sequence build', add_special_tokens=lowerCamelCase) _lowercase : Optional[int] = tokenizer.build_inputs_with_special_tokens(lowerCamelCase) _lowercase : List[Any] = tokenizer.build_inputs_with_special_tokens(lowerCamelCase, lowerCamelCase) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]
21
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
1
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor from .base import PipelineTool class _lowerCamelCase( _a ): lowercase_ : int = """openai/whisper-base""" lowercase_ : Union[str, Any] = ( """This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the """ """transcribed text.""" ) lowercase_ : Any = """transcriber""" lowercase_ : List[Any] = WhisperProcessor lowercase_ : List[str] = WhisperForConditionalGeneration lowercase_ : Any = ["""audio"""] lowercase_ : Union[str, Any] = ["""text"""] def UpperCamelCase ( self, lowerCamelCase) -> Tuple: """simple docstring""" return self.pre_processor(lowerCamelCase, return_tensors='pt').input_features def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" return self.model.generate(inputs=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> Optional[Any]: """simple docstring""" return self.pre_processor.batch_decode(lowerCamelCase, skip_special_tokens=lowerCamelCase)[0]
21
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
1
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
1
import os import string import sys SCREAMING_SNAKE_CASE : int = 1 << 8 SCREAMING_SNAKE_CASE : int = { "tab": ord("\t"), "newline": ord("\r"), "esc": 27, "up": 65 + ARROW_KEY_FLAG, "down": 66 + ARROW_KEY_FLAG, "right": 67 + ARROW_KEY_FLAG, "left": 68 + ARROW_KEY_FLAG, "mod_int": 91, "undefined": sys.maxsize, "interrupt": 3, "insert": 50, "delete": 51, "pg_up": 53, "pg_down": 54, } SCREAMING_SNAKE_CASE : Tuple = KEYMAP["up"] SCREAMING_SNAKE_CASE : Union[str, Any] = KEYMAP["left"] if sys.platform == "win32": SCREAMING_SNAKE_CASE : Union[str, Any] = [] SCREAMING_SNAKE_CASE : List[str] = { B"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG, B"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG, B"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG, B"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG, B"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG, B"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG, B"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG, B"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG, } for i in range(10): SCREAMING_SNAKE_CASE : Dict = ord(str(i)) def UpperCamelCase_( ) -> Optional[Any]: if os.name == "nt": import msvcrt _lowercase : Tuple = 'mbcs' # Flush the keyboard buffer while msvcrt.kbhit(): msvcrt.getch() if len(lowerCamelCase_ ) == 0: # Read the keystroke _lowercase : List[str] = msvcrt.getch() # If it is a prefix char, get second part if ch in (b"\x00", b"\xe0"): _lowercase : Any = ch + msvcrt.getch() # Translate actual Win chars to bullet char types try: _lowercase : Any = chr(WIN_KEYMAP[cha] ) WIN_CH_BUFFER.append(chr(KEYMAP['mod_int'] ) ) WIN_CH_BUFFER.append(lowerCamelCase_ ) if ord(lowerCamelCase_ ) in ( KEYMAP["insert"] - 1 << 9, KEYMAP["delete"] - 1 << 9, KEYMAP["pg_up"] - 1 << 9, KEYMAP["pg_down"] - 1 << 9, ): WIN_CH_BUFFER.append(chr(126 ) ) _lowercase : int = chr(KEYMAP['esc'] ) except KeyError: _lowercase : Union[str, Any] = cha[1] else: _lowercase : str = ch.decode(lowerCamelCase_ ) else: _lowercase : Optional[Any] = WIN_CH_BUFFER.pop(0 ) elif os.name == "posix": import termios import tty _lowercase : str = sys.stdin.fileno() _lowercase : List[str] = termios.tcgetattr(lowerCamelCase_ ) try: tty.setraw(lowerCamelCase_ ) _lowercase : Any = sys.stdin.read(1 ) finally: termios.tcsetattr(lowerCamelCase_ , termios.TCSADRAIN , lowerCamelCase_ ) return ch def UpperCamelCase_( ) -> Dict: _lowercase : List[Any] = get_raw_chars() if ord(lowerCamelCase_ ) in [KEYMAP["interrupt"], KEYMAP["newline"]]: return char elif ord(lowerCamelCase_ ) == KEYMAP["esc"]: _lowercase : Dict = get_raw_chars() if ord(lowerCamelCase_ ) == KEYMAP["mod_int"]: _lowercase : Union[str, Any] = get_raw_chars() if ord(lowerCamelCase_ ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(lowerCamelCase_ ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG: return chr(ord(lowerCamelCase_ ) + ARROW_KEY_FLAG ) else: return KEYMAP["undefined"] else: return get_raw_chars() else: if char in string.printable: return char else: return KEYMAP["undefined"]
21
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 _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) 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 UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): 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) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = 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=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
1
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
1
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
1
import argparse import os import shutil import torch from emmental.modules import MagnitudeBinarizer, ThresholdBinarizer, TopKBinarizer def UpperCamelCase_( lowerCamelCase_ ) -> Tuple: _lowercase : Optional[Any] = args.pruning_method _lowercase : Tuple = args.threshold _lowercase : int = args.model_name_or_path.rstrip('/' ) _lowercase : List[str] = args.target_model_path print(F'''Load fine-pruned model from {model_name_or_path}''' ) _lowercase : Optional[int] = torch.load(os.path.join(lowerCamelCase_ , 'pytorch_model.bin' ) ) _lowercase : Dict = {} for name, tensor in model.items(): if "embeddings" in name or "LayerNorm" in name or "pooler" in name: _lowercase : Union[str, Any] = tensor print(F'''Copied layer {name}''' ) elif "classifier" in name or "qa_output" in name: _lowercase : Optional[Any] = tensor print(F'''Copied layer {name}''' ) elif "bias" in name: _lowercase : Union[str, Any] = tensor print(F'''Copied layer {name}''' ) else: if pruning_method == "magnitude": _lowercase : List[str] = MagnitudeBinarizer.apply(inputs=lowerCamelCase_ , threshold=lowerCamelCase_ ) _lowercase : str = tensor * mask print(F'''Pruned layer {name}''' ) elif pruning_method == "topK": if "mask_scores" in name: continue _lowercase : Dict = name[:-6] _lowercase : Optional[Any] = model[F'''{prefix_}mask_scores'''] _lowercase : Union[str, Any] = TopKBinarizer.apply(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : Union[str, Any] = tensor * mask print(F'''Pruned layer {name}''' ) elif pruning_method == "sigmoied_threshold": if "mask_scores" in name: continue _lowercase : str = name[:-6] _lowercase : Dict = model[F'''{prefix_}mask_scores'''] _lowercase : List[Any] = ThresholdBinarizer.apply(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[Any] = tensor * mask print(F'''Pruned layer {name}''' ) elif pruning_method == "l0": if "mask_scores" in name: continue _lowercase : Optional[Any] = name[:-6] _lowercase : Tuple = model[F'''{prefix_}mask_scores'''] _lowercase , _lowercase : Any = -0.1, 1.1 _lowercase : Dict = torch.sigmoid(lowerCamelCase_ ) _lowercase : List[Any] = s * (r - l) + l _lowercase : Optional[Any] = s_bar.clamp(min=0.0 , max=1.0 ) _lowercase : Optional[Any] = tensor * mask print(F'''Pruned layer {name}''' ) else: raise ValueError('Unknown pruning method' ) if target_model_path is None: _lowercase : Tuple = os.path.join( os.path.dirname(lowerCamelCase_ ) , F'''bertarized_{os.path.basename(lowerCamelCase_ )}''' ) if not os.path.isdir(lowerCamelCase_ ): shutil.copytree(lowerCamelCase_ , lowerCamelCase_ ) print(F'''\nCreated folder {target_model_path}''' ) torch.save(lowerCamelCase_ , os.path.join(lowerCamelCase_ , 'pytorch_model.bin' ) ) print('\nPruned model saved! See you later!' ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : Dict = argparse.ArgumentParser() parser.add_argument( "--pruning_method", choices=["l0", "magnitude", "topK", "sigmoied_threshold"], type=str, required=True, help=( "Pruning Method (l0 = L0 regularization, magnitude = Magnitude pruning, topK = Movement pruning," " sigmoied_threshold = Soft movement pruning)" ), ) parser.add_argument( "--threshold", type=float, required=False, help=( "For `magnitude` and `topK`, it is the level of remaining weights (in %) in the fine-pruned model." "For `sigmoied_threshold`, it is the threshold \tau against which the (sigmoied) scores are compared." "Not needed for `l0`" ), ) parser.add_argument( "--model_name_or_path", type=str, required=True, help="Folder containing the model that was previously fine-pruned", ) parser.add_argument( "--target_model_path", default=None, type=str, required=False, help="Folder containing the model that was previously fine-pruned", ) SCREAMING_SNAKE_CASE : Dict = parser.parse_args() main(args)
21
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
1
import multiprocessing import os from typing import BinaryIO, Optional, Union import fsspec from .. import Dataset, Features, NamedSplit, config from ..formatting import query_table from ..packaged_modules.json.json import Json from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> Tuple: """simple docstring""" super().__init__( lowerCamelCase, split=lowerCamelCase, features=lowerCamelCase, cache_dir=lowerCamelCase, keep_in_memory=lowerCamelCase, streaming=lowerCamelCase, num_proc=lowerCamelCase, **lowerCamelCase, ) _lowercase : Optional[Any] = field _lowercase : Dict = path_or_paths if isinstance(lowerCamelCase, lowerCamelCase) else {self.split: path_or_paths} _lowercase : Tuple = Json( cache_dir=lowerCamelCase, data_files=lowerCamelCase, features=lowerCamelCase, field=lowerCamelCase, **lowerCamelCase, ) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" if self.streaming: _lowercase : str = self.builder.as_streaming_dataset(split=self.split) # Build regular (map-style) dataset else: _lowercase : Any = None _lowercase : List[str] = None _lowercase : Dict = None _lowercase : Tuple = None self.builder.download_and_prepare( download_config=lowerCamelCase, download_mode=lowerCamelCase, verification_mode=lowerCamelCase, base_path=lowerCamelCase, num_proc=self.num_proc, ) _lowercase : Tuple = self.builder.as_dataset( split=self.split, verification_mode=lowerCamelCase, in_memory=self.keep_in_memory) return dataset class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if num_proc is not None and num_proc <= 0: raise ValueError(F'''num_proc {num_proc} must be an integer > 0.''') _lowercase : List[Any] = dataset _lowercase : int = path_or_buf _lowercase : Optional[Any] = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE _lowercase : Dict = num_proc _lowercase : Optional[Any] = 'utf-8' _lowercase : Optional[Any] = to_json_kwargs def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : int = self.to_json_kwargs.pop('path_or_buf', lowerCamelCase) _lowercase : List[Any] = self.to_json_kwargs.pop('orient', 'records') _lowercase : Dict = self.to_json_kwargs.pop('lines', True if orient == 'records' else False) _lowercase : Dict = self.to_json_kwargs.pop('index', False if orient in ['split', 'table'] else True) _lowercase : List[Any] = self.to_json_kwargs.pop('compression', lowerCamelCase) if compression not in [None, "infer", "gzip", "bz2", "xz"]: raise NotImplementedError(F'''`datasets` currently does not support {compression} compression''') if isinstance(self.path_or_buf, (str, bytes, os.PathLike)): with fsspec.open(self.path_or_buf, 'wb', compression=lowerCamelCase) as buffer: _lowercase : Dict = self._write(file_obj=lowerCamelCase, orient=lowerCamelCase, lines=lowerCamelCase, index=lowerCamelCase, **self.to_json_kwargs) else: if compression: raise NotImplementedError( F'''The compression parameter is not supported when writing to a buffer, but compression={compression}''' ' was passed. Please provide a local path instead.') _lowercase : Any = self._write( file_obj=self.path_or_buf, orient=lowerCamelCase, lines=lowerCamelCase, index=lowerCamelCase, **self.to_json_kwargs) return written def UpperCamelCase ( self, lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase , _lowercase , _lowercase , _lowercase : str = args _lowercase : Optional[Any] = query_table( table=self.dataset.data, key=slice(lowerCamelCase, offset + self.batch_size), indices=self.dataset._indices, ) _lowercase : List[Any] = batch.to_pandas().to_json( path_or_buf=lowerCamelCase, orient=lowerCamelCase, lines=lowerCamelCase, index=lowerCamelCase, **lowerCamelCase) if not json_str.endswith('\n'): json_str += "\n" return json_str.encode(self.encoding) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase, ) -> int: """simple docstring""" _lowercase : Any = 0 if self.num_proc is None or self.num_proc == 1: for offset in logging.tqdm( range(0, len(self.dataset), self.batch_size), unit='ba', disable=not logging.is_progress_bar_enabled(), desc='Creating json from Arrow format', ): _lowercase : Dict = self._batch_json((offset, orient, lines, index, to_json_kwargs)) written += file_obj.write(lowerCamelCase) else: _lowercase , _lowercase : Dict = len(self.dataset), self.batch_size with multiprocessing.Pool(self.num_proc) as pool: for json_str in logging.tqdm( pool.imap( self._batch_json, [(offset, orient, lines, index, to_json_kwargs) for offset in range(0, lowerCamelCase, lowerCamelCase)], ), total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size, unit='ba', disable=not logging.is_progress_bar_enabled(), desc='Creating json from Arrow format', ): written += file_obj.write(lowerCamelCase) return written
21
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available SCREAMING_SNAKE_CASE : List[str] = {} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["MLukeTokenizer"] if TYPE_CHECKING: try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mluke import MLukeTokenizer else: import sys SCREAMING_SNAKE_CASE : Union[str, Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
1
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
1
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( SwiftFormerConfig, SwiftFormerForImageClassification, ViTImageProcessor, ) from transformers.utils import logging logging.set_verbosity_info() SCREAMING_SNAKE_CASE : Tuple = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = torch.device("cpu") def UpperCamelCase_( ) -> int: _lowercase : List[Any] = 'http://images.cocodataset.org/val2017/000000039769.jpg' _lowercase : List[Any] = Image.open(requests.get(lowerCamelCase_ , stream=lowerCamelCase_ ).raw ) return im def UpperCamelCase_( lowerCamelCase_ ) -> str: if swiftformer_name == "swiftformer_xs": return torch.tensor([-2.1703e00, 2.1107e00, -2.0811e00, 8.8685e-01, 2.4360e-01] ) elif swiftformer_name == "swiftformer_s": return torch.tensor([3.9636e-01, 2.3478e-01, -1.6963e00, -1.7381e00, -8.6337e-01] ) elif swiftformer_name == "swiftformer_l1": return torch.tensor([-4.2768e-01, -4.7429e-01, -1.0897e00, -1.0248e00, 3.5523e-02] ) elif swiftformer_name == "swiftformer_l3": return torch.tensor([-2.5330e-01, 2.4211e-01, -6.0185e-01, -8.2789e-01, -6.0446e-02] ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> Tuple: _lowercase : List[Any] = dct.pop(lowerCamelCase_ ) _lowercase : List[Any] = val def UpperCamelCase_( lowerCamelCase_ ) -> Any: _lowercase : Dict = [] for k in state_dict.keys(): _lowercase : str = k if ".pwconv" in k: _lowercase : List[str] = k_new.replace('.pwconv' , '.point_wise_conv' ) if ".dwconv" in k: _lowercase : Union[str, Any] = k_new.replace('.dwconv' , '.depth_wise_conv' ) if ".Proj." in k: _lowercase : Optional[int] = k_new.replace('.Proj.' , '.proj.' ) if "patch_embed" in k_new: _lowercase : Optional[Any] = k_new.replace('patch_embed' , 'swiftformer.patch_embed.patch_embedding' ) if "network" in k_new: _lowercase : Tuple = k_new.split('.' ) if ls[2].isdigit(): _lowercase : List[Any] = 'swiftformer.encoder.network.' + ls[1] + '.blocks.' + ls[2] + '.' + '.'.join(ls[3:] ) else: _lowercase : Any = k_new.replace('network' , 'swiftformer.encoder.network' ) rename_keys.append((k, k_new) ) return rename_keys @torch.no_grad() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> Dict: _lowercase : Optional[Any] = SwiftFormerConfig() # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size _lowercase : Any = 1000 _lowercase : Any = 'huggingface/label-files' _lowercase : int = 'imagenet-1k-id2label.json' _lowercase : Optional[int] = json.load(open(hf_hub_download(lowerCamelCase_ , lowerCamelCase_ , repo_type='dataset' ) , 'r' ) ) _lowercase : Dict = {int(lowerCamelCase_ ): v for k, v in idalabel.items()} _lowercase : Dict = idalabel _lowercase : Tuple = {v: k for k, v in idalabel.items()} # size of the architecture if swiftformer_name == "swiftformer_xs": _lowercase : Optional[Any] = [3, 3, 6, 4] _lowercase : List[Any] = [48, 56, 112, 220] elif swiftformer_name == "swiftformer_s": _lowercase : Dict = [3, 3, 9, 6] _lowercase : Optional[Any] = [48, 64, 168, 224] elif swiftformer_name == "swiftformer_l1": _lowercase : Union[str, Any] = [4, 3, 10, 5] _lowercase : List[str] = [48, 96, 192, 384] elif swiftformer_name == "swiftformer_l3": _lowercase : Any = [4, 4, 12, 6] _lowercase : Tuple = [64, 128, 320, 512] # load state_dict of original model, remove and rename some keys if original_ckpt: if original_ckpt.startswith('https' ): _lowercase : List[str] = torch.hub.load_state_dict_from_url(lowerCamelCase_ , map_location='cpu' , check_hash=lowerCamelCase_ ) else: _lowercase : List[Any] = torch.load(lowerCamelCase_ , map_location='cpu' ) _lowercase : Union[str, Any] = checkpoint _lowercase : str = create_rename_keys(lowerCamelCase_ ) for rename_key_src, rename_key_dest in rename_keys: rename_key(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) # load HuggingFace model _lowercase : Tuple = SwiftFormerForImageClassification(lowerCamelCase_ ).eval() hf_model.load_state_dict(lowerCamelCase_ ) # prepare test inputs _lowercase : List[str] = prepare_img() _lowercase : Any = ViTImageProcessor.from_pretrained('preprocessor_config' ) _lowercase : Union[str, Any] = processor(images=lowerCamelCase_ , return_tensors='pt' ) # compare outputs from both models _lowercase : List[Any] = get_expected_output(lowerCamelCase_ ) _lowercase : Any = hf_model(inputs['pixel_values'] ).logits assert hf_logits.shape == torch.Size([1, 1000] ) assert torch.allclose(hf_logits[0, 0:5] , lowerCamelCase_ , atol=1e-3 ) Path(lowerCamelCase_ ).mkdir(exist_ok=lowerCamelCase_ ) print(F'''Saving model {swiftformer_name} to {pytorch_dump_folder_path}''' ) hf_model.save_pretrained(lowerCamelCase_ ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : Any = argparse.ArgumentParser() # Required parameters parser.add_argument( "--swiftformer_name", default="swiftformer_xs", choices=["swiftformer_xs", "swiftformer_s", "swiftformer_l1", "swiftformer_l3"], type=str, help="Name of the SwiftFormer model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default="./converted_outputs/", type=str, help="Path to the output PyTorch model directory.", ) parser.add_argument("--original_ckpt", default=None, type=str, help="Path to the original model checkpoint.") SCREAMING_SNAKE_CASE : int = parser.parse_args() convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)
21
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
1
SCREAMING_SNAKE_CASE : List[str] = { "a": "AAAAA", "b": "AAAAB", "c": "AAABA", "d": "AAABB", "e": "AABAA", "f": "AABAB", "g": "AABBA", "h": "AABBB", "i": "ABAAA", "j": "BBBAA", "k": "ABAAB", "l": "ABABA", "m": "ABABB", "n": "ABBAA", "o": "ABBAB", "p": "ABBBA", "q": "ABBBB", "r": "BAAAA", "s": "BAAAB", "t": "BAABA", "u": "BAABB", "v": "BBBAB", "w": "BABAA", "x": "BABAB", "y": "BABBA", "z": "BABBB", " ": " ", } SCREAMING_SNAKE_CASE : Optional[Any] = {value: key for key, value in encode_dict.items()} def UpperCamelCase_( lowerCamelCase_ ) -> str: _lowercase : Tuple = '' for letter in word.lower(): if letter.isalpha() or letter == " ": encoded += encode_dict[letter] else: raise Exception('encode() accepts only letters of the alphabet and spaces' ) return encoded def UpperCamelCase_( lowerCamelCase_ ) -> str: if set(lowerCamelCase_ ) - {"A", "B", " "} != set(): raise Exception('decode() accepts only \'A\', \'B\' and spaces' ) _lowercase : Dict = '' for word in coded.split(): while len(lowerCamelCase_ ) != 0: decoded += decode_dict[word[:5]] _lowercase : Optional[int] = word[5:] decoded += " " return decoded.strip() if __name__ == "__main__": from doctest import testmod testmod()
21
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
1
from math import factorial, pi def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ = 30 ) -> float: if not isinstance(lowerCamelCase_ , (int, float) ): raise ValueError('maclaurin_sin() requires either an int or float for theta' ) if not isinstance(lowerCamelCase_ , lowerCamelCase_ ) or accuracy <= 0: raise ValueError('maclaurin_sin() requires a positive int for accuracy' ) _lowercase : Dict = float(lowerCamelCase_ ) _lowercase : Union[str, Any] = theta // (2 * pi) theta -= 2 * div * pi return sum( (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1 ) for r in range(lowerCamelCase_ ) ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ = 30 ) -> float: if not isinstance(lowerCamelCase_ , (int, float) ): raise ValueError('maclaurin_cos() requires either an int or float for theta' ) if not isinstance(lowerCamelCase_ , lowerCamelCase_ ) or accuracy <= 0: raise ValueError('maclaurin_cos() requires a positive int for accuracy' ) _lowercase : Union[str, Any] = float(lowerCamelCase_ ) _lowercase : Union[str, Any] = theta // (2 * pi) theta -= 2 * div * pi return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r ) for r in range(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() print(maclaurin_sin(10)) print(maclaurin_sin(-10)) print(maclaurin_sin(10, 15)) print(maclaurin_sin(-10, 15)) print(maclaurin_cos(5)) print(maclaurin_cos(-5)) print(maclaurin_cos(10, 15)) print(maclaurin_cos(-10, 15))
21
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
1
from __future__ import annotations import pandas as pd def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> list[int]: _lowercase : Tuple = [0] * no_of_processes _lowercase : List[Any] = [0] * no_of_processes # Copy the burst time into remaining_time[] for i in range(lowerCamelCase_ ): _lowercase : Optional[int] = burst_time[i] _lowercase : Any = 0 _lowercase : Optional[int] = 0 _lowercase : List[Any] = 9_9999_9999 _lowercase : Dict = 0 _lowercase : List[Any] = False # Process until all processes are completed while complete != no_of_processes: for j in range(lowerCamelCase_ ): if arrival_time[j] <= increment_time and remaining_time[j] > 0: if remaining_time[j] < minm: _lowercase : Union[str, Any] = remaining_time[j] _lowercase : List[Any] = j _lowercase : Optional[Any] = True if not check: increment_time += 1 continue remaining_time[short] -= 1 _lowercase : str = remaining_time[short] if minm == 0: _lowercase : Optional[Any] = 9_9999_9999 if remaining_time[short] == 0: complete += 1 _lowercase : Optional[Any] = False # Find finish time of current process _lowercase : Dict = increment_time + 1 # Calculate waiting time _lowercase : List[str] = finish_time - arrival_time[short] _lowercase : Tuple = finar - burst_time[short] if waiting_time[short] < 0: _lowercase : Optional[Any] = 0 # Increment time increment_time += 1 return waiting_time def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> list[int]: _lowercase : int = [0] * no_of_processes for i in range(lowerCamelCase_ ): _lowercase : Dict = burst_time[i] + waiting_time[i] return turn_around_time def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> None: _lowercase : int = 0 _lowercase : List[Any] = 0 for i in range(lowerCamelCase_ ): _lowercase : int = total_waiting_time + waiting_time[i] _lowercase : Optional[Any] = total_turn_around_time + turn_around_time[i] print(F'''Average waiting time = {total_waiting_time / no_of_processes:.5f}''' ) print('Average turn around time =' , total_turn_around_time / no_of_processes ) if __name__ == "__main__": print("Enter how many process you want to analyze") SCREAMING_SNAKE_CASE : str = int(input()) SCREAMING_SNAKE_CASE : Union[str, Any] = [0] * no_of_processes SCREAMING_SNAKE_CASE : Tuple = [0] * no_of_processes SCREAMING_SNAKE_CASE : Optional[Any] = list(range(1, no_of_processes + 1)) for i in range(no_of_processes): print("Enter the arrival time and burst time for process:--" + str(i + 1)) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = map(int, input().split()) SCREAMING_SNAKE_CASE : List[Any] = calculate_waitingtime(arrival_time, burst_time, no_of_processes) SCREAMING_SNAKE_CASE : Any = burst_time SCREAMING_SNAKE_CASE : str = no_of_processes SCREAMING_SNAKE_CASE : str = waiting_time SCREAMING_SNAKE_CASE : Tuple = calculate_turnaroundtime(bt, n, wt) calculate_average_times(waiting_time, turn_around_time, no_of_processes) SCREAMING_SNAKE_CASE : Dict = pd.DataFrame( list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)), columns=[ "Process", "BurstTime", "ArrivalTime", "WaitingTime", "TurnAroundTime", ], ) # Printing the dataFrame pd.set_option("display.max_rows", fcfs.shape[0] + 1) print(fcfs)
21
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
1
from unittest.mock import patch import pyspark from datasets.packaged_modules.spark.spark import ( Spark, SparkExamplesIterable, _generate_iterable_examples, ) from ..utils import ( require_dill_gt_0_3_2, require_not_windows, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : List[Any] = [] for part_id in partition_order: _lowercase : List[str] = df.where(F'''SPARK_PARTITION_ID() = {part_id}''' ).collect() for row_idx, row in enumerate(lowerCamelCase_ ): expected_row_ids_and_row_dicts.append((F'''{part_id}_{row_idx}''', row.asDict()) ) return expected_row_ids_and_row_dicts @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> Union[str, Any]: _lowercase : Optional[int] = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : Any = spark.range(100 ).repartition(1 ) _lowercase : int = Spark(lowerCamelCase_ ) # The id ints will be converted to Pyarrow int64s, so each row will be 8 bytes. Setting a max_shard_size of 16 means # that each partition can hold 2 rows. spark_builder._repartition_df_if_needed(max_shard_size=16 ) # Given that the dataframe has 100 rows and each partition has 2 rows, we expect 50 partitions. assert spark_builder.df.rdd.getNumPartitions() == 50 @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> str: _lowercase : Any = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : Union[str, Any] = spark.range(10 ).repartition(2 ) _lowercase : Optional[Any] = [1, 0] _lowercase : int = _generate_iterable_examples(lowerCamelCase_ , lowerCamelCase_ ) # Reverse the partitions. _lowercase : Tuple = _get_expected_row_ids_and_row_dicts_for_partition_order(lowerCamelCase_ , lowerCamelCase_ ) for i, (row_id, row_dict) in enumerate(generate_fn() ): _lowercase , _lowercase : Tuple = expected_row_ids_and_row_dicts[i] assert row_id == expected_row_id assert row_dict == expected_row_dict @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> Tuple: _lowercase : Optional[Any] = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : Dict = spark.range(10 ).repartition(1 ) _lowercase : Any = SparkExamplesIterable(lowerCamelCase_ ) assert it.n_shards == 1 for i, (row_id, row_dict) in enumerate(lowerCamelCase_ ): assert row_id == F'''0_{i}''' assert row_dict == {"id": i} @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> str: _lowercase : Optional[int] = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : str = spark.range(30 ).repartition(3 ) # Mock the generator so that shuffle reverses the partition indices. with patch('numpy.random.Generator' ) as generator_mock: _lowercase : Dict = lambda lowerCamelCase_ : x.reverse() _lowercase : Dict = _get_expected_row_ids_and_row_dicts_for_partition_order(lowerCamelCase_ , [2, 1, 0] ) _lowercase : Dict = SparkExamplesIterable(lowerCamelCase_ ).shuffle_data_sources(lowerCamelCase_ ) assert shuffled_it.n_shards == 3 for i, (row_id, row_dict) in enumerate(lowerCamelCase_ ): _lowercase , _lowercase : Any = expected_row_ids_and_row_dicts[i] assert row_id == expected_row_id assert row_dict == expected_row_dict @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> Union[str, Any]: _lowercase : List[str] = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : int = spark.range(20 ).repartition(4 ) # Partitions 0 and 2 _lowercase : Any = SparkExamplesIterable(lowerCamelCase_ ).shard_data_sources(worker_id=0 , num_workers=2 ) assert shard_it_a.n_shards == 2 _lowercase : List[Any] = _get_expected_row_ids_and_row_dicts_for_partition_order(lowerCamelCase_ , [0, 2] ) for i, (row_id, row_dict) in enumerate(lowerCamelCase_ ): _lowercase , _lowercase : Dict = expected_row_ids_and_row_dicts_a[i] assert row_id == expected_row_id assert row_dict == expected_row_dict # Partitions 1 and 3 _lowercase : Union[str, Any] = SparkExamplesIterable(lowerCamelCase_ ).shard_data_sources(worker_id=1 , num_workers=2 ) assert shard_it_a.n_shards == 2 _lowercase : str = _get_expected_row_ids_and_row_dicts_for_partition_order(lowerCamelCase_ , [1, 3] ) for i, (row_id, row_dict) in enumerate(lowerCamelCase_ ): _lowercase , _lowercase : Union[str, Any] = expected_row_ids_and_row_dicts_a[i] assert row_id == expected_row_id assert row_dict == expected_row_dict @require_not_windows @require_dill_gt_0_3_2 def UpperCamelCase_( ) -> Optional[int]: _lowercase : Union[str, Any] = pyspark.sql.SparkSession.builder.master('local[*]' ).appName('pyspark' ).getOrCreate() _lowercase : List[str] = spark.range(100 ).repartition(1 ) _lowercase : Dict = Spark(lowerCamelCase_ ) # Choose a small max_shard_size for maximum partitioning. spark_builder._repartition_df_if_needed(max_shard_size=1 ) # The new number of partitions should not be greater than the number of rows. assert spark_builder.df.rdd.getNumPartitions() == 100
21
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.') if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
1
import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : Tuple = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = { "salesforce/blip2-opt-2.7b": "https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json", } class _lowerCamelCase( _a ): lowercase_ : int = """blip_2_vision_model""" def __init__( self, lowerCamelCase=14_08, lowerCamelCase=61_44, lowerCamelCase=39, lowerCamelCase=16, lowerCamelCase=2_24, lowerCamelCase=14, lowerCamelCase="gelu", lowerCamelCase=0.0_0_0_0_1, lowerCamelCase=0.0, lowerCamelCase=1E-10, lowerCamelCase=True, **lowerCamelCase, ) -> str: """simple docstring""" super().__init__(**lowerCamelCase) _lowercase : Tuple = hidden_size _lowercase : Tuple = intermediate_size _lowercase : Optional[int] = num_hidden_layers _lowercase : Tuple = num_attention_heads _lowercase : List[Any] = patch_size _lowercase : List[str] = image_size _lowercase : Dict = initializer_range _lowercase : str = attention_dropout _lowercase : Tuple = layer_norm_eps _lowercase : List[Any] = hidden_act _lowercase : Optional[Any] = qkv_bias @classmethod def UpperCamelCase ( cls, lowerCamelCase, **lowerCamelCase) -> "PretrainedConfig": """simple docstring""" cls._set_token_in_kwargs(lowerCamelCase) _lowercase , _lowercase : Dict = cls.get_config_dict(lowerCamelCase, **lowerCamelCase) # get the vision config dict if we are loading from Blip2Config if config_dict.get('model_type') == "blip-2": _lowercase : Tuple = config_dict['vision_config'] if "model_type" in config_dict and hasattr(cls, 'model_type') and config_dict["model_type"] != cls.model_type: logger.warning( F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type ''' F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''') return cls.from_dict(lowerCamelCase, **lowerCamelCase) class _lowerCamelCase( _a ): lowercase_ : List[Any] = """blip_2_qformer""" def __init__( self, lowerCamelCase=3_05_22, lowerCamelCase=7_68, lowerCamelCase=12, lowerCamelCase=12, lowerCamelCase=30_72, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=0.0_2, lowerCamelCase=1E-12, lowerCamelCase=0, lowerCamelCase="absolute", lowerCamelCase=2, lowerCamelCase=14_08, **lowerCamelCase, ) -> Tuple: """simple docstring""" super().__init__(pad_token_id=lowerCamelCase, **lowerCamelCase) _lowercase : Any = vocab_size _lowercase : int = hidden_size _lowercase : List[str] = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : Dict = hidden_act _lowercase : str = intermediate_size _lowercase : Optional[int] = hidden_dropout_prob _lowercase : str = attention_probs_dropout_prob _lowercase : int = max_position_embeddings _lowercase : Dict = initializer_range _lowercase : Optional[int] = layer_norm_eps _lowercase : Tuple = position_embedding_type _lowercase : Tuple = cross_attention_frequency _lowercase : List[Any] = encoder_hidden_size @classmethod def UpperCamelCase ( cls, lowerCamelCase, **lowerCamelCase) -> "PretrainedConfig": """simple docstring""" cls._set_token_in_kwargs(lowerCamelCase) _lowercase , _lowercase : int = cls.get_config_dict(lowerCamelCase, **lowerCamelCase) # get the qformer config dict if we are loading from Blip2Config if config_dict.get('model_type') == "blip-2": _lowercase : str = config_dict['qformer_config'] if "model_type" in config_dict and hasattr(cls, 'model_type') and config_dict["model_type"] != cls.model_type: logger.warning( F'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type ''' F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''') return cls.from_dict(lowerCamelCase, **lowerCamelCase) class _lowerCamelCase( _a ): lowercase_ : Dict = """blip-2""" lowercase_ : Union[str, Any] = True def __init__( self, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=32, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" super().__init__(**lowerCamelCase) if vision_config is None: _lowercase : List[Any] = {} logger.info('vision_config is None. initializing the Blip2VisionConfig with default values.') if qformer_config is None: _lowercase : str = {} logger.info('qformer_config is None. Initializing the Blip2QFormerConfig with default values.') if text_config is None: _lowercase : Tuple = {} logger.info('text_config is None. Initializing the text config with default values (`OPTConfig`).') _lowercase : Tuple = BlipaVisionConfig(**lowerCamelCase) _lowercase : List[Any] = BlipaQFormerConfig(**lowerCamelCase) _lowercase : Tuple = text_config['model_type'] if 'model_type' in text_config else 'opt' _lowercase : Optional[Any] = CONFIG_MAPPING[text_model_type](**lowerCamelCase) _lowercase : Optional[int] = self.text_config.tie_word_embeddings _lowercase : int = self.text_config.is_encoder_decoder _lowercase : List[Any] = num_query_tokens _lowercase : Dict = self.vision_config.hidden_size _lowercase : Any = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES _lowercase : Union[str, Any] = 1.0 _lowercase : List[str] = 0.0_2 @classmethod def UpperCamelCase ( cls, lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase, ) -> Union[str, Any]: """simple docstring""" return cls( vision_config=vision_config.to_dict(), qformer_config=qformer_config.to_dict(), text_config=text_config.to_dict(), **lowerCamelCase, ) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Tuple = copy.deepcopy(self.__dict__) _lowercase : Union[str, Any] = self.vision_config.to_dict() _lowercase : Optional[Any] = self.qformer_config.to_dict() _lowercase : Dict = self.text_config.to_dict() _lowercase : int = self.__class__.model_type return output
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
import unittest from datasets import load_dataset from transformers import BloomTokenizerFast from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Tuple = None lowercase_ : Tuple = BloomTokenizerFast lowercase_ : Optional[int] = BloomTokenizerFast lowercase_ : int = True lowercase_ : str = False lowercase_ : Dict = """tokenizer_file""" lowercase_ : int = {"""bos_token""": """<s>""", """eos_token""": """</s>""", """unk_token""": """<unk>""", """pad_token""": """<pad>"""} def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().setUp() _lowercase : str = BloomTokenizerFast.from_pretrained('bigscience/tokenizer') tokenizer.save_pretrained(self.tmpdirname) def UpperCamelCase ( self, **lowerCamelCase) -> List[Any]: """simple docstring""" kwargs.update(self.special_tokens_map) return BloomTokenizerFast.from_pretrained(self.tmpdirname, **lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.get_rust_tokenizer() _lowercase : Any = ['The quick brown fox</s>', 'jumps over the lazy dog</s>'] _lowercase : List[str] = [[21_75, 2_37_14, 7_31_73, 14_42_52, 2], [77, 13_26_19, 34_78, 3_68, 10_95_86, 3_54_33, 2]] _lowercase : List[str] = tokenizer.batch_encode_plus(lowerCamelCase)['input_ids'] self.assertListEqual(lowerCamelCase, lowerCamelCase) _lowercase : Dict = tokenizer.batch_decode(lowerCamelCase) self.assertListEqual(lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase=6) -> List[str]: """simple docstring""" for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''): _lowercase : Optional[int] = self.rust_tokenizer_class.from_pretrained(lowerCamelCase, **lowerCamelCase) # tokenizer_r.pad_token = None # Hotfixing padding = None # Simple input _lowercase : Any = 'This is a simple input' _lowercase : Union[str, Any] = ['This is a simple input 1', 'This is a simple input 2'] _lowercase : Optional[int] = ('This is a simple input', 'This is a pair') _lowercase : Tuple = [ ('This is a simple input 1', 'This is a simple input 2'), ('This is a simple pair 1', 'This is a simple pair 2'), ] # Simple input tests try: tokenizer_r.encode(lowerCamelCase, max_length=lowerCamelCase) tokenizer_r.encode_plus(lowerCamelCase, max_length=lowerCamelCase) tokenizer_r.batch_encode_plus(lowerCamelCase, max_length=lowerCamelCase) tokenizer_r.encode(lowerCamelCase, max_length=lowerCamelCase) tokenizer_r.batch_encode_plus(lowerCamelCase, max_length=lowerCamelCase) except ValueError: self.fail('Bloom Tokenizer should be able to deal with padding') _lowercase : Union[str, Any] = None # Hotfixing padding = None self.assertRaises(lowerCamelCase, tokenizer_r.encode, lowerCamelCase, max_length=lowerCamelCase, padding='max_length') # Simple input self.assertRaises(lowerCamelCase, tokenizer_r.encode_plus, lowerCamelCase, max_length=lowerCamelCase, padding='max_length') # Simple input self.assertRaises( lowerCamelCase, tokenizer_r.batch_encode_plus, lowerCamelCase, max_length=lowerCamelCase, padding='max_length', ) # Pair input self.assertRaises(lowerCamelCase, tokenizer_r.encode, lowerCamelCase, max_length=lowerCamelCase, padding='max_length') # Pair input self.assertRaises(lowerCamelCase, tokenizer_r.encode_plus, lowerCamelCase, max_length=lowerCamelCase, padding='max_length') # Pair input self.assertRaises( lowerCamelCase, tokenizer_r.batch_encode_plus, lowerCamelCase, max_length=lowerCamelCase, padding='max_length', ) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = self.get_rust_tokenizer() _lowercase : Optional[int] = load_dataset('xnli', 'all_languages', split='test', streaming=lowerCamelCase) _lowercase : Optional[Any] = next(iter(lowerCamelCase))['premise'] # pick up one data _lowercase : Optional[int] = list(sample_data.values()) _lowercase : List[str] = list(map(tokenizer.encode, lowerCamelCase)) _lowercase : Dict = [tokenizer.decode(lowerCamelCase, clean_up_tokenization_spaces=lowerCamelCase) for x in output_tokens] self.assertListEqual(lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map), 1) self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values())[0]), 1)
21
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
1
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 _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : str = IFInpaintingSuperResolutionPipeline lowercase_ : Union[str, Any] = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""} lowercase_ : str = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""} ) lowercase_ : int = PipelineTesterMixin.required_optional_params - {"""latents"""} def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" return self._get_superresolution_dummy_components() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Optional[int]: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) else: _lowercase : List[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Any = floats_tensor((1, 3, 16, 16), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = floats_tensor((1, 3, 32, 32), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : str = floats_tensor((1, 3, 32, 32), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Union[str, Any] = { '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 UpperCamelCase ( self) -> Dict: """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3) def UpperCamelCase ( self) -> str: """simple docstring""" self._test_save_load_optional_components() @unittest.skipIf(torch_device != 'cuda', reason='float16 requires CUDA') def UpperCamelCase ( self) -> List[str]: """simple docstring""" super().test_save_load_floataa(expected_max_diff=1E-1) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self._test_attention_slicing_forward_pass(expected_max_diff=1E-2) def UpperCamelCase ( self) -> Tuple: """simple docstring""" self._test_save_load_local() def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self._test_inference_batch_single_identical( expected_max_diff=1E-2, )
21
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
1
def UpperCamelCase_( lowerCamelCase_ = 100 ) -> int: _lowercase : int = set() _lowercase : str = 0 _lowercase : int = n + 1 # maximum limit for a in range(2 , lowerCamelCase_ ): for b in range(2 , lowerCamelCase_ ): _lowercase : Tuple = a**b # calculates the current power collect_powers.add(lowerCamelCase_ ) # adds the result to the set return len(lowerCamelCase_ ) if __name__ == "__main__": print("Number of terms ", solution(int(str(input()).strip())))
21
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
1
import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import MgpstrTokenizer from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES from transformers.testing_utils import require_torch, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import MgpstrProcessor, ViTImageProcessor @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): lowercase_ : Optional[Any] = ViTImageProcessor if is_vision_available() else None @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = (3, 32, 1_28) _lowercase : str = tempfile.mkdtemp() # fmt: off _lowercase : Tuple = ['[GO]', '[s]', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] # fmt: on _lowercase : Optional[Any] = dict(zip(lowerCamelCase, range(len(lowerCamelCase)))) _lowercase : Union[str, Any] = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['vocab_file']) with open(self.vocab_file, 'w', encoding='utf-8') as fp: fp.write(json.dumps(lowerCamelCase) + '\n') _lowercase : List[Any] = { 'do_normalize': False, 'do_resize': True, 'image_processor_type': 'ViTImageProcessor', 'resample': 3, 'size': {'height': 32, 'width': 1_28}, } _lowercase : Any = os.path.join(self.tmpdirname, lowerCamelCase) with open(self.image_processor_file, 'w', encoding='utf-8') as fp: json.dump(lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, **lowerCamelCase) -> int: """simple docstring""" return MgpstrTokenizer.from_pretrained(self.tmpdirname, **lowerCamelCase) def UpperCamelCase ( self, **lowerCamelCase) -> Optional[Any]: """simple docstring""" return ViTImageProcessor.from_pretrained(self.tmpdirname, **lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" shutil.rmtree(self.tmpdirname) def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : List[str] = np.random.randint(2_55, size=(3, 30, 4_00), dtype=np.uinta) _lowercase : Union[str, Any] = Image.fromarray(np.moveaxis(lowerCamelCase, 0, -1)) return image_input def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : int = self.get_tokenizer() _lowercase : Any = self.get_image_processor() _lowercase : Any = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) processor.save_pretrained(self.tmpdirname) _lowercase : Optional[int] = MgpstrProcessor.from_pretrained(self.tmpdirname, use_fast=lowerCamelCase) self.assertEqual(processor.char_tokenizer.get_vocab(), tokenizer.get_vocab()) self.assertIsInstance(processor.char_tokenizer, lowerCamelCase) self.assertEqual(processor.image_processor.to_json_string(), image_processor.to_json_string()) self.assertIsInstance(processor.image_processor, lowerCamelCase) def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : str = self.get_tokenizer() _lowercase : Any = self.get_image_processor() _lowercase : str = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) processor.save_pretrained(self.tmpdirname) _lowercase : List[str] = self.get_tokenizer(bos_token='(BOS)', eos_token='(EOS)') _lowercase : Optional[int] = self.get_image_processor(do_normalize=lowerCamelCase, padding_value=1.0) _lowercase : Dict = MgpstrProcessor.from_pretrained( self.tmpdirname, bos_token='(BOS)', eos_token='(EOS)', do_normalize=lowerCamelCase, padding_value=1.0) self.assertEqual(processor.char_tokenizer.get_vocab(), tokenizer_add_kwargs.get_vocab()) self.assertIsInstance(processor.char_tokenizer, lowerCamelCase) self.assertEqual(processor.image_processor.to_json_string(), image_processor_add_kwargs.to_json_string()) self.assertIsInstance(processor.image_processor, lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : int = self.get_image_processor() _lowercase : List[Any] = self.get_tokenizer() _lowercase : Dict = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : Any = self.prepare_image_inputs() _lowercase : str = image_processor(lowerCamelCase, return_tensors='np') _lowercase : Optional[Any] = processor(images=lowerCamelCase, return_tensors='np') for key in input_image_proc.keys(): self.assertAlmostEqual(input_image_proc[key].sum(), input_processor[key].sum(), delta=1E-2) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Dict = self.get_image_processor() _lowercase : List[Any] = self.get_tokenizer() _lowercase : Dict = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : Tuple = 'test' _lowercase : List[str] = processor(text=lowerCamelCase) _lowercase : List[str] = tokenizer(lowerCamelCase) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key], encoded_processor[key]) def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : int = self.get_image_processor() _lowercase : List[Any] = self.get_tokenizer() _lowercase : List[Any] = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : Optional[Any] = 'test' _lowercase : List[Any] = self.prepare_image_inputs() _lowercase : Any = processor(text=lowerCamelCase, images=lowerCamelCase) self.assertListEqual(list(inputs.keys()), ['pixel_values', 'labels']) # test if it raises when no input is passed with pytest.raises(lowerCamelCase): processor() def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[int] = self.get_image_processor() _lowercase : int = self.get_tokenizer() _lowercase : Optional[int] = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : Optional[Any] = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]] _lowercase : Dict = processor.char_decode(lowerCamelCase) _lowercase : List[str] = tokenizer.batch_decode(lowerCamelCase) _lowercase : Dict = [seq.replace(' ', '') for seq in decoded_tok] self.assertListEqual(lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Union[str, Any] = self.get_image_processor() _lowercase : Optional[Any] = self.get_tokenizer() _lowercase : Union[str, Any] = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : Dict = None _lowercase : Dict = self.prepare_image_inputs() _lowercase : int = processor(text=lowerCamelCase, images=lowerCamelCase) self.assertListEqual(list(inputs.keys()), processor.model_input_names) def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Dict = self.get_image_processor() _lowercase : Optional[Any] = self.get_tokenizer() _lowercase : List[str] = MgpstrProcessor(tokenizer=lowerCamelCase, image_processor=lowerCamelCase) _lowercase : str = torch.randn(1, 27, 38) _lowercase : List[Any] = torch.randn(1, 27, 5_02_57) _lowercase : List[Any] = torch.randn(1, 27, 3_05_22) _lowercase : List[str] = processor.batch_decode([char_input, bpe_input, wp_input]) self.assertListEqual(list(results.keys()), ['generated_text', 'scores', 'char_preds', 'bpe_preds', 'wp_preds'])
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available SCREAMING_SNAKE_CASE : Optional[int] = {"tokenization_herbert": ["HerbertTokenizer"]} try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[int] = ["HerbertTokenizerFast"] if TYPE_CHECKING: from .tokenization_herbert import HerbertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_herbert_fast import HerbertTokenizerFast else: import sys SCREAMING_SNAKE_CASE : str = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
1
from __future__ import annotations from scipy.special import comb # type: ignore class _lowerCamelCase: def __init__( self, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = list_of_points # Degree determines the flexibility of the curve. # Degree = 1 will produce a straight line. _lowercase : List[str] = len(lowerCamelCase) - 1 def UpperCamelCase ( self, lowerCamelCase) -> list[float]: """simple docstring""" assert 0 <= t <= 1, "Time t must be between 0 and 1." _lowercase : list[float] = [] for i in range(len(self.list_of_points)): # basis function for each i output_values.append( comb(self.degree, lowerCamelCase) * ((1 - t) ** (self.degree - i)) * (t**i)) # the basis must sum up to 1 for it to produce a valid Bezier curve. assert round(sum(lowerCamelCase), 5) == 1 return output_values def UpperCamelCase ( self, lowerCamelCase) -> tuple[float, float]: """simple docstring""" assert 0 <= t <= 1, "Time t must be between 0 and 1." _lowercase : Optional[int] = self.basis_function(lowerCamelCase) _lowercase : Optional[int] = 0.0 _lowercase : Optional[Any] = 0.0 for i in range(len(self.list_of_points)): # For all points, sum up the product of i-th basis function and i-th point. x += basis_function[i] * self.list_of_points[i][0] y += basis_function[i] * self.list_of_points[i][1] return (x, y) def UpperCamelCase ( self, lowerCamelCase = 0.0_1) -> int: """simple docstring""" from matplotlib import pyplot as plt # type: ignore _lowercase : list[float] = [] # x coordinates of points to plot _lowercase : list[float] = [] # y coordinates of points to plot _lowercase : str = 0.0 while t <= 1: _lowercase : List[Any] = self.bezier_curve_function(lowerCamelCase) to_plot_x.append(value[0]) to_plot_y.append(value[1]) t += step_size _lowercase : List[str] = [i[0] for i in self.list_of_points] _lowercase : Dict = [i[1] for i in self.list_of_points] plt.plot( lowerCamelCase, lowerCamelCase, color='blue', label='Curve of Degree ' + str(self.degree), ) plt.scatter(lowerCamelCase, lowerCamelCase, color='red', label='Control Points') plt.legend() plt.show() if __name__ == "__main__": import doctest doctest.testmod() BezierCurve([(1, 2), (3, 5)]).plot_curve() # degree 1 BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve() # degree 2 BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve() # degree 3
21
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
1
import torch from diffusers import StableDiffusionPipeline SCREAMING_SNAKE_CASE : str = "path-to-your-trained-model" SCREAMING_SNAKE_CASE : Optional[int] = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to("cuda") SCREAMING_SNAKE_CASE : Any = "A photo of sks dog in a bucket" SCREAMING_SNAKE_CASE : List[str] = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0] image.save("dog-bucket.png")
21
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) SCREAMING_SNAKE_CASE : str = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["ViTFeatureExtractor"] SCREAMING_SNAKE_CASE : str = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Any = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
1
import unittest import numpy as np import timeout_decorator # noqa from transformers import BlenderbotConfig, is_flax_available from transformers.testing_utils import jax_device, require_flax, slow from ...generation.test_flax_utils import FlaxGenerationTesterMixin from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor if is_flax_available(): import os # The slow tests are often failing with OOM error on GPU # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html SCREAMING_SNAKE_CASE : str = "platform" import jax import jax.numpy as jnp from transformers import BlenderbotTokenizer from transformers.models.blenderbot.modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, shift_tokens_right, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=None , lowerCamelCase_=None , lowerCamelCase_=None , lowerCamelCase_=None , lowerCamelCase_=None , lowerCamelCase_=None , ) -> List[str]: if attention_mask is None: _lowercase : int = np.where(input_ids != config.pad_token_id , 1 , 0 ) if decoder_attention_mask is None: _lowercase : Optional[Any] = np.where(decoder_input_ids != config.pad_token_id , 1 , 0 ) if head_mask is None: _lowercase : Dict = np.ones((config.encoder_layers, config.encoder_attention_heads) ) if decoder_head_mask is None: _lowercase : Optional[int] = np.ones((config.decoder_layers, config.decoder_attention_heads) ) if cross_attn_head_mask is None: _lowercase : List[str] = np.ones((config.decoder_layers, config.decoder_attention_heads) ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": attention_mask, } class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=99, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=32, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=0, lowerCamelCase=0.0_2, ) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = parent _lowercase : Any = batch_size _lowercase : List[str] = seq_length _lowercase : Union[str, Any] = is_training _lowercase : Optional[Any] = use_labels _lowercase : Tuple = vocab_size _lowercase : Tuple = hidden_size _lowercase : List[str] = num_hidden_layers _lowercase : Union[str, Any] = num_attention_heads _lowercase : Optional[int] = intermediate_size _lowercase : List[Any] = hidden_act _lowercase : Dict = hidden_dropout_prob _lowercase : Any = attention_probs_dropout_prob _lowercase : Union[str, Any] = max_position_embeddings _lowercase : Tuple = eos_token_id _lowercase : List[Any] = pad_token_id _lowercase : Dict = bos_token_id _lowercase : List[Any] = initializer_range def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = np.clip(ids_tensor([self.batch_size, self.seq_length - 1], self.vocab_size), 3, self.vocab_size) _lowercase : str = np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1), dtype=np.intaa)), -1) _lowercase : Union[str, Any] = shift_tokens_right(lowerCamelCase, 1, 2) _lowercase : Optional[Any] = BlenderbotConfig( vocab_size=self.vocab_size, d_model=self.hidden_size, 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, max_position_embeddings=self.max_position_embeddings, eos_token_id=self.eos_token_id, bos_token_id=self.bos_token_id, pad_token_id=self.pad_token_id, initializer_range=self.initializer_range, use_cache=lowerCamelCase, ) _lowercase : List[Any] = prepare_blenderbot_inputs_dict(lowerCamelCase, lowerCamelCase, lowerCamelCase) return config, inputs_dict def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.prepare_config_and_inputs() return config, inputs_dict def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[Any]: """simple docstring""" _lowercase : int = 20 _lowercase : Any = model_class_name(lowerCamelCase) _lowercase : Any = model.encode(inputs_dict['input_ids']) _lowercase , _lowercase : Optional[int] = ( inputs_dict['decoder_input_ids'], inputs_dict['decoder_attention_mask'], ) _lowercase : str = model.init_cache(decoder_input_ids.shape[0], lowerCamelCase, lowerCamelCase) _lowercase : Tuple = jnp.ones((decoder_input_ids.shape[0], max_decoder_length), dtype='i4') _lowercase : Optional[int] = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :], (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1), ) _lowercase : Optional[Any] = model.decode( decoder_input_ids[:, :-1], lowerCamelCase, decoder_attention_mask=lowerCamelCase, past_key_values=lowerCamelCase, decoder_position_ids=lowerCamelCase, ) _lowercase : Union[str, Any] = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]], dtype='i4') _lowercase : List[str] = model.decode( decoder_input_ids[:, -1:], lowerCamelCase, decoder_attention_mask=lowerCamelCase, past_key_values=outputs_cache.past_key_values, decoder_position_ids=lowerCamelCase, ) _lowercase : Tuple = model.decode(lowerCamelCase, lowerCamelCase) _lowercase : Union[str, Any] = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]))) self.parent.assertTrue(diff < 1E-3, msg=F'''Max diff is {diff}''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Union[str, Any] = 20 _lowercase : List[str] = model_class_name(lowerCamelCase) _lowercase : int = model.encode(inputs_dict['input_ids']) _lowercase , _lowercase : Any = ( inputs_dict['decoder_input_ids'], inputs_dict['decoder_attention_mask'], ) _lowercase : str = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])), ], axis=-1, ) _lowercase : Any = model.init_cache(decoder_input_ids.shape[0], lowerCamelCase, lowerCamelCase) _lowercase : str = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :], (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1), ) _lowercase : Optional[Any] = model.decode( decoder_input_ids[:, :-1], lowerCamelCase, decoder_attention_mask=lowerCamelCase, past_key_values=lowerCamelCase, decoder_position_ids=lowerCamelCase, ) _lowercase : str = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]], dtype='i4') _lowercase : List[str] = model.decode( decoder_input_ids[:, -1:], lowerCamelCase, past_key_values=outputs_cache.past_key_values, decoder_attention_mask=lowerCamelCase, decoder_position_ids=lowerCamelCase, ) _lowercase : List[Any] = model.decode(lowerCamelCase, lowerCamelCase, decoder_attention_mask=lowerCamelCase) _lowercase : List[str] = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]))) self.parent.assertTrue(diff < 1E-3, msg=F'''Max diff is {diff}''') @require_flax class _lowerCamelCase( unittest.TestCase ): lowercase_ : str = 99 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[Any] = np.array( [ [71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 82, 2], [5, 97, 17, 39, 94, 40, 2], [76, 83, 94, 25, 70, 78, 2], [87, 59, 41, 35, 48, 66, 2], [55, 13, 16, 58, 5, 2, 1], # note padding [64, 27, 31, 51, 12, 75, 2], [52, 64, 86, 17, 83, 39, 2], [48, 61, 9, 24, 71, 82, 2], [26, 1, 60, 48, 22, 13, 2], [21, 5, 62, 28, 14, 76, 2], [45, 98, 37, 86, 59, 48, 2], [70, 70, 50, 9, 28, 0, 2], ], dtype=np.intaa, ) _lowercase : Optional[int] = input_ids.shape[0] _lowercase : int = BlenderbotConfig( vocab_size=self.vocab_size, d_model=24, encoder_layers=2, decoder_layers=2, encoder_attention_heads=2, decoder_attention_heads=2, encoder_ffn_dim=32, decoder_ffn_dim=32, max_position_embeddings=48, eos_token_id=2, pad_token_id=1, bos_token_id=0, ) return config, input_ids, batch_size def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase , _lowercase : Dict = self._get_config_and_data() _lowercase : Dict = FlaxBlenderbotForConditionalGeneration(lowerCamelCase) _lowercase : Union[str, Any] = lm_model(input_ids=lowerCamelCase) _lowercase : Tuple = (batch_size, input_ids.shape[1], config.vocab_size) self.assertEqual(outputs['logits'].shape, lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Union[str, Any] = BlenderbotConfig( vocab_size=self.vocab_size, d_model=14, encoder_layers=2, decoder_layers=2, encoder_attention_heads=2, decoder_attention_heads=2, encoder_ffn_dim=8, decoder_ffn_dim=8, max_position_embeddings=48, ) _lowercase : str = FlaxBlenderbotForConditionalGeneration(lowerCamelCase) _lowercase : Optional[Any] = np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]], dtype=np.intaa) _lowercase : Optional[Any] = np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]], dtype=np.intaa) _lowercase : Dict = lm_model(input_ids=lowerCamelCase, decoder_input_ids=lowerCamelCase) _lowercase : Any = (*summary.shape, config.vocab_size) self.assertEqual(outputs['logits'].shape, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Union[str, Any] = np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]], dtype=np.intaa) _lowercase : List[Any] = shift_tokens_right(lowerCamelCase, 1, 2) _lowercase : List[Any] = np.equal(lowerCamelCase, 1).astype(np.floataa).sum() _lowercase : List[Any] = np.equal(lowerCamelCase, 1).astype(np.floataa).sum() self.assertEqual(shifted.shape, input_ids.shape) self.assertEqual(lowerCamelCase, n_pad_before - 1) self.assertTrue(np.equal(shifted[:, 0], 2).all()) @require_flax class _lowerCamelCase( _a, unittest.TestCase, _a ): lowercase_ : int = True lowercase_ : Optional[Any] = ( ( FlaxBlenderbotModel, FlaxBlenderbotForConditionalGeneration, ) if is_flax_available() else () ) lowercase_ : List[Any] = (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else () def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : int = FlaxBlenderbotModelTester(self) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Tuple = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase , _lowercase : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__): _lowercase : Any = self._prepare_for_class(lowerCamelCase, lowerCamelCase) _lowercase : str = model_class(lowerCamelCase) @jax.jit def encode_jitted(lowerCamelCase, lowerCamelCase=None, **lowerCamelCase): return model.encode(input_ids=lowerCamelCase, attention_mask=lowerCamelCase) with self.subTest('JIT Enabled'): _lowercase : Any = encode_jitted(**lowerCamelCase).to_tuple() with self.subTest('JIT Disabled'): with jax.disable_jit(): _lowercase : List[Any] = encode_jitted(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase)) for jitted_output, output in zip(lowerCamelCase, lowerCamelCase): self.assertEqual(jitted_output.shape, output.shape) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__): _lowercase : List[str] = model_class(lowerCamelCase) _lowercase : Optional[Any] = model.encode(inputs_dict['input_ids'], inputs_dict['attention_mask']) _lowercase : str = { 'decoder_input_ids': inputs_dict['decoder_input_ids'], 'decoder_attention_mask': inputs_dict['decoder_attention_mask'], 'encoder_outputs': encoder_outputs, } @jax.jit def decode_jitted(lowerCamelCase, lowerCamelCase, lowerCamelCase): return model.decode( decoder_input_ids=lowerCamelCase, decoder_attention_mask=lowerCamelCase, encoder_outputs=lowerCamelCase, ) with self.subTest('JIT Enabled'): _lowercase : List[Any] = decode_jitted(**lowerCamelCase).to_tuple() with self.subTest('JIT Disabled'): with jax.disable_jit(): _lowercase : List[Any] = decode_jitted(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase)) for jitted_output, output in zip(lowerCamelCase, lowerCamelCase): self.assertEqual(jitted_output.shape, output.shape) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_class_name in self.all_model_classes: _lowercase : Optional[int] = model_class_name.from_pretrained('facebook/blenderbot-400M-distill') # FlaxBlenderbotForSequenceClassification expects eos token in input_ids _lowercase : Optional[Any] = np.ones((1, 1)) * model.config.eos_token_id _lowercase : int = model(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @unittest.skipUnless(jax_device != 'cpu', '3B test too slow on CPU.') @slow def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = {'num_beams': 1, 'early_stopping': True, 'min_length': 15, 'max_length': 25} _lowercase : List[Any] = {'skip_special_tokens': True, 'clean_up_tokenization_spaces': True} _lowercase : List[str] = FlaxBlenderbotForConditionalGeneration.from_pretrained('facebook/blenderbot-3B', from_pt=lowerCamelCase) _lowercase : Dict = BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B') _lowercase : Any = ['Sam'] _lowercase : List[str] = tokenizer(lowerCamelCase, return_tensors='jax') _lowercase : Any = model.generate(**lowerCamelCase, **lowerCamelCase) _lowercase : str = 'Sam is a great name. It means "sun" in Gaelic.' _lowercase : List[str] = tokenizer.batch_decode(lowerCamelCase, **lowerCamelCase) assert generated_txt[0].strip() == tgt_text
21
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 _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) 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 UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): 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) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = 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=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
1
from io import BytesIO from typing import List, Union import requests from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, Pipeline if is_decord_available(): import numpy as np from decord import VideoReader if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : str = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> Dict: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'decord') self.check_model_type(lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = {} if frame_sampling_rate is not None: _lowercase : Optional[int] = frame_sampling_rate if num_frames is not None: _lowercase : List[Any] = num_frames _lowercase : List[Any] = {} if top_k is not None: _lowercase : str = top_k return preprocess_params, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Dict: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=1) -> List[Any]: """simple docstring""" if num_frames is None: _lowercase : Dict = self.model.config.num_frames if video.startswith('http://') or video.startswith('https://'): _lowercase : int = BytesIO(requests.get(lowerCamelCase).content) _lowercase : Tuple = VideoReader(lowerCamelCase) videoreader.seek(0) _lowercase : str = 0 _lowercase : List[Any] = num_frames * frame_sampling_rate - 1 _lowercase : Tuple = np.linspace(lowerCamelCase, lowerCamelCase, num=lowerCamelCase, dtype=np.intaa) _lowercase : Tuple = videoreader.get_batch(lowerCamelCase).asnumpy() _lowercase : Tuple = list(lowerCamelCase) _lowercase : Optional[int] = self.image_processor(lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : int = self.model.config.num_labels if self.framework == "pt": _lowercase : Optional[Any] = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Any = probs.topk(lowerCamelCase) else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : Union[str, Any] = scores.tolist() _lowercase : List[str] = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
1
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( 'compression_format, is_archive' , [ ('7z', True), ('bz2', False), ('gzip', False), ('lz4', False), ('tar', True), ('xz', False), ('zip', True), ('zstd', False), ] , ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , ) -> List[str]: _lowercase : Dict = { '7z': (seven_zip_file, SevenZipExtractor), 'bz2': (bza_file, BzipaExtractor), 'gzip': (gz_file, GzipExtractor), 'lz4': (lza_file, LzaExtractor), 'tar': (tar_file, TarExtractor), 'xz': (xz_file, XzExtractor), 'zip': (zip_file, ZipExtractor), 'zstd': (zstd_file, ZstdExtractor), } _lowercase , _lowercase : int = input_paths_and_base_extractors[compression_format] if input_path is None: _lowercase : Optional[int] = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(lowerCamelCase_ ) assert base_extractor.is_extractable(lowerCamelCase_ ) _lowercase : str = tmp_path / ('extracted' if is_archive else 'extracted.txt') base_extractor.extract(lowerCamelCase_ , lowerCamelCase_ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name _lowercase : Union[str, Any] = file_path.read_text(encoding='utf-8' ) else: _lowercase : List[Any] = output_path.read_text(encoding='utf-8' ) _lowercase : Tuple = text_file.read_text(encoding='utf-8' ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( 'compression_format, is_archive' , [ ('7z', True), ('bz2', False), ('gzip', False), ('lz4', False), ('tar', True), ('xz', False), ('zip', True), ('zstd', False), ] , ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , ) -> List[str]: _lowercase : List[Any] = { '7z': seven_zip_file, 'bz2': bza_file, 'gzip': gz_file, 'lz4': lza_file, 'tar': tar_file, 'xz': xz_file, 'zip': zip_file, 'zstd': zstd_file, } _lowercase : int = input_paths[compression_format] if input_path is None: _lowercase : Tuple = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(lowerCamelCase_ ) _lowercase : List[Any] = Extractor.infer_extractor_format(lowerCamelCase_ ) assert extractor_format is not None _lowercase : int = tmp_path / ('extracted' if is_archive else 'extracted.txt') Extractor.extract(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name _lowercase : Optional[int] = file_path.read_text(encoding='utf-8' ) else: _lowercase : Any = output_path.read_text(encoding='utf-8' ) _lowercase : Any = text_file.read_text(encoding='utf-8' ) assert extracted_file_content == expected_file_content @pytest.fixture def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: import tarfile _lowercase : Union[str, Any] = tmp_path / 'data_dot_dot' directory.mkdir() _lowercase : Tuple = directory / 'tar_file_with_dot_dot.tar' with tarfile.TarFile(lowerCamelCase_ , 'w' ) as f: f.add(lowerCamelCase_ , arcname=os.path.join('..' , text_file.name ) ) return path @pytest.fixture def UpperCamelCase_( lowerCamelCase_ ) -> Optional[Any]: import tarfile _lowercase : int = tmp_path / 'data_sym_link' directory.mkdir() _lowercase : Union[str, Any] = directory / 'tar_file_with_sym_link.tar' os.symlink('..' , directory / 'subdir' , target_is_directory=lowerCamelCase_ ) with tarfile.TarFile(lowerCamelCase_ , 'w' ) as f: f.add(str(directory / 'subdir' ) , arcname='subdir' ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( 'insecure_tar_file, error_log' , [('tar_file_with_dot_dot', 'illegal path'), ('tar_file_with_sym_link', 'Symlink')] , ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> int: _lowercase : Dict = { 'tar_file_with_dot_dot': tar_file_with_dot_dot, 'tar_file_with_sym_link': tar_file_with_sym_link, } _lowercase : List[Any] = insecure_tar_files[insecure_tar_file] _lowercase : List[str] = tmp_path / 'extracted' TarExtractor.extract(lowerCamelCase_ , lowerCamelCase_ ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def UpperCamelCase_( lowerCamelCase_ ) -> Union[str, Any]: # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number _lowercase : List[Any] = tmpdir / 'not_a_zip_file' # From: https://github.com/python/cpython/pull/5053 _lowercase : Union[str, Any] = ( B'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00' B'\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6\'\x00\x00\x00\x15I' B'DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07' B'\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82' ) with not_a_zip_file.open('wb' ) as f: f.write(lowerCamelCase_ ) assert zipfile.is_zipfile(str(lowerCamelCase_ ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(lowerCamelCase_ ) # but we're right
21
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
1
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
1
import os import re import shutil from argparse import ArgumentParser, Namespace from datasets.commands import BaseDatasetsCLICommand from datasets.utils.logging import get_logger SCREAMING_SNAKE_CASE : Union[str, Any] = "<<<<<<< This should probably be modified because it mentions: " SCREAMING_SNAKE_CASE : Optional[int] = "=======\n>>>>>>>\n" SCREAMING_SNAKE_CASE : str = [ "TextEncoderConfig", "ByteTextEncoder", "SubwordTextEncoder", "encoder_config", "maybe_build_from_corpus", "manual_dir", ] SCREAMING_SNAKE_CASE : List[Any] = [ # (pattern, replacement) # Order is important here for some replacements (r"tfds\.core", r"datasets"), (r"tf\.io\.gfile\.GFile", r"open"), (r"tf\.([\w\d]+)", r"datasets.Value('\1')"), (r"tfds\.features\.Text\(\)", r"datasets.Value('string')"), (r"tfds\.features\.Text\(", r"datasets.Value('string'),"), (r"features\s*=\s*tfds.features.FeaturesDict\(", r"features=datasets.Features("), (r"tfds\.features\.FeaturesDict\(", r"dict("), (r"The TensorFlow Datasets Authors", r"The TensorFlow Datasets Authors and the HuggingFace Datasets Authors"), (r"tfds\.", r"datasets."), (r"dl_manager\.manual_dir", r"self.config.data_dir"), (r"self\.builder_config", r"self.config"), ] def UpperCamelCase_( lowerCamelCase_ ) -> Optional[Any]: return ConvertCommand(args.tfds_path , args.datasets_directory ) class _lowerCamelCase( _a ): @staticmethod def UpperCamelCase ( lowerCamelCase) -> Dict: """simple docstring""" _lowercase : Union[str, Any] = parser.add_parser( 'convert', help='Convert a TensorFlow Datasets dataset to a HuggingFace Datasets dataset.', ) train_parser.add_argument( '--tfds_path', type=lowerCamelCase, required=lowerCamelCase, help='Path to a TensorFlow Datasets folder to convert or a single tfds file to convert.', ) train_parser.add_argument( '--datasets_directory', type=lowerCamelCase, required=lowerCamelCase, help='Path to the HuggingFace Datasets folder.') train_parser.set_defaults(func=lowerCamelCase) def __init__( self, lowerCamelCase, lowerCamelCase, *lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Optional[int] = get_logger('datasets-cli/converting') _lowercase : Union[str, Any] = tfds_path _lowercase : Tuple = datasets_directory def UpperCamelCase ( self) -> List[str]: """simple docstring""" if os.path.isdir(self._tfds_path): _lowercase : List[Any] = os.path.abspath(self._tfds_path) elif os.path.isfile(self._tfds_path): _lowercase : Tuple = os.path.dirname(self._tfds_path) else: raise ValueError('--tfds_path is neither a directory nor a file. Please check path.') _lowercase : List[str] = os.path.abspath(self._datasets_directory) self._logger.info(F'''Converting datasets from {abs_tfds_path} to {abs_datasets_path}''') _lowercase : Any = [] _lowercase : Union[str, Any] = [] _lowercase : Optional[Any] = {} if os.path.isdir(self._tfds_path): _lowercase : int = os.listdir(lowerCamelCase) else: _lowercase : List[Any] = [os.path.basename(self._tfds_path)] for f_name in file_names: self._logger.info(F'''Looking at file {f_name}''') _lowercase : Any = os.path.join(lowerCamelCase, lowerCamelCase) _lowercase : int = os.path.join(lowerCamelCase, lowerCamelCase) if not os.path.isfile(lowerCamelCase) or "__init__" in f_name or "_test" in f_name or ".py" not in f_name: self._logger.info('Skipping file') continue with open(lowerCamelCase, encoding='utf-8') as f: _lowercase : List[Any] = f.readlines() _lowercase : Any = [] _lowercase : Tuple = False _lowercase : Union[str, Any] = False _lowercase : Optional[int] = [] for line in lines: _lowercase : Dict = line # Convert imports if "import tensorflow.compat.v2 as tf" in out_line: continue elif "@tfds.core" in out_line: continue elif "builder=self" in out_line: continue elif "import tensorflow_datasets.public_api as tfds" in out_line: _lowercase : Tuple = 'import datasets\n' elif "import tensorflow" in out_line: # order is important here _lowercase : List[Any] = '' continue elif "from absl import logging" in out_line: _lowercase : List[str] = 'from datasets import logging\n' elif "getLogger" in out_line: _lowercase : Tuple = out_line.replace('getLogger', 'get_logger') elif any(expression in out_line for expression in TO_HIGHLIGHT): _lowercase : Tuple = True _lowercase : List[str] = list(filter(lambda lowerCamelCase: e in out_line, lowerCamelCase)) out_lines.append(HIGHLIGHT_MESSAGE_PRE + str(lowerCamelCase) + '\n') out_lines.append(lowerCamelCase) out_lines.append(lowerCamelCase) continue else: for pattern, replacement in TO_CONVERT: _lowercase : Union[str, Any] = re.sub(lowerCamelCase, lowerCamelCase, lowerCamelCase) # Take care of saving utilities (to later move them together with main script) if "tensorflow_datasets" in out_line: _lowercase : List[str] = re.match(R'from\stensorflow_datasets.*import\s([^\.\r\n]+)', lowerCamelCase) tfds_imports.extend(imp.strip() for imp in match.group(1).split(',')) _lowercase : Optional[Any] = 'from . import ' + match.group(1) # Check we have not forget anything if "tf." in out_line or "tfds." in out_line or "tensorflow_datasets" in out_line: raise ValueError(F'''Error converting {out_line.strip()}''') if "GeneratorBasedBuilder" in out_line or "BeamBasedBuilder" in out_line: _lowercase : Optional[Any] = True out_lines.append(lowerCamelCase) if is_builder or "wmt" in f_name: # We create a new directory for each dataset _lowercase : Optional[Any] = f_name.replace('.py', '') _lowercase : Tuple = os.path.join(lowerCamelCase, lowerCamelCase) _lowercase : str = os.path.join(lowerCamelCase, lowerCamelCase) os.makedirs(lowerCamelCase, exist_ok=lowerCamelCase) self._logger.info(F'''Adding directory {output_dir}''') imports_to_builder_map.update({imp: output_dir for imp in tfds_imports}) else: # Utilities will be moved at the end utils_files.append(lowerCamelCase) if needs_manual_update: with_manual_update.append(lowerCamelCase) with open(lowerCamelCase, 'w', encoding='utf-8') as f: f.writelines(lowerCamelCase) self._logger.info(F'''Converted in {output_file}''') for utils_file in utils_files: try: _lowercase : int = os.path.basename(lowerCamelCase) _lowercase : int = imports_to_builder_map[f_name.replace('.py', '')] self._logger.info(F'''Moving {dest_folder} to {utils_file}''') shutil.copy(lowerCamelCase, lowerCamelCase) except KeyError: self._logger.error(F'''Cannot find destination folder for {utils_file}. Please copy manually.''') if with_manual_update: for file_path in with_manual_update: self._logger.warning( F'''You need to manually update file {file_path} to remove configurations using \'TextEncoderConfig\'.''')
21
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
1
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Optional[int] = sorted(numsa + numsa ) _lowercase , _lowercase : int = divmod(len(lowerCamelCase_ ) , 2 ) if mod == 1: return all_numbers[div] else: return (all_numbers[div] + all_numbers[div - 1]) / 2 if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : List[str] = [float(x) for x in input("Enter the elements of first array: ").split()] SCREAMING_SNAKE_CASE : str = [float(x) for x in input("Enter the elements of second array: ").split()] print(F"The median of two arrays is: {median_of_two_arrays(array_a, array_a)}")
21
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
1
from __future__ import annotations import unittest from transformers import XGLMConfig, XGLMTokenizer, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers.models.xglm.modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, ) @require_tf class _lowerCamelCase: lowercase_ : Dict = XGLMConfig lowercase_ : Optional[Any] = {} lowercase_ : Dict = """gelu""" def __init__( self, lowerCamelCase, lowerCamelCase=14, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=37, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=0.0_2, ) -> List[Any]: """simple docstring""" _lowercase : int = parent _lowercase : List[str] = batch_size _lowercase : Tuple = seq_length _lowercase : Tuple = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : Dict = use_labels _lowercase : Tuple = vocab_size _lowercase : Optional[int] = d_model _lowercase : Dict = num_hidden_layers _lowercase : Dict = num_attention_heads _lowercase : Optional[Any] = ffn_dim _lowercase : Tuple = activation_function _lowercase : Tuple = activation_dropout _lowercase : Any = attention_dropout _lowercase : Union[str, Any] = max_position_embeddings _lowercase : Optional[Any] = initializer_range _lowercase : Optional[int] = None _lowercase : Optional[int] = 0 _lowercase : Tuple = 2 _lowercase : str = 1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return XGLMConfig.from_pretrained('facebook/xglm-564M') def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : Tuple = tf.clip_by_value( ids_tensor([self.batch_size, self.seq_length], self.vocab_size), clip_value_min=0, clip_value_max=3) _lowercase : Optional[int] = None if self.use_input_mask: _lowercase : Any = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : List[Any] = self.get_config() _lowercase : int = floats_tensor([self.num_hidden_layers, self.num_attention_heads], 2) return ( config, input_ids, input_mask, head_mask, ) def UpperCamelCase ( self) -> int: """simple docstring""" return XGLMConfig( vocab_size=self.vocab_size, d_model=self.hidden_size, num_layers=self.num_hidden_layers, attention_heads=self.num_attention_heads, ffn_dim=self.ffn_dim, activation_function=self.activation_function, activation_dropout=self.activation_dropout, attention_dropout=self.attention_dropout, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, use_cache=lowerCamelCase, bos_token_id=self.bos_token_id, eos_token_id=self.eos_token_id, pad_token_id=self.pad_token_id, return_dict=lowerCamelCase, ) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Any = self.prepare_config_and_inputs() ( ( _lowercase ) , ( _lowercase ) , ( _lowercase ) , ( _lowercase ) , ) : Optional[Any] = config_and_inputs _lowercase : Tuple = { 'input_ids': input_ids, 'head_mask': head_mask, } return config, inputs_dict @require_tf class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : int = (TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else () lowercase_ : Optional[Any] = (TFXGLMForCausalLM,) if is_tf_available() else () lowercase_ : Union[str, Any] = ( {"""feature-extraction""": TFXGLMModel, """text-generation""": TFXGLMForCausalLM} if is_tf_available() else {} ) lowercase_ : Dict = False lowercase_ : Dict = False lowercase_ : Optional[int] = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : Any = TFXGLMModelTester(self) _lowercase : int = ConfigTester(self, config_class=lowerCamelCase, n_embd=37) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.config_tester.run_common_tests() @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = TFXGLMModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.') def UpperCamelCase ( self) -> str: """simple docstring""" super().test_resize_token_embeddings() @require_tf class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self, lowerCamelCase=True) -> List[str]: """simple docstring""" _lowercase : List[Any] = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M') _lowercase : Optional[Any] = tf.convert_to_tensor([[2, 2_68, 98_65]], dtype=tf.intaa) # The dog # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other # fmt: off _lowercase : List[Any] = [2, 2_68, 98_65, 67, 11, 19_88, 5_72_52, 98_65, 5, 9_84, 67, 19_88, 21_38_38, 16_58, 53, 7_04_46, 33, 66_57, 2_78, 15_81] # fmt: on _lowercase : Union[str, Any] = model.generate(lowerCamelCase, do_sample=lowerCamelCase, num_beams=1) if verify_outputs: self.assertListEqual(output_ids[0].numpy().tolist(), lowerCamelCase) @slow def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = XGLMTokenizer.from_pretrained('facebook/xglm-564M') _lowercase : List[str] = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M') tf.random.set_seed(0) _lowercase : Tuple = tokenizer('Today is a nice day and', return_tensors='tf') _lowercase : List[Any] = tokenized.input_ids # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices) with tf.device(':/CPU:0'): _lowercase : List[Any] = model.generate(lowerCamelCase, do_sample=lowerCamelCase, seed=[7, 0]) _lowercase : str = tokenizer.decode(output_ids[0], skip_special_tokens=lowerCamelCase) _lowercase : List[Any] = ( 'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due' ) self.assertEqual(lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Union[str, Any] = TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M') _lowercase : int = XGLMTokenizer.from_pretrained('facebook/xglm-564M') _lowercase : List[str] = 'left' # use different length sentences to test batching _lowercase : Tuple = [ 'This is an extremelly long sentence that only exists to test the ability of the model to cope with ' 'left-padding, such as in batched generation. The output for the sequence below should be the same ' 'regardless of whether left padding is applied or not. When', 'Hello, my dog is a little', ] _lowercase : str = tokenizer(lowerCamelCase, return_tensors='tf', padding=lowerCamelCase) _lowercase : Optional[int] = inputs['input_ids'] _lowercase : Optional[int] = model.generate(input_ids=lowerCamelCase, attention_mask=inputs['attention_mask'], max_new_tokens=12) _lowercase : Tuple = tokenizer(sentences[0], return_tensors='tf').input_ids _lowercase : Optional[Any] = model.generate(input_ids=lowerCamelCase, max_new_tokens=12) _lowercase : Tuple = tokenizer(sentences[1], return_tensors='tf').input_ids _lowercase : int = model.generate(input_ids=lowerCamelCase, max_new_tokens=12) _lowercase : str = tokenizer.batch_decode(lowerCamelCase, skip_special_tokens=lowerCamelCase) _lowercase : Any = tokenizer.decode(output_non_padded[0], skip_special_tokens=lowerCamelCase) _lowercase : List[Any] = tokenizer.decode(output_padded[0], skip_special_tokens=lowerCamelCase) _lowercase : Dict = [ 'This is an extremelly long sentence that only exists to test the ability of the model to cope with ' 'left-padding, such as in batched generation. The output for the sequence below should be the same ' 'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be ' 'a single', 'Hello, my dog is a little bit of a shy one, but he is very friendly', ] self.assertListEqual(lowerCamelCase, lowerCamelCase) self.assertListEqual(lowerCamelCase, [non_padded_sentence, padded_sentence])
21
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
1
import os import sys from contextlib import contextmanager # Windows only if os.name == "nt": import ctypes import msvcrt # noqa class _lowerCamelCase( ctypes.Structure ): # _fields is a specific attr expected by ctypes lowercase_ : Optional[Any] = [("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)] def UpperCamelCase_( ) -> Optional[int]: if os.name == "nt": _lowercase : List[str] = CursorInfo() _lowercase : int = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase_ , ctypes.byref(lowerCamelCase_ ) ) _lowercase : List[str] = False ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase_ , ctypes.byref(lowerCamelCase_ ) ) elif os.name == "posix": sys.stdout.write('\033[?25l' ) sys.stdout.flush() def UpperCamelCase_( ) -> Tuple: if os.name == "nt": _lowercase : Dict = CursorInfo() _lowercase : Any = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(lowerCamelCase_ , ctypes.byref(lowerCamelCase_ ) ) _lowercase : Dict = True ctypes.windll.kernelaa.SetConsoleCursorInfo(lowerCamelCase_ , ctypes.byref(lowerCamelCase_ ) ) elif os.name == "posix": sys.stdout.write('\033[?25h' ) sys.stdout.flush() @contextmanager def UpperCamelCase_( ) -> Tuple: try: hide_cursor() yield finally: show_cursor()
21
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
1
import os from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen, xsplitext from ..table import array_cast from ..utils.py_utils import no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: from .features import FeatureType SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = False, False, False @dataclass class _lowerCamelCase: lowercase_ : Optional[int] = None lowercase_ : bool = True lowercase_ : bool = True lowercase_ : Optional[str] = None # Automatically constructed lowercase_ : ClassVar[str] = "dict" lowercase_ : ClassVar[Any] = pa.struct({"""bytes""": pa.binary(), """path""": pa.string()} ) lowercase_ : str = field(default="""Audio""", init=_a, repr=_a ) def __call__( self) -> List[str]: """simple docstring""" return self.pa_type def UpperCamelCase ( self, lowerCamelCase) -> dict: """simple docstring""" try: import soundfile as sf # soundfile is a dependency of librosa, needed to decode audio files. except ImportError as err: raise ImportError('To support encoding audio data, please install \'soundfile\'.') from err if isinstance(lowerCamelCase, lowerCamelCase): return {"bytes": None, "path": value} elif isinstance(lowerCamelCase, lowerCamelCase): return {"bytes": value, "path": None} elif "array" in value: # convert the audio array to wav bytes _lowercase : Optional[Any] = BytesIO() sf.write(lowerCamelCase, value['array'], value['sampling_rate'], format='wav') return {"bytes": buffer.getvalue(), "path": None} elif value.get('path') is not None and os.path.isfile(value['path']): # we set "bytes": None to not duplicate the data if they're already available locally if value["path"].endswith('pcm'): # "PCM" only has raw audio bytes if value.get('sampling_rate') is None: # At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate raise KeyError('To use PCM files, please specify a \'sampling_rate\' in Audio object') if value.get('bytes'): # If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!) _lowercase : List[Any] = np.frombuffer(value['bytes'], dtype=np.intaa).astype(np.floataa) / 3_27_67 else: _lowercase : Dict = np.memmap(value['path'], dtype='h', mode='r').astype(np.floataa) / 3_27_67 _lowercase : List[str] = BytesIO(bytes()) sf.write(lowerCamelCase, lowerCamelCase, value['sampling_rate'], format='wav') return {"bytes": buffer.getvalue(), "path": None} else: return {"bytes": None, "path": value.get('path')} elif value.get('bytes') is not None or value.get('path') is not None: # store the audio bytes, and path is used to infer the audio format using the file extension return {"bytes": value.get('bytes'), "path": value.get('path')} else: raise ValueError( F'''An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase = None) -> dict: """simple docstring""" if not self.decode: raise RuntimeError('Decoding is disabled for this feature. Please use Audio(decode=True) instead.') _lowercase , _lowercase : List[Any] = (value['path'], BytesIO(value['bytes'])) if value['bytes'] is not None else (value['path'], None) if path is None and file is None: raise ValueError(F'''An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.''') try: import librosa import soundfile as sf except ImportError as err: raise ImportError('To support decoding audio files, please install \'librosa\' and \'soundfile\'.') from err _lowercase : Optional[Any] = xsplitext(lowerCamelCase)[1][1:].lower() if path is not None else None if not config.IS_OPUS_SUPPORTED and audio_format == "opus": raise RuntimeError( 'Decoding \'opus\' files requires system library \'libsndfile\'>=1.0.31, ' 'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ') elif not config.IS_MP3_SUPPORTED and audio_format == "mp3": raise RuntimeError( 'Decoding \'mp3\' files requires system library \'libsndfile\'>=1.1.0, ' 'You can try to update `soundfile` python library: `pip install "soundfile>=0.12.1"`. ') if file is None: _lowercase : int = token_per_repo_id or {} _lowercase : Optional[int] = path.split('::')[-1] try: _lowercase : Any = string_to_dict(lowerCamelCase, config.HUB_DATASETS_URL)['repo_id'] _lowercase : Optional[Any] = token_per_repo_id[repo_id] except (ValueError, KeyError): _lowercase : int = None with xopen(lowerCamelCase, 'rb', use_auth_token=lowerCamelCase) as f: _lowercase , _lowercase : int = sf.read(lowerCamelCase) else: _lowercase , _lowercase : Union[str, Any] = sf.read(lowerCamelCase) _lowercase : Any = array.T if self.mono: _lowercase : List[str] = librosa.to_mono(lowerCamelCase) if self.sampling_rate and self.sampling_rate != sampling_rate: _lowercase : Tuple = librosa.resample(lowerCamelCase, orig_sr=lowerCamelCase, target_sr=self.sampling_rate) _lowercase : List[str] = self.sampling_rate return {"path": path, "array": array, "sampling_rate": sampling_rate} def UpperCamelCase ( self) -> Union["FeatureType", Dict[str, "FeatureType"]]: """simple docstring""" from .features import Value if self.decode: raise ValueError('Cannot flatten a decoded Audio feature.') return { "bytes": Value('binary'), "path": Value('string'), } def UpperCamelCase ( self, lowerCamelCase) -> pa.StructArray: """simple docstring""" if pa.types.is_string(storage.type): _lowercase : List[Any] = pa.array([None] * len(lowerCamelCase), type=pa.binary()) _lowercase : Union[str, Any] = pa.StructArray.from_arrays([bytes_array, storage], ['bytes', 'path'], mask=storage.is_null()) elif pa.types.is_binary(storage.type): _lowercase : Tuple = pa.array([None] * len(lowerCamelCase), type=pa.string()) _lowercase : Dict = pa.StructArray.from_arrays([storage, path_array], ['bytes', 'path'], mask=storage.is_null()) elif pa.types.is_struct(storage.type) and storage.type.get_all_field_indices('array'): _lowercase : int = pa.array([Audio().encode_example(lowerCamelCase) if x is not None else None for x in storage.to_pylist()]) elif pa.types.is_struct(storage.type): if storage.type.get_field_index('bytes') >= 0: _lowercase : Optional[int] = storage.field('bytes') else: _lowercase : str = pa.array([None] * len(lowerCamelCase), type=pa.binary()) if storage.type.get_field_index('path') >= 0: _lowercase : Union[str, Any] = storage.field('path') else: _lowercase : List[Any] = pa.array([None] * len(lowerCamelCase), type=pa.string()) _lowercase : Any = pa.StructArray.from_arrays([bytes_array, path_array], ['bytes', 'path'], mask=storage.is_null()) return array_cast(lowerCamelCase, self.pa_type) def UpperCamelCase ( self, lowerCamelCase) -> pa.StructArray: """simple docstring""" @no_op_if_value_is_null def path_to_bytes(lowerCamelCase): with xopen(lowerCamelCase, 'rb') as f: _lowercase : int = f.read() return bytes_ _lowercase : Optional[Any] = pa.array( [ (path_to_bytes(x['path']) if x['bytes'] is None else x['bytes']) if x is not None else None for x in storage.to_pylist() ], type=pa.binary(), ) _lowercase : int = pa.array( [os.path.basename(lowerCamelCase) if path is not None else None for path in storage.field('path').to_pylist()], type=pa.string(), ) _lowercase : Dict = pa.StructArray.from_arrays([bytes_array, path_array], ['bytes', 'path'], mask=bytes_array.is_null()) return array_cast(lowerCamelCase, self.pa_type)
21
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
1
import importlib import sys from argparse import REMAINDER, ArgumentParser from pathlib import Path import torch_xla.distributed.xla_multiprocessing as xmp def UpperCamelCase_( ) -> Any: _lowercase : Dict = ArgumentParser( description=( 'PyTorch TPU distributed training launch ' 'helper utility that will spawn up ' 'multiple distributed processes' ) ) # Optional arguments for the launch helper parser.add_argument('--num_cores' , type=lowerCamelCase_ , default=1 , help='Number of TPU cores to use (1 or 8).' ) # positional parser.add_argument( 'training_script' , type=lowerCamelCase_ , help=( 'The full path to the single TPU training ' 'program/script to be launched in parallel, ' 'followed by all the arguments for the ' 'training script' ) , ) # rest from the training program parser.add_argument('training_script_args' , nargs=lowerCamelCase_ ) return parser.parse_args() def UpperCamelCase_( ) -> int: _lowercase : List[str] = parse_args() # Import training_script as a module. _lowercase : int = Path(args.training_script ) sys.path.append(str(script_fpath.parent.resolve() ) ) _lowercase : str = script_fpath.stem _lowercase : Optional[int] = importlib.import_module(lowerCamelCase_ ) # Patch sys.argv _lowercase : List[Any] = [args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores )] xmp.spawn(mod._mp_fn , args=() , nprocs=args.num_cores ) if __name__ == "__main__": main()
21
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
1
from typing import List, Optional, Union import torch from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) SCREAMING_SNAKE_CASE : Tuple = logging.get_logger(__name__) # pylint: disable=invalid-name SCREAMING_SNAKE_CASE : Optional[Any] = "\n Examples:\n ```py\n >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline\n >>> import torch\n\n >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-prior\")\n >>> pipe_prior.to(\"cuda\")\n >>> prompt = \"red cat, 4k photo\"\n >>> out = pipe_prior(prompt)\n >>> image_emb = out.image_embeds\n >>> zero_image_emb = out.negative_image_embeds\n >>> pipe = KandinskyV22Pipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-decoder\")\n >>> pipe.to(\"cuda\")\n >>> image = pipe(\n ... image_embeds=image_emb,\n ... negative_image_embeds=zero_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=50,\n ... ).images\n >>> image[0].save(\"cat.png\")\n ```\n" def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=8 ) -> Dict: _lowercase : Optional[Any] = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 _lowercase : Any = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> Dict: """simple docstring""" super().__init__() self.register_modules( unet=lowerCamelCase, scheduler=lowerCamelCase, movq=lowerCamelCase, ) _lowercase : List[str] = 2 ** (len(self.movq.config.block_out_channels) - 1) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[Any]: """simple docstring""" if latents is None: _lowercase : Optional[Any] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) else: if latents.shape != shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {shape}''') _lowercase : int = latents.to(lowerCamelCase) _lowercase : int = latents * scheduler.init_noise_sigma return latents def UpperCamelCase ( self, lowerCamelCase=0) -> Optional[int]: """simple docstring""" if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('Please install accelerate via `pip install accelerate`') _lowercase : Tuple = torch.device(F'''cuda:{gpu_id}''') _lowercase : Optional[Any] = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase=0) -> int: """simple docstring""" if is_accelerate_available() and is_accelerate_version('>=', '0.17.0.dev0'): from accelerate import cpu_offload_with_hook else: raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.') _lowercase : Union[str, Any] = torch.device(F'''cuda:{gpu_id}''') if self.device.type != "cpu": self.to('cpu', silence_dtype_warnings=lowerCamelCase) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) _lowercase : Optional[Any] = None for cpu_offloaded_model in [self.unet, self.movq]: _lowercase , _lowercase : List[str] = cpu_offload_with_hook(lowerCamelCase, lowerCamelCase, prev_module_hook=lowerCamelCase) # We'll offload the last model manually. _lowercase : Dict = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def UpperCamelCase ( self) -> Tuple: """simple docstring""" if not hasattr(self.unet, '_hf_hook'): return self.device for module in self.unet.modules(): if ( hasattr(lowerCamelCase, '_hf_hook') and hasattr(module._hf_hook, 'execution_device') and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device) return self.device @torch.no_grad() @replace_example_docstring(lowerCamelCase) def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 1_00, lowerCamelCase = 4.0, lowerCamelCase = 1, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, ) -> List[Any]: """simple docstring""" _lowercase : int = self._execution_device _lowercase : Any = guidance_scale > 1.0 if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : int = torch.cat(lowerCamelCase, dim=0) _lowercase : Optional[int] = image_embeds.shape[0] * num_images_per_prompt if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Optional[int] = torch.cat(lowerCamelCase, dim=0) if do_classifier_free_guidance: _lowercase : str = image_embeds.repeat_interleave(lowerCamelCase, dim=0) _lowercase : int = negative_image_embeds.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = torch.cat([negative_image_embeds, image_embeds], dim=0).to(dtype=self.unet.dtype, device=lowerCamelCase) self.scheduler.set_timesteps(lowerCamelCase, device=lowerCamelCase) _lowercase : Optional[Any] = self.scheduler.timesteps _lowercase : List[str] = self.unet.config.in_channels _lowercase , _lowercase : Union[str, Any] = downscale_height_and_width(lowerCamelCase, lowerCamelCase, self.movq_scale_factor) # create initial latent _lowercase : str = self.prepare_latents( (batch_size, num_channels_latents, height, width), image_embeds.dtype, lowerCamelCase, lowerCamelCase, lowerCamelCase, self.scheduler, ) for i, t in enumerate(self.progress_bar(lowerCamelCase)): # expand the latents if we are doing classifier free guidance _lowercase : List[Any] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : Tuple = {'image_embeds': image_embeds} _lowercase : Optional[Any] = self.unet( sample=lowerCamelCase, timestep=lowerCamelCase, encoder_hidden_states=lowerCamelCase, added_cond_kwargs=lowerCamelCase, return_dict=lowerCamelCase, )[0] if do_classifier_free_guidance: _lowercase , _lowercase : List[str] = noise_pred.split(latents.shape[1], dim=1) _lowercase , _lowercase : Tuple = noise_pred.chunk(2) _lowercase , _lowercase : Any = variance_pred.chunk(2) _lowercase : Dict = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) _lowercase : Tuple = torch.cat([noise_pred, variance_pred_text], dim=1) if not ( hasattr(self.scheduler.config, 'variance_type') and self.scheduler.config.variance_type in ["learned", "learned_range"] ): _lowercase , _lowercase : int = noise_pred.split(latents.shape[1], dim=1) # compute the previous noisy sample x_t -> x_t-1 _lowercase : str = self.scheduler.step( lowerCamelCase, lowerCamelCase, lowerCamelCase, generator=lowerCamelCase, )[0] # post-processing _lowercase : str = self.movq.decode(lowerCamelCase, force_not_quantize=lowerCamelCase)['sample'] if output_type not in ["pt", "np", "pil"]: raise ValueError(F'''Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}''') if output_type in ["np", "pil"]: _lowercase : Dict = image * 0.5 + 0.5 _lowercase : Any = image.clamp(0, 1) _lowercase : List[str] = image.cpu().permute(0, 2, 3, 1).float().numpy() if output_type == "pil": _lowercase : Optional[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image,) return ImagePipelineOutput(images=lowerCamelCase)
21
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
1
import inspect import math import tempfile import unittest import numpy as np from transformers import ViTMAEConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTMAEForPreTraining, ViTMAEModel from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=30, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=37, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=10, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=0.6, lowerCamelCase=None, ) -> int: """simple docstring""" _lowercase : str = parent _lowercase : Union[str, Any] = batch_size _lowercase : Dict = image_size _lowercase : Optional[Any] = patch_size _lowercase : List[Any] = num_channels _lowercase : Union[str, Any] = is_training _lowercase : Dict = use_labels _lowercase : List[str] = hidden_size _lowercase : Union[str, Any] = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : Tuple = intermediate_size _lowercase : List[str] = hidden_act _lowercase : Dict = hidden_dropout_prob _lowercase : str = attention_probs_dropout_prob _lowercase : List[str] = type_sequence_label_size _lowercase : Union[str, Any] = initializer_range _lowercase : int = mask_ratio _lowercase : List[str] = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) _lowercase : str = (image_size // patch_size) ** 2 _lowercase : List[str] = int(math.ceil((1 - mask_ratio) * (num_patches + 1))) def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : int = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : Optional[int] = self.get_config() return config, pixel_values, labels def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return ViTMAEConfig( image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_size=self.hidden_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, is_decoder=lowerCamelCase, initializer_range=self.initializer_range, mask_ratio=self.mask_ratio, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : Tuple = ViTMAEModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Tuple = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[Any] = ViTMAEForPreTraining(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) _lowercase : int = (self.image_size // self.patch_size) ** 2 _lowercase : List[str] = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels)) # test greyscale images _lowercase : Tuple = 1 _lowercase : Any = ViTMAEForPreTraining(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]) _lowercase : Dict = model(lowerCamelCase) _lowercase : List[str] = self.patch_size**2 self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase : Tuple = config_and_inputs _lowercase : Any = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Optional[Any] = (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else () lowercase_ : str = {"""feature-extraction""": ViTMAEModel} if is_torch_available() else {} lowercase_ : Optional[int] = False lowercase_ : List[str] = False lowercase_ : Dict = False lowercase_ : List[str] = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : List[Any] = ViTMAEModelTester(self) _lowercase : Union[str, Any] = ConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase, hidden_size=37) def UpperCamelCase ( self) -> str: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='ViTMAE does not use inputs_embeds') def UpperCamelCase ( self) -> Any: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Union[str, Any] = model_class(lowerCamelCase) self.assertIsInstance(model.get_input_embeddings(), (nn.Module)) _lowercase : str = model.get_output_embeddings() self.assertTrue(x is None or isinstance(lowerCamelCase, nn.Linear)) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Optional[int] = model_class(lowerCamelCase) _lowercase : Union[str, Any] = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Optional[Any] = [*signature.parameters.keys()] _lowercase : Optional[Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" np.random.seed(2) _lowercase : Optional[Any] = int((pt_model.config.image_size // pt_model.config.patch_size) ** 2) _lowercase : Optional[int] = np.random.uniform(size=(self.model_tester.batch_size, num_patches)) _lowercase : List[str] = torch.from_numpy(lowerCamelCase) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument _lowercase : List[str] = pt_noise super().check_pt_tf_models(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase , _lowercase : Tuple = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Any = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() # make random mask reproducible torch.manual_seed(2) with torch.no_grad(): _lowercase : List[str] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : str = outputs[0].cpu().numpy() _lowercase : List[str] = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Tuple = model_class.from_pretrained(lowerCamelCase) model.to(lowerCamelCase) # make random mask reproducible torch.manual_seed(2) with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) # Make sure we don't have nans _lowercase : Tuple = after_outputs[0].cpu().numpy() _lowercase : List[Any] = 0 _lowercase : Any = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.') def UpperCamelCase ( self) -> str: """simple docstring""" pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.') def UpperCamelCase ( self) -> List[str]: """simple docstring""" pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.') def UpperCamelCase ( self) -> Dict: """simple docstring""" pass @unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> Any: """simple docstring""" pass @slow def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : Tuple = ViTMAEModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Tuple: _lowercase : int = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return ViTImageProcessor.from_pretrained('facebook/vit-mae-base') if is_vision_available() else None @slow def UpperCamelCase ( self) -> int: """simple docstring""" np.random.seed(2) _lowercase : Dict = ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base').to(lowerCamelCase) _lowercase : int = self.default_image_processor _lowercase : List[Any] = prepare_img() _lowercase : List[Any] = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # prepare a noise vector that will be also used for testing the TF model # (this way we can ensure that the PT and TF models operate on the same inputs) _lowercase : Optional[Any] = ViTMAEConfig() _lowercase : Dict = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2) _lowercase : Dict = np.random.uniform(size=(1, num_patches)) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase, noise=torch.from_numpy(lowerCamelCase).to(device=lowerCamelCase)) # verify the logits _lowercase : Optional[Any] = torch.Size((1, 1_96, 7_68)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Any = torch.tensor( [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3], expected_slice.to(lowerCamelCase), atol=1E-4))
21
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
1
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 : Union[str, Any] = { "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 : Tuple = ["BlenderbotTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = [ "BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotForCausalLM", "BlenderbotForConditionalGeneration", "BlenderbotModel", "BlenderbotPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Dict = [ "TFBlenderbotForConditionalGeneration", "TFBlenderbotModel", "TFBlenderbotPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "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 : int = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.') if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
1
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> str: if a < 0 or b < 0: raise ValueError('the value of both inputs must be positive' ) _lowercase : int = str(bin(lowerCamelCase_ ) )[2:] # remove the leading "0b" _lowercase : Any = str(bin(lowerCamelCase_ ) )[2:] _lowercase : List[Any] = max(len(lowerCamelCase_ ) , len(lowerCamelCase_ ) ) return "0b" + "".join( str(int('1' in (char_a, char_b) ) ) for char_a, char_b in zip(a_binary.zfill(lowerCamelCase_ ) , b_binary.zfill(lowerCamelCase_ ) ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
import heapq def UpperCamelCase_( lowerCamelCase_ ) -> set[int]: _lowercase : list[list] = [] # for each node and his adjacency list add them and the rank of the node to queue # using heapq module the queue will be filled like a Priority Queue # heapq works with a min priority queue, so I used -1*len(v) to build it for key, value in graph.items(): # O(log(n)) heapq.heappush(lowerCamelCase_ , [-1 * len(lowerCamelCase_ ), (key, value)] ) # chosen_vertices = set of chosen vertices _lowercase : List[str] = set() # while queue isn't empty and there are still edges # (queue[0][0] is the rank of the node with max rank) while queue and queue[0][0] != 0: # extract vertex with max rank from queue and add it to chosen_vertices _lowercase : Any = heapq.heappop(lowerCamelCase_ )[1][0] chosen_vertices.add(lowerCamelCase_ ) # Remove all arcs adjacent to argmax for elem in queue: # if v haven't adjacent node, skip if elem[0] == 0: continue # if argmax is reachable from elem # remove argmax from elem's adjacent list and update his rank if argmax in elem[1][1]: _lowercase : List[str] = elem[1][1].index(lowerCamelCase_ ) del elem[1][1][index] elem[0] += 1 # re-order the queue heapq.heapify(lowerCamelCase_ ) return chosen_vertices if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : Dict = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]} print(F"Minimum vertex cover:\n{greedy_min_vertex_cover(graph)}")
21
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
1
from __future__ import annotations from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> int: if not postfix_notation: return 0 _lowercase : str = {'+', '-', '*', '/'} _lowercase : list[Any] = [] for token in postfix_notation: if token in operations: _lowercase , _lowercase : Optional[Any] = stack.pop(), stack.pop() if token == "+": stack.append(a + b ) elif token == "-": stack.append(a - b ) elif token == "*": stack.append(a * b ) else: if a * b < 0 and a % b != 0: stack.append(a // b + 1 ) else: stack.append(a // b ) else: stack.append(int(lowerCamelCase_ ) ) return stack.pop() if __name__ == "__main__": import doctest doctest.testmod()
21
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
1
from maths.is_square_free import is_square_free from maths.prime_factors import prime_factors def UpperCamelCase_( lowerCamelCase_ ) -> int: _lowercase : Optional[Any] = prime_factors(lowerCamelCase_ ) if is_square_free(lowerCamelCase_ ): return -1 if len(lowerCamelCase_ ) % 2 else 1 return 0 if __name__ == "__main__": import doctest doctest.testmod()
21
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
1
import os from typing import List, Optional, Union from ...image_processing_utils import BatchFeature from ...image_utils import ImageInput from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType from ..auto import AutoTokenizer class _lowerCamelCase( _a ): lowercase_ : Optional[int] = ["""image_processor""", """tokenizer"""] lowercase_ : Dict = """BlipImageProcessor""" lowercase_ : List[str] = """AutoTokenizer""" def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" super().__init__(lowerCamelCase, lowerCamelCase) # add QFormer tokenizer _lowercase : int = qformer_tokenizer def __call__( self, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = True, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 0, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = True, lowerCamelCase = None, **lowerCamelCase, ) -> BatchFeature: """simple docstring""" if images is None and text is None: raise ValueError('You have to specify at least images or text.') _lowercase : int = BatchFeature() if text is not None: _lowercase : Union[str, Any] = self.tokenizer( text=lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, stride=lowerCamelCase, pad_to_multiple_of=lowerCamelCase, return_attention_mask=lowerCamelCase, return_overflowing_tokens=lowerCamelCase, return_special_tokens_mask=lowerCamelCase, return_offsets_mapping=lowerCamelCase, return_token_type_ids=lowerCamelCase, return_length=lowerCamelCase, verbose=lowerCamelCase, return_tensors=lowerCamelCase, **lowerCamelCase, ) encoding.update(lowerCamelCase) _lowercase : str = self.qformer_tokenizer( text=lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, stride=lowerCamelCase, pad_to_multiple_of=lowerCamelCase, return_attention_mask=lowerCamelCase, return_overflowing_tokens=lowerCamelCase, return_special_tokens_mask=lowerCamelCase, return_offsets_mapping=lowerCamelCase, return_token_type_ids=lowerCamelCase, return_length=lowerCamelCase, verbose=lowerCamelCase, return_tensors=lowerCamelCase, **lowerCamelCase, ) _lowercase : Tuple = qformer_text_encoding.pop('input_ids') _lowercase : Tuple = qformer_text_encoding.pop('attention_mask') if images is not None: _lowercase : Any = self.image_processor(lowerCamelCase, return_tensors=lowerCamelCase) encoding.update(lowerCamelCase) return encoding def UpperCamelCase ( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" return self.tokenizer.batch_decode(*lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" return self.tokenizer.decode(*lowerCamelCase, **lowerCamelCase) @property # Copied from transformers.models.blip.processing_blip.BlipProcessor.model_input_names def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.tokenizer.model_input_names _lowercase : Union[str, Any] = self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names)) def UpperCamelCase ( self, lowerCamelCase, **lowerCamelCase) -> Optional[Any]: """simple docstring""" if os.path.isfile(lowerCamelCase): raise ValueError(F'''Provided path ({save_directory}) should be a directory, not a file''') os.makedirs(lowerCamelCase, exist_ok=lowerCamelCase) _lowercase : Tuple = os.path.join(lowerCamelCase, 'qformer_tokenizer') self.qformer_tokenizer.save_pretrained(lowerCamelCase) return super().save_pretrained(lowerCamelCase, **lowerCamelCase) @classmethod def UpperCamelCase ( cls, lowerCamelCase, **lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = AutoTokenizer.from_pretrained(lowerCamelCase, subfolder='qformer_tokenizer') _lowercase : Any = cls._get_arguments_from_pretrained(lowerCamelCase, **lowerCamelCase) args.append(lowerCamelCase) return cls(*lowerCamelCase)
21
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
1
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging SCREAMING_SNAKE_CASE : Union[str, Any] = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : int = { "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 _lowerCamelCase( _a ): lowercase_ : int = """encodec""" def __init__( self, lowerCamelCase=[1.5, 3.0, 6.0, 1_2.0, 2_4.0], lowerCamelCase=2_40_00, lowerCamelCase=1, lowerCamelCase=False, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=1_28, lowerCamelCase=32, lowerCamelCase=1, lowerCamelCase=[8, 5, 4, 2], lowerCamelCase="weight_norm", lowerCamelCase=7, lowerCamelCase=7, lowerCamelCase=3, lowerCamelCase=2, lowerCamelCase=True, lowerCamelCase="reflect", lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=1.0, lowerCamelCase=10_24, lowerCamelCase=None, lowerCamelCase=True, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" _lowercase : List[Any] = target_bandwidths _lowercase : Dict = sampling_rate _lowercase : List[Any] = audio_channels _lowercase : Any = normalize _lowercase : str = chunk_length_s _lowercase : Tuple = overlap _lowercase : str = hidden_size _lowercase : List[Any] = num_filters _lowercase : Tuple = num_residual_layers _lowercase : Union[str, Any] = upsampling_ratios _lowercase : Union[str, Any] = norm_type _lowercase : Optional[int] = kernel_size _lowercase : List[str] = last_kernel_size _lowercase : Optional[Any] = residual_kernel_size _lowercase : Union[str, Any] = dilation_growth_rate _lowercase : Tuple = use_causal_conv _lowercase : Tuple = pad_mode _lowercase : str = compress _lowercase : List[str] = num_lstm_layers _lowercase : Optional[Any] = trim_right_ratio _lowercase : List[Any] = codebook_size _lowercase : Dict = codebook_dim if codebook_dim is not None else hidden_size _lowercase : int = 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__(**lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" 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 UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : Optional[int] = np.prod(self.upsampling_ratios) return math.ceil(self.sampling_rate / hop_length) @property def UpperCamelCase ( self) -> int: """simple docstring""" return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10))
21
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
1
import time import unittest from transformers import is_torch_available from transformers.testing_utils import require_torch, torch_device from ..test_modeling_common import ids_tensor if is_torch_available(): import torch from transformers.generation import ( MaxLengthCriteria, MaxNewTokensCriteria, MaxTimeCriteria, StoppingCriteriaList, validate_stopping_criteria, ) @require_torch class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self, lowerCamelCase) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = 3 _lowercase : Dict = 2_50 _lowercase : Optional[int] = ids_tensor((batch_size, length), lowerCamelCase) _lowercase : List[Any] = torch.ones((batch_size, length), device=lowerCamelCase, dtype=torch.float) / length return input_ids, scores def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : List[Any] = self._get_tensors(5) _lowercase : Optional[int] = StoppingCriteriaList( [ MaxLengthCriteria(max_length=10), MaxTimeCriteria(max_time=0.1), ]) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : Tuple = self._get_tensors(9) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : Dict = self._get_tensors(10) self.assertTrue(criteria(lowerCamelCase, lowerCamelCase)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : List[str] = MaxLengthCriteria(max_length=10) _lowercase , _lowercase : str = self._get_tensors(5) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : List[str] = self._get_tensors(9) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : Optional[int] = self._get_tensors(10) self.assertTrue(criteria(lowerCamelCase, lowerCamelCase)) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MaxNewTokensCriteria(start_length=5, max_new_tokens=5) _lowercase , _lowercase : Optional[int] = self._get_tensors(5) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : List[str] = self._get_tensors(9) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase , _lowercase : Union[str, Any] = self._get_tensors(10) self.assertTrue(criteria(lowerCamelCase, lowerCamelCase)) _lowercase : int = StoppingCriteriaList([criteria]) self.assertEqual(criteria_list.max_length, 10) def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase , _lowercase : Optional[int] = self._get_tensors(5) _lowercase : List[Any] = MaxTimeCriteria(max_time=0.1) self.assertFalse(criteria(lowerCamelCase, lowerCamelCase)) _lowercase : Union[str, Any] = MaxTimeCriteria(max_time=0.1, initial_timestamp=time.time() - 0.2) self.assertTrue(criteria(lowerCamelCase, lowerCamelCase)) def UpperCamelCase ( self) -> int: """simple docstring""" validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10)]), 10) with self.assertWarns(lowerCamelCase): validate_stopping_criteria(StoppingCriteriaList([MaxLengthCriteria(10)]), 11) _lowercase : Optional[Any] = validate_stopping_criteria(StoppingCriteriaList(), 11) self.assertEqual(len(lowerCamelCase), 1)
21
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
1
import os import tempfile import unittest import uuid from pathlib import Path from transformers.testing_utils import get_tests_dir, require_soundfile, require_torch, require_vision from transformers.tools.agent_types import AgentAudio, AgentImage, AgentText from transformers.utils import is_soundfile_availble, is_torch_available, is_vision_available if is_torch_available(): import torch if is_soundfile_availble(): import soundfile as sf if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_="" ) -> str: _lowercase : Optional[Any] = tempfile.mkdtemp() return os.path.join(lowerCamelCase_ , str(uuid.uuida() ) + suffix ) @require_soundfile @require_torch class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = torch.rand(12, dtype=torch.floataa) - 0.5 _lowercase : Dict = AgentAudio(lowerCamelCase) _lowercase : List[Any] = str(agent_type.to_string()) # Ensure that the tensor and the agent_type's tensor are the same self.assertTrue(torch.allclose(lowerCamelCase, agent_type.to_raw(), atol=1E-4)) del agent_type # Ensure the path remains even after the object deletion self.assertTrue(os.path.exists(lowerCamelCase)) # Ensure that the file contains the same value as the original tensor _lowercase , _lowercase : List[Any] = sf.read(lowerCamelCase) self.assertTrue(torch.allclose(lowerCamelCase, torch.tensor(lowerCamelCase), atol=1E-4)) def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : List[str] = torch.rand(12, dtype=torch.floataa) - 0.5 _lowercase : Optional[Any] = get_new_path(suffix='.wav') sf.write(lowerCamelCase, lowerCamelCase, 1_60_00) _lowercase : List[str] = AgentAudio(lowerCamelCase) self.assertTrue(torch.allclose(lowerCamelCase, agent_type.to_raw(), atol=1E-4)) self.assertEqual(agent_type.to_string(), lowerCamelCase) @require_vision @require_torch class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = torch.randint(0, 2_56, (64, 64, 3)) _lowercase : List[Any] = AgentImage(lowerCamelCase) _lowercase : Any = str(agent_type.to_string()) # Ensure that the tensor and the agent_type's tensor are the same self.assertTrue(torch.allclose(lowerCamelCase, agent_type._tensor, atol=1E-4)) self.assertIsInstance(agent_type.to_raw(), Image.Image) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(lowerCamelCase)) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Optional[Any] = Path(get_tests_dir('fixtures/tests_samples/COCO')) / '000000039769.png' _lowercase : Any = Image.open(lowerCamelCase) _lowercase : Optional[int] = AgentImage(lowerCamelCase) self.assertTrue(path.samefile(agent_type.to_string())) self.assertTrue(image == agent_type.to_raw()) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(lowerCamelCase)) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = Path(get_tests_dir('fixtures/tests_samples/COCO')) / '000000039769.png' _lowercase : Optional[int] = Image.open(lowerCamelCase) _lowercase : List[str] = AgentImage(lowerCamelCase) self.assertFalse(path.samefile(agent_type.to_string())) self.assertTrue(image == agent_type.to_raw()) # Ensure the path remains even after the object deletion del agent_type self.assertTrue(os.path.exists(lowerCamelCase)) class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'Hey!' _lowercase : List[str] = AgentText(lowerCamelCase) self.assertEqual(lowerCamelCase, agent_type.to_string()) self.assertEqual(lowerCamelCase, agent_type.to_raw()) self.assertEqual(lowerCamelCase, lowerCamelCase)
21
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
1
import re from filelock import FileLock try: import nltk SCREAMING_SNAKE_CASE : List[Any] = True except (ImportError, ModuleNotFoundError): SCREAMING_SNAKE_CASE : int = False if NLTK_AVAILABLE: with FileLock(".lock") as lock: nltk.download("punkt", quiet=True) def UpperCamelCase_( lowerCamelCase_ ) -> str: re.sub('<n>' , '' , lowerCamelCase_ ) # 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(lowerCamelCase_ ) )
21
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
1
from __future__ import annotations import bisect def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = 0 , lowerCamelCase_ = -1 ) -> int: if hi < 0: _lowercase : List[Any] = len(lowerCamelCase_ ) while lo < hi: _lowercase : Tuple = lo + (hi - lo) // 2 if sorted_collection[mid] < item: _lowercase : int = mid + 1 else: _lowercase : int = mid return lo def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = 0 , lowerCamelCase_ = -1 ) -> int: if hi < 0: _lowercase : Optional[Any] = len(lowerCamelCase_ ) while lo < hi: _lowercase : Tuple = lo + (hi - lo) // 2 if sorted_collection[mid] <= item: _lowercase : Any = mid + 1 else: _lowercase : int = mid return lo def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = 0 , lowerCamelCase_ = -1 ) -> None: sorted_collection.insert(bisect_left(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) , lowerCamelCase_ ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = 0 , lowerCamelCase_ = -1 ) -> None: sorted_collection.insert(bisect_right(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) , lowerCamelCase_ ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> int | None: _lowercase : str = 0 _lowercase : List[str] = len(lowerCamelCase_ ) - 1 while left <= right: _lowercase : Dict = left + (right - left) // 2 _lowercase : List[str] = sorted_collection[midpoint] if current_item == item: return midpoint elif item < current_item: _lowercase : Optional[Any] = midpoint - 1 else: _lowercase : Dict = midpoint + 1 return None def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> int | None: _lowercase : int = bisect.bisect_left(lowerCamelCase_ , lowerCamelCase_ ) if index != len(lowerCamelCase_ ) and sorted_collection[index] == item: return index return None def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> int | None: if right < left: return None _lowercase : int = left + (right - left) // 2 if sorted_collection[midpoint] == item: return midpoint elif sorted_collection[midpoint] > item: return binary_search_by_recursion(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , midpoint - 1 ) else: return binary_search_by_recursion(lowerCamelCase_ , lowerCamelCase_ , midpoint + 1 , lowerCamelCase_ ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : List[Any] = input("Enter numbers separated by comma:\n").strip() SCREAMING_SNAKE_CASE : Union[str, Any] = sorted(int(item) for item in user_input.split(",")) SCREAMING_SNAKE_CASE : int = int(input("Enter a single number to be found in the list:\n")) SCREAMING_SNAKE_CASE : Any = binary_search(collection, target) if result is None: print(F"{target} was not found in {collection}.") else: print(F"{target} was found at position {result} in {collection}.")
21
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 _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) 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 UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): 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) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = 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=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
1
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 : str = None SCREAMING_SNAKE_CASE : str = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[Any] = {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Optional[int] = { "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[int] = { "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 : Union[str, Any] = "▁" class _lowerCamelCase( _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Dict = PRETRAINED_VOCAB_FILES_MAP lowercase_ : Optional[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : List[Any] = AlbertTokenizer def __init__( self, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="[CLS]", lowerCamelCase="[SEP]", lowerCamelCase="<unk>", lowerCamelCase="[SEP]", lowerCamelCase="<pad>", lowerCamelCase="[CLS]", lowerCamelCase="[MASK]", **lowerCamelCase, ) -> Optional[Any]: """simple docstring""" _lowercase : Optional[Any] = ( AddedToken(lowerCamelCase, lstrip=lowerCamelCase, rstrip=lowerCamelCase, normalized=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase) else mask_token ) super().__init__( lowerCamelCase, tokenizer_file=lowerCamelCase, do_lower_case=lowerCamelCase, remove_space=lowerCamelCase, keep_accents=lowerCamelCase, bos_token=lowerCamelCase, eos_token=lowerCamelCase, unk_token=lowerCamelCase, sep_token=lowerCamelCase, pad_token=lowerCamelCase, cls_token=lowerCamelCase, mask_token=lowerCamelCase, **lowerCamelCase, ) _lowercase : List[Any] = do_lower_case _lowercase : List[Any] = remove_space _lowercase : Optional[int] = keep_accents _lowercase : Optional[int] = vocab_file _lowercase : List[Any] = False if not self.vocab_file else True def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase = None) -> List[int]: """simple docstring""" _lowercase : str = [self.sep_token_id] _lowercase : int = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase = None) -> List[int]: """simple docstring""" _lowercase : Dict = [self.sep_token_id] _lowercase : str = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep) * [0] return len(cls + token_ids_a + sep) * [0] + len(token_ids_a + sep) * [1] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase = None) -> Tuple[str]: """simple docstring""" if not self.can_save_slow_tokenizer: raise ValueError( 'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow ' 'tokenizer.') if not os.path.isdir(lowerCamelCase): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''') return _lowercase : Optional[Any] = os.path.join( lowerCamelCase, (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']) if os.path.abspath(self.vocab_file) != os.path.abspath(lowerCamelCase): copyfile(self.vocab_file, lowerCamelCase) return (out_vocab_file,)
21
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
1
import argparse import collections import os import re from transformers.utils import direct_transformers_import # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_table.py SCREAMING_SNAKE_CASE : int = "src/transformers" SCREAMING_SNAKE_CASE : Any = "docs/source/en" SCREAMING_SNAKE_CASE : str = "." def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: with open(lowerCamelCase_ , 'r' , encoding='utf-8' , newline='\n' ) as f: _lowercase : Dict = f.readlines() # Find the start prompt. _lowercase : int = 0 while not lines[start_index].startswith(lowerCamelCase_ ): start_index += 1 start_index += 1 _lowercase : Any = start_index while not lines[end_index].startswith(lowerCamelCase_ ): end_index += 1 end_index -= 1 while len(lines[start_index] ) <= 1: start_index += 1 while len(lines[end_index] ) <= 1: end_index -= 1 end_index += 1 return "".join(lines[start_index:end_index] ), start_index, end_index, lines # Add here suffixes that are used to identify models, separated by | SCREAMING_SNAKE_CASE : Dict = "Model|Encoder|Decoder|ForConditionalGeneration" # Regexes that match TF/Flax/PT model names. SCREAMING_SNAKE_CASE : Dict = re.compile(r"TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)") SCREAMING_SNAKE_CASE : int = re.compile(r"Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)") # Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes. SCREAMING_SNAKE_CASE : List[Any] = re.compile(r"(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)") # This is to make sure the transformers module imported is the one in the repo. SCREAMING_SNAKE_CASE : str = direct_transformers_import(TRANSFORMERS_PATH) def UpperCamelCase_( lowerCamelCase_ ) -> Optional[Any]: _lowercase : List[Any] = re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)' , lowerCamelCase_ ) return [m.group(0 ) for m in matches] def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[Any]: _lowercase : Optional[int] = 2 if text == '✅' or text == '❌' else len(lowerCamelCase_ ) _lowercase : Union[str, Any] = (width - text_length) // 2 _lowercase : str = width - text_length - left_indent return " " * left_indent + text + " " * right_indent def UpperCamelCase_( ) -> List[Any]: _lowercase : Any = transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES _lowercase : str = { name: config_maping_names[code] for code, name in transformers_module.MODEL_NAMES_MAPPING.items() if code in config_maping_names } _lowercase : str = {name: config.replace('Config' , '' ) for name, config in model_name_to_config.items()} # Dictionaries flagging if each model prefix has a slow/fast tokenizer, backend in PT/TF/Flax. _lowercase : Optional[Any] = collections.defaultdict(lowerCamelCase_ ) _lowercase : Tuple = collections.defaultdict(lowerCamelCase_ ) _lowercase : int = collections.defaultdict(lowerCamelCase_ ) _lowercase : str = collections.defaultdict(lowerCamelCase_ ) _lowercase : str = collections.defaultdict(lowerCamelCase_ ) # Let's lookup through all transformers object (once). for attr_name in dir(lowerCamelCase_ ): _lowercase : Optional[int] = None if attr_name.endswith('Tokenizer' ): _lowercase : str = slow_tokenizers _lowercase : Any = attr_name[:-9] elif attr_name.endswith('TokenizerFast' ): _lowercase : Union[str, Any] = fast_tokenizers _lowercase : str = attr_name[:-13] elif _re_tf_models.match(lowerCamelCase_ ) is not None: _lowercase : str = tf_models _lowercase : Dict = _re_tf_models.match(lowerCamelCase_ ).groups()[0] elif _re_flax_models.match(lowerCamelCase_ ) is not None: _lowercase : Union[str, Any] = flax_models _lowercase : List[Any] = _re_flax_models.match(lowerCamelCase_ ).groups()[0] elif _re_pt_models.match(lowerCamelCase_ ) is not None: _lowercase : Any = pt_models _lowercase : Dict = _re_pt_models.match(lowerCamelCase_ ).groups()[0] if lookup_dict is not None: while len(lowerCamelCase_ ) > 0: if attr_name in model_name_to_prefix.values(): _lowercase : Dict = True break # Try again after removing the last word in the name _lowercase : List[str] = ''.join(camel_case_split(lowerCamelCase_ )[:-1] ) # Let's build that table! _lowercase : Optional[Any] = list(model_name_to_config.keys() ) model_names.sort(key=str.lower ) _lowercase : Tuple = ['Model', 'Tokenizer slow', 'Tokenizer fast', 'PyTorch support', 'TensorFlow support', 'Flax Support'] # We'll need widths to properly display everything in the center (+2 is to leave one extra space on each side). _lowercase : List[Any] = [len(lowerCamelCase_ ) + 2 for c in columns] _lowercase : str = max([len(lowerCamelCase_ ) for name in model_names] ) + 2 # Build the table per se _lowercase : int = '|' + '|'.join([_center_text(lowerCamelCase_ , lowerCamelCase_ ) for c, w in zip(lowerCamelCase_ , lowerCamelCase_ )] ) + '|\n' # Use ":-----:" format to center-aligned table cell texts table += "|" + "|".join([':' + '-' * (w - 2) + ':' for w in widths] ) + "|\n" _lowercase : List[str] = {True: '✅', False: '❌'} for name in model_names: _lowercase : List[str] = model_name_to_prefix[name] _lowercase : Dict = [ name, check[slow_tokenizers[prefix]], check[fast_tokenizers[prefix]], check[pt_models[prefix]], check[tf_models[prefix]], check[flax_models[prefix]], ] table += "|" + "|".join([_center_text(lowerCamelCase_ , lowerCamelCase_ ) for l, w in zip(lowerCamelCase_ , lowerCamelCase_ )] ) + "|\n" return table def UpperCamelCase_( lowerCamelCase_=False ) -> List[Any]: _lowercase , _lowercase , _lowercase , _lowercase : Dict = _find_text_in_file( filename=os.path.join(lowerCamelCase_ , 'index.md' ) , start_prompt='<!--This table is updated automatically from the auto modules' , end_prompt='<!-- End table-->' , ) _lowercase : Union[str, Any] = get_model_table_from_auto_modules() if current_table != new_table: if overwrite: with open(os.path.join(lowerCamelCase_ , 'index.md' ) , 'w' , encoding='utf-8' , newline='\n' ) as f: f.writelines(lines[:start_index] + [new_table] + lines[end_index:] ) else: raise ValueError( 'The model table in the `index.md` has not been updated. Run `make fix-copies` to fix this.' ) if __name__ == "__main__": SCREAMING_SNAKE_CASE : Dict = argparse.ArgumentParser() parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.") SCREAMING_SNAKE_CASE : Tuple = parser.parse_args() check_model_table(args.fix_and_overwrite)
21
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
1
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 _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) 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 UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): 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) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = 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=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
1
UpperCAmelCase__ = [sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(100000)] def _a ( a :int ) -> int: a = 0 while number: # Increased Speed Slightly by checking every 5 digits together. sum_of_digits_squared += DIGITS_SQUARED[number % 100_000] number //= 100_000 return sum_of_digits_squared # There are 2 Chains made, # One ends with 89 with the chain member 58 being the one which when declared first, # there will be the least number of iterations for all the members to be checked. # The other one ends with 1 and has only one element 1. # So 58 and 1 are chosen to be declared at the starting. # Changed dictionary to an array to quicken the solution UpperCAmelCase__ = [None] * 10000000 UpperCAmelCase__ = True UpperCAmelCase__ = False def _a ( a :int ) -> bool: if CHAINS[number - 1] is not None: return CHAINS[number - 1] # type: ignore a = chain(next_number(a ) ) a = number_chain while number < 10_000_000: a = number_chain number *= 10 return number_chain def _a ( a :int = 10_000_000 ) -> int: for i in range(1 , a ): if CHAINS[i] is None: chain(i + 1 ) return CHAINS[:number].count(a ) if __name__ == "__main__": import doctest doctest.testmod() print(f"""{solution() = }""")
0
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
0
'''simple docstring''' from typing import Callable, Dict, Optional, Tuple import torch from torch import nn from torch.distributions import ( AffineTransform, Distribution, Independent, NegativeBinomial, Normal, StudentT, TransformedDistribution, ) class __A ( UpperCamelCase__ ): def __init__(self : int , __a : Distribution , __a : Dict=None , __a : int=None , __a : Any=0 ): UpperCAmelCase_ = 1.0 if scale is None else scale UpperCAmelCase_ = 0.0 if loc is None else loc super().__init__(__a , [AffineTransform(loc=self.loc , scale=self.scale , event_dim=__a )] ) @property def _lowercase (self : Union[str, Any] ): return self.base_dist.mean * self.scale + self.loc @property def _lowercase (self : List[Any] ): return self.base_dist.variance * self.scale**2 @property def _lowercase (self : List[Any] ): return self.variance.sqrt() class __A ( nn.Module ): def __init__(self : Optional[int] , __a : int , __a : Dict[str, int] , __a : Callable[..., Tuple[torch.Tensor]] , **__a : List[str] ): super().__init__(**__a ) UpperCAmelCase_ = args_dim UpperCAmelCase_ = nn.ModuleList([nn.Linear(__a , __a ) for dim in args_dim.values()] ) UpperCAmelCase_ = domain_map def _lowercase (self : List[str] , __a : torch.Tensor ): UpperCAmelCase_ = [proj(__a ) for proj in self.proj] return self.domain_map(*__a ) class __A ( nn.Module ): def __init__(self : Union[str, Any] , __a : List[str] ): super().__init__() UpperCAmelCase_ = function def _lowercase (self : Optional[int] , __a : List[str] , *__a : Optional[int] ): return self.function(__a , *__a ) class __A : a__ : type a__ : int a__ : Dict[str, int] def __init__(self : List[Any] , __a : int = 1 ): UpperCAmelCase_ = dim UpperCAmelCase_ = {k: dim * self.args_dim[k] for k in self.args_dim} def _lowercase (self : Any , __a : Any ): if self.dim == 1: return self.distribution_class(*__a ) else: return Independent(self.distribution_class(*__a ) , 1 ) def _lowercase (self : List[str] , __a : Union[str, Any] , __a : Optional[torch.Tensor] = None , __a : Optional[torch.Tensor] = None , ): UpperCAmelCase_ = self._base_distribution(__a ) if loc is None and scale is None: return distr else: return AffineTransformed(__a , loc=__a , scale=__a , event_dim=self.event_dim ) @property def _lowercase (self : Any ): return () if self.dim == 1 else (self.dim,) @property def _lowercase (self : Dict ): return len(self.event_shape ) @property def _lowercase (self : Tuple ): return 0.0 def _lowercase (self : List[str] , __a : int ): return ParameterProjection( in_features=__a , args_dim=self.args_dim , domain_map=LambdaLayer(self.domain_map ) , ) def _lowercase (self : Optional[int] , *__a : torch.Tensor ): raise NotImplementedError() @staticmethod def _lowercase (__a : torch.Tensor ): return (x + torch.sqrt(torch.square(__a ) + 4.0 )) / 2.0 class __A ( UpperCamelCase__ ): a__ : Dict[str, int] = {"df": 1, "loc": 1, "scale": 1} a__ : type = StudentT @classmethod def _lowercase (cls : Union[str, Any] , __a : torch.Tensor , __a : torch.Tensor , __a : torch.Tensor ): UpperCAmelCase_ = cls.squareplus(__a ).clamp_min(torch.finfo(scale.dtype ).eps ) UpperCAmelCase_ = 2.0 + cls.squareplus(__a ) return df.squeeze(-1 ), loc.squeeze(-1 ), scale.squeeze(-1 ) class __A ( UpperCamelCase__ ): a__ : Dict[str, int] = {"loc": 1, "scale": 1} a__ : type = Normal @classmethod def _lowercase (cls : Tuple , __a : torch.Tensor , __a : torch.Tensor ): UpperCAmelCase_ = cls.squareplus(__a ).clamp_min(torch.finfo(scale.dtype ).eps ) return loc.squeeze(-1 ), scale.squeeze(-1 ) class __A ( UpperCamelCase__ ): a__ : Dict[str, int] = {"total_count": 1, "logits": 1} a__ : type = NegativeBinomial @classmethod def _lowercase (cls : Optional[Any] , __a : torch.Tensor , __a : torch.Tensor ): UpperCAmelCase_ = cls.squareplus(__a ) return total_count.squeeze(-1 ), logits.squeeze(-1 ) def _lowercase (self : List[str] , __a : str ): UpperCAmelCase_ , UpperCAmelCase_ = distr_args if self.dim == 1: return self.distribution_class(total_count=__a , logits=__a ) else: return Independent(self.distribution_class(total_count=__a , logits=__a ) , 1 ) def _lowercase (self : Optional[Any] , __a : int , __a : Optional[torch.Tensor] = None , __a : Optional[torch.Tensor] = None ): UpperCAmelCase_ , UpperCAmelCase_ = distr_args if scale is not None: # See scaling property of Gamma. logits += scale.log() return self._base_distribution((total_count, logits) )
1
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
0
'''simple docstring''' # Lint as: python3 import itertools import os import re lowerCamelCase : Any = re.compile(R'([A-Z]+)([A-Z][a-z])') lowerCamelCase : str = re.compile(R'([a-z\d])([A-Z])') lowerCamelCase : Optional[int] = re.compile(R'(?<!_)_(?!_)') lowerCamelCase : List[Any] = re.compile(R'(_{2,})') lowerCamelCase : str = R'^\w+(\.\w+)*$' lowerCamelCase : Dict = R'<>:/\|?*' def _SCREAMING_SNAKE_CASE (A ) -> Any: """simple docstring""" lowercase__ = _uppercase_uppercase_re.sub(R'''\1_\2''' , A ) lowercase__ = _lowercase_uppercase_re.sub(R'''\1_\2''' , A ) return name.lower() def _SCREAMING_SNAKE_CASE (A ) -> Tuple: """simple docstring""" lowercase__ = _single_underscore_re.split(A ) lowercase__ = [_multiple_underscores_re.split(A ) for n in name] return "".join(n.capitalize() for n in itertools.chain.from_iterable(A ) if n != '''''' ) def _SCREAMING_SNAKE_CASE (A ) -> Tuple: """simple docstring""" if os.path.basename(A ) != name: raise ValueError(f"Should be a dataset name, not a path: {name}" ) return camelcase_to_snakecase(A ) def _SCREAMING_SNAKE_CASE (A , A ) -> Optional[Any]: """simple docstring""" if os.path.basename(A ) != name: raise ValueError(f"Should be a dataset name, not a path: {name}" ) if not re.match(_split_re , A ): raise ValueError(f"Split name should match '{_split_re}'' but got '{split}'." ) return f"{filename_prefix_for_name(A )}-{split}" def _SCREAMING_SNAKE_CASE (A , A , A , A=None ) -> List[str]: """simple docstring""" lowercase__ = filename_prefix_for_split(A , A ) if filetype_suffix: prefix += f".{filetype_suffix}" lowercase__ = os.path.join(A , A ) return f"{filepath}*" def _SCREAMING_SNAKE_CASE (A , A , A , A=None , A=None ) -> Optional[Any]: """simple docstring""" lowercase__ = filename_prefix_for_split(A , A ) lowercase__ = os.path.join(A , A ) if shard_lengths: lowercase__ = len(A ) lowercase__ = [f"{prefix}-{shard_id:05d}-of-{num_shards:05d}" for shard_id in range(A )] if filetype_suffix: lowercase__ = [filename + f".{filetype_suffix}" for filename in filenames] return filenames else: lowercase__ = prefix if filetype_suffix: filename += f".{filetype_suffix}" return [filename]
2
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
0
'''simple docstring''' import functools from typing import Any def lowerCAmelCase_ ( snake_case__ , snake_case__ ): '''simple docstring''' if not isinstance(snake_case__ , snake_case__ ) or len(snake_case__ ) == 0: raise ValueError('''the string should be not empty string''' ) if not isinstance(snake_case__ , snake_case__ ) or not all( isinstance(snake_case__ , snake_case__ ) and len(snake_case__ ) > 0 for item in words ): raise ValueError('''the words should be a list of non-empty strings''' ) # Build trie A : dict[str, Any] = {} A : Union[str, Any] = '''WORD_KEEPER''' for word in words: A : Union[str, Any] = trie for c in word: if c not in trie_node: A : List[Any] = {} A : Tuple = trie_node[c] A : int = True A : str = len(snake_case__ ) # Dynamic programming method @functools.cache def is_breakable(snake_case__ ) -> bool: if index == len_string: return True A : Optional[int] = trie for i in range(snake_case__ , snake_case__ ): A : Dict = trie_node.get(string[i] , snake_case__ ) if trie_node is None: return False if trie_node.get(snake_case__ , snake_case__ ) and is_breakable(i + 1 ): return True return False return is_breakable(0 ) if __name__ == "__main__": import doctest doctest.testmod()
3
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
'''simple docstring''' from typing import Optional import torch import torch.utils.checkpoint from torch import Tensor, nn from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss from ...activations import ACTaFN from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward from ...modeling_outputs import ( BaseModelOutputWithNoAttention, BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention, ) from ...modeling_utils import PreTrainedModel from ...utils import logging from .configuration_regnet import RegNetConfig __snake_case =logging.get_logger(__name__) # General docstring __snake_case ="""RegNetConfig""" # Base docstring __snake_case ="""facebook/regnet-y-040""" __snake_case =[1, 1_088, 7, 7] # Image classification docstring __snake_case ="""facebook/regnet-y-040""" __snake_case ="""tabby, tabby cat""" __snake_case =[ """facebook/regnet-y-040""", # See all regnet models at https://huggingface.co/models?filter=regnet ] class UpperCAmelCase_ ( nn.Module ): def __init__( self : List[Any] , UpperCAmelCase__ : int , UpperCAmelCase__ : int , UpperCAmelCase__ : int = 3 , UpperCAmelCase__ : int = 1 , UpperCAmelCase__ : int = 1 , UpperCAmelCase__ : Optional[str] = "relu" , ) -> Any: super().__init__() lowerCAmelCase = nn.Convad( UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=UpperCAmelCase__ , stride=UpperCAmelCase__ , padding=kernel_size // 2 , groups=UpperCAmelCase__ , bias=UpperCAmelCase__ , ) lowerCAmelCase = nn.BatchNormad(UpperCAmelCase__ ) lowerCAmelCase = ACTaFN[activation] if activation is not None else nn.Identity() def __UpperCAmelCase ( self : Dict , UpperCAmelCase__ : Tuple ) -> Tuple: lowerCAmelCase = self.convolution(UpperCAmelCase__ ) lowerCAmelCase = self.normalization(UpperCAmelCase__ ) lowerCAmelCase = self.activation(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Optional[int] , UpperCAmelCase__ : RegNetConfig ) -> Tuple: super().__init__() lowerCAmelCase = RegNetConvLayer( config.num_channels , config.embedding_size , kernel_size=3 , stride=2 , activation=config.hidden_act ) lowerCAmelCase = config.num_channels def __UpperCAmelCase ( self : Union[str, Any] , UpperCAmelCase__ : Optional[Any] ) -> Any: lowerCAmelCase = pixel_values.shape[1] if num_channels != self.num_channels: raise ValueError( 'Make sure that the channel dimension of the pixel values match with the one set in the configuration.' ) lowerCAmelCase = self.embedder(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Tuple , UpperCAmelCase__ : int , UpperCAmelCase__ : int , UpperCAmelCase__ : int = 2 ) -> Optional[int]: super().__init__() lowerCAmelCase = nn.Convad(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 , stride=UpperCAmelCase__ , bias=UpperCAmelCase__ ) lowerCAmelCase = nn.BatchNormad(UpperCAmelCase__ ) def __UpperCAmelCase ( self : Union[str, Any] , UpperCAmelCase__ : Tensor ) -> Tensor: lowerCAmelCase = self.convolution(UpperCAmelCase__ ) lowerCAmelCase = self.normalization(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Any , UpperCAmelCase__ : int , UpperCAmelCase__ : int ) -> Union[str, Any]: super().__init__() lowerCAmelCase = nn.AdaptiveAvgPoolad((1, 1) ) lowerCAmelCase = nn.Sequential( nn.Convad(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 ) , nn.ReLU() , nn.Convad(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 ) , nn.Sigmoid() , ) def __UpperCAmelCase ( self : Tuple , UpperCAmelCase__ : str ) -> Optional[Any]: # b c h w -> b c 1 1 lowerCAmelCase = self.pooler(UpperCAmelCase__ ) lowerCAmelCase = self.attention(UpperCAmelCase__ ) lowerCAmelCase = hidden_state * attention return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Optional[int] , UpperCAmelCase__ : RegNetConfig , UpperCAmelCase__ : int , UpperCAmelCase__ : int , UpperCAmelCase__ : int = 1 ) -> Optional[int]: super().__init__() lowerCAmelCase = in_channels != out_channels or stride != 1 lowerCAmelCase = max(1 , out_channels // config.groups_width ) lowerCAmelCase = ( RegNetShortCut(UpperCAmelCase__ , UpperCAmelCase__ , stride=UpperCAmelCase__ ) if should_apply_shortcut else nn.Identity() ) lowerCAmelCase = nn.Sequential( RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 , activation=config.hidden_act ) , RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , stride=UpperCAmelCase__ , groups=UpperCAmelCase__ , activation=config.hidden_act ) , RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 , activation=UpperCAmelCase__ ) , ) lowerCAmelCase = ACTaFN[config.hidden_act] def __UpperCAmelCase ( self : Dict , UpperCAmelCase__ : Any ) -> Union[str, Any]: lowerCAmelCase = hidden_state lowerCAmelCase = self.layer(UpperCAmelCase__ ) lowerCAmelCase = self.shortcut(UpperCAmelCase__ ) hidden_state += residual lowerCAmelCase = self.activation(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : str , UpperCAmelCase__ : RegNetConfig , UpperCAmelCase__ : int , UpperCAmelCase__ : int , UpperCAmelCase__ : int = 1 ) -> Optional[Any]: super().__init__() lowerCAmelCase = in_channels != out_channels or stride != 1 lowerCAmelCase = max(1 , out_channels // config.groups_width ) lowerCAmelCase = ( RegNetShortCut(UpperCAmelCase__ , UpperCAmelCase__ , stride=UpperCAmelCase__ ) if should_apply_shortcut else nn.Identity() ) lowerCAmelCase = nn.Sequential( RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 , activation=config.hidden_act ) , RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , stride=UpperCAmelCase__ , groups=UpperCAmelCase__ , activation=config.hidden_act ) , RegNetSELayer(UpperCAmelCase__ , reduced_channels=int(round(in_channels / 4 ) ) ) , RegNetConvLayer(UpperCAmelCase__ , UpperCAmelCase__ , kernel_size=1 , activation=UpperCAmelCase__ ) , ) lowerCAmelCase = ACTaFN[config.hidden_act] def __UpperCAmelCase ( self : Any , UpperCAmelCase__ : Union[str, Any] ) -> Tuple: lowerCAmelCase = hidden_state lowerCAmelCase = self.layer(UpperCAmelCase__ ) lowerCAmelCase = self.shortcut(UpperCAmelCase__ ) hidden_state += residual lowerCAmelCase = self.activation(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Union[str, Any] , UpperCAmelCase__ : RegNetConfig , UpperCAmelCase__ : int , UpperCAmelCase__ : int , UpperCAmelCase__ : int = 2 , UpperCAmelCase__ : int = 2 , ) -> Optional[Any]: super().__init__() lowerCAmelCase = RegNetXLayer if config.layer_type == 'x' else RegNetYLayer lowerCAmelCase = nn.Sequential( # downsampling is done in the first layer with stride of 2 layer( UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , stride=UpperCAmelCase__ , ) , *[layer(UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ ) for _ in range(depth - 1 )] , ) def __UpperCAmelCase ( self : Optional[Any] , UpperCAmelCase__ : List[str] ) -> Tuple: lowerCAmelCase = self.layers(UpperCAmelCase__ ) return hidden_state class UpperCAmelCase_ ( nn.Module ): def __init__( self : Any , UpperCAmelCase__ : RegNetConfig ) -> Dict: super().__init__() lowerCAmelCase = nn.ModuleList([] ) # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input self.stages.append( RegNetStage( UpperCAmelCase__ , config.embedding_size , config.hidden_sizes[0] , stride=2 if config.downsample_in_first_stage else 1 , depth=config.depths[0] , ) ) lowerCAmelCase = zip(config.hidden_sizes , config.hidden_sizes[1:] ) for (in_channels, out_channels), depth in zip(UpperCAmelCase__ , config.depths[1:] ): self.stages.append(RegNetStage(UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , depth=UpperCAmelCase__ ) ) def __UpperCAmelCase ( self : Union[str, Any] , UpperCAmelCase__ : Tensor , UpperCAmelCase__ : bool = False , UpperCAmelCase__ : bool = True ) -> BaseModelOutputWithNoAttention: lowerCAmelCase = () if output_hidden_states else None for stage_module in self.stages: if output_hidden_states: lowerCAmelCase = hidden_states + (hidden_state,) lowerCAmelCase = stage_module(UpperCAmelCase__ ) if output_hidden_states: lowerCAmelCase = hidden_states + (hidden_state,) if not return_dict: return tuple(v for v in [hidden_state, hidden_states] if v is not None ) return BaseModelOutputWithNoAttention(last_hidden_state=UpperCAmelCase__ , hidden_states=UpperCAmelCase__ ) class UpperCAmelCase_ ( __lowercase ): lowerCamelCase : List[Any] = RegNetConfig lowerCamelCase : Any = '''regnet''' lowerCamelCase : Any = '''pixel_values''' lowerCamelCase : Union[str, Any] = True def __UpperCAmelCase ( self : List[str] , UpperCAmelCase__ : int ) -> Optional[int]: if isinstance(UpperCAmelCase__ , nn.Convad ): nn.init.kaiming_normal_(module.weight , mode='fan_out' , nonlinearity='relu' ) elif isinstance(UpperCAmelCase__ , (nn.BatchNormad, nn.GroupNorm) ): nn.init.constant_(module.weight , 1 ) nn.init.constant_(module.bias , 0 ) def __UpperCAmelCase ( self : str , UpperCAmelCase__ : Optional[int] , UpperCAmelCase__ : Tuple=False ) -> Any: if isinstance(UpperCAmelCase__ , UpperCAmelCase__ ): lowerCAmelCase = value __snake_case =R""" This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`RegNetConfig`]): Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. """ __snake_case =R""" Args: pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`ConvNextImageProcessor.__call__`] for details. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple. """ @add_start_docstrings( '''The bare RegNet model outputting raw features without any specific head on top.''' , __lowercase , ) # Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet class UpperCAmelCase_ ( __lowercase ): def __init__( self : List[str] , UpperCAmelCase__ : Optional[int] ) -> List[Any]: super().__init__(UpperCAmelCase__ ) lowerCAmelCase = config lowerCAmelCase = RegNetEmbeddings(UpperCAmelCase__ ) lowerCAmelCase = RegNetEncoder(UpperCAmelCase__ ) lowerCAmelCase = nn.AdaptiveAvgPoolad((1, 1) ) # Initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(UpperCAmelCase__ ) @add_code_sample_docstrings( checkpoint=_CHECKPOINT_FOR_DOC , output_type=UpperCAmelCase__ , config_class=_CONFIG_FOR_DOC , modality='vision' , expected_output=_EXPECTED_OUTPUT_SHAPE , ) def __UpperCAmelCase ( self : Dict , UpperCAmelCase__ : Tensor , UpperCAmelCase__ : Optional[bool] = None , UpperCAmelCase__ : Optional[bool] = None ) -> BaseModelOutputWithPoolingAndNoAttention: lowerCAmelCase = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) lowerCAmelCase = return_dict if return_dict is not None else self.config.use_return_dict lowerCAmelCase = self.embedder(UpperCAmelCase__ ) lowerCAmelCase = self.encoder( UpperCAmelCase__ , output_hidden_states=UpperCAmelCase__ , return_dict=UpperCAmelCase__ ) lowerCAmelCase = encoder_outputs[0] lowerCAmelCase = self.pooler(UpperCAmelCase__ ) if not return_dict: return (last_hidden_state, pooled_output) + encoder_outputs[1:] return BaseModelOutputWithPoolingAndNoAttention( last_hidden_state=UpperCAmelCase__ , pooler_output=UpperCAmelCase__ , hidden_states=encoder_outputs.hidden_states , ) @add_start_docstrings( ''' RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for ImageNet. ''' , __lowercase , ) # Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet class UpperCAmelCase_ ( __lowercase ): def __init__( self : Optional[int] , UpperCAmelCase__ : Union[str, Any] ) -> str: super().__init__(UpperCAmelCase__ ) lowerCAmelCase = config.num_labels lowerCAmelCase = RegNetModel(UpperCAmelCase__ ) # classification head lowerCAmelCase = nn.Sequential( nn.Flatten() , nn.Linear(config.hidden_sizes[-1] , config.num_labels ) if config.num_labels > 0 else nn.Identity() , ) # initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(UpperCAmelCase__ ) @add_code_sample_docstrings( checkpoint=_IMAGE_CLASS_CHECKPOINT , output_type=UpperCAmelCase__ , config_class=_CONFIG_FOR_DOC , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT , ) def __UpperCAmelCase ( self : int , UpperCAmelCase__ : Optional[torch.FloatTensor] = None , UpperCAmelCase__ : Optional[torch.LongTensor] = None , UpperCAmelCase__ : Optional[bool] = None , UpperCAmelCase__ : Optional[bool] = None , ) -> ImageClassifierOutputWithNoAttention: lowerCAmelCase = return_dict if return_dict is not None else self.config.use_return_dict lowerCAmelCase = self.regnet(UpperCAmelCase__ , output_hidden_states=UpperCAmelCase__ , return_dict=UpperCAmelCase__ ) lowerCAmelCase = outputs.pooler_output if return_dict else outputs[1] lowerCAmelCase = self.classifier(UpperCAmelCase__ ) lowerCAmelCase = None if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: lowerCAmelCase = 'regression' elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): lowerCAmelCase = 'single_label_classification' else: lowerCAmelCase = 'multi_label_classification' if self.config.problem_type == "regression": lowerCAmelCase = MSELoss() if self.num_labels == 1: lowerCAmelCase = loss_fct(logits.squeeze() , labels.squeeze() ) else: lowerCAmelCase = loss_fct(UpperCAmelCase__ , UpperCAmelCase__ ) elif self.config.problem_type == "single_label_classification": lowerCAmelCase = CrossEntropyLoss() lowerCAmelCase = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) elif self.config.problem_type == "multi_label_classification": lowerCAmelCase = BCEWithLogitsLoss() lowerCAmelCase = loss_fct(UpperCAmelCase__ , UpperCAmelCase__ ) if not return_dict: lowerCAmelCase = (logits,) + outputs[2:] return (loss,) + output if loss is not None else output return ImageClassifierOutputWithNoAttention(loss=UpperCAmelCase__ , logits=UpperCAmelCase__ , hidden_states=outputs.hidden_states )
4
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
0
import sys from typing import Tuple import numpy as np import torch from PIL import Image from torch import nn from transformers.image_utils import PILImageResampling from utils import img_tensorize class lowerCamelCase__ : def __init__(self , UpperCAmelCase , UpperCAmelCase=sys.maxsize ) -> str: _lowercase ='''bilinear''' _lowercase =max_size _lowercase =short_edge_length def __call__(self , UpperCAmelCase ) -> int: _lowercase =[] for img in imgs: _lowercase , _lowercase =img.shape[:2] # later: provide list and randomly choose index for resize _lowercase =np.random.randint(self.short_edge_length[0] , self.short_edge_length[1] + 1 ) if size == 0: return img _lowercase =size * 1.0 / min(UpperCAmelCase , UpperCAmelCase ) if h < w: _lowercase , _lowercase =size, scale * w else: _lowercase , _lowercase =scale * h, size if max(UpperCAmelCase , UpperCAmelCase ) > self.max_size: _lowercase =self.max_size * 1.0 / max(UpperCAmelCase , UpperCAmelCase ) _lowercase =newh * scale _lowercase =neww * scale _lowercase =int(neww + 0.5 ) _lowercase =int(newh + 0.5 ) if img.dtype == np.uinta: _lowercase =Image.fromarray(UpperCAmelCase ) _lowercase =pil_image.resize((neww, newh) , PILImageResampling.BILINEAR ) _lowercase =np.asarray(UpperCAmelCase ) else: _lowercase =img.permute(2 , 0 , 1 ).unsqueeze(0 ) # 3, 0, 1) # hw(c) -> nchw _lowercase =nn.functional.interpolate( UpperCAmelCase , (newh, neww) , mode=self.interp_method , align_corners=UpperCAmelCase ).squeeze(0 ) img_augs.append(UpperCAmelCase ) return img_augs class lowerCamelCase__ : def __init__(self , UpperCAmelCase ) -> Tuple: _lowercase =ResizeShortestEdge([cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST] , cfg.INPUT.MAX_SIZE_TEST ) _lowercase =cfg.INPUT.FORMAT _lowercase =cfg.SIZE_DIVISIBILITY _lowercase =cfg.PAD_VALUE _lowercase =cfg.INPUT.MAX_SIZE_TEST _lowercase =cfg.MODEL.DEVICE _lowercase =torch.tensor(cfg.MODEL.PIXEL_STD ).to(self.device ).view(len(cfg.MODEL.PIXEL_STD ) , 1 , 1 ) _lowercase =torch.tensor(cfg.MODEL.PIXEL_MEAN ).to(self.device ).view(len(cfg.MODEL.PIXEL_STD ) , 1 , 1 ) _lowercase =lambda UpperCAmelCase : (x - self.pixel_mean) / self.pixel_std def __A (self , UpperCAmelCase ) -> List[str]: _lowercase =tuple(max(UpperCAmelCase ) for s in zip(*[img.shape for img in images] ) ) _lowercase =[im.shape[-2:] for im in images] _lowercase =[ nn.functional.pad( UpperCAmelCase , [0, max_size[-1] - size[1], 0, max_size[-2] - size[0]] , value=self.pad_value , ) for size, im in zip(UpperCAmelCase , UpperCAmelCase ) ] return torch.stack(UpperCAmelCase ), torch.tensor(UpperCAmelCase ) def __call__(self , UpperCAmelCase , UpperCAmelCase=False ) -> str: with torch.no_grad(): if not isinstance(UpperCAmelCase , UpperCAmelCase ): _lowercase =[images] if single_image: assert len(UpperCAmelCase ) == 1 for i in range(len(UpperCAmelCase ) ): if isinstance(images[i] , torch.Tensor ): images.insert(UpperCAmelCase , images.pop(UpperCAmelCase ).to(self.device ).float() ) elif not isinstance(images[i] , torch.Tensor ): images.insert( UpperCAmelCase , torch.as_tensor(img_tensorize(images.pop(UpperCAmelCase ) , input_format=self.input_format ) ) .to(self.device ) .float() , ) # resize smallest edge _lowercase =torch.tensor([im.shape[:2] for im in images] ) _lowercase =self.aug(UpperCAmelCase ) # transpose images and convert to torch tensors # images = [torch.as_tensor(i.astype("float32")).permute(2, 0, 1).to(self.device) for i in images] # now normalize before pad to avoid useless arithmetic _lowercase =[self.normalizer(UpperCAmelCase ) for x in images] # now pad them to do the following operations _lowercase , _lowercase =self.pad(UpperCAmelCase ) # Normalize if self.size_divisibility > 0: raise NotImplementedError() # pad _lowercase =torch.true_divide(UpperCAmelCase , UpperCAmelCase ) if single_image: return images[0], sizes[0], scales_yx[0] else: return images, sizes, scales_yx def UpperCAmelCase_ ( __snake_case , __snake_case ) -> Tuple: """simple docstring""" boxes[:, 0::2] *= scale_yx[:, 1] boxes[:, 1::2] *= scale_yx[:, 0] return boxes def UpperCAmelCase_ ( __snake_case , __snake_case ) -> Optional[int]: """simple docstring""" assert torch.isfinite(__snake_case ).all(), "Box tensor contains infinite or NaN!" _lowercase , _lowercase =box_size tensor[:, 0].clamp_(min=0 , max=__snake_case ) tensor[:, 1].clamp_(min=0 , max=__snake_case ) tensor[:, 2].clamp_(min=0 , max=__snake_case ) tensor[:, 3].clamp_(min=0 , max=__snake_case )
5
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
0
from __future__ import annotations import unittest import numpy as np from transformers import BlipTextConfig from transformers.testing_utils import require_tf, slow from transformers.utils import is_tf_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask if is_tf_available(): import tensorflow as tf from transformers import TFBlipTextModel from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST class __A: def __init__( self , _snake_case , _snake_case=12 , _snake_case=7 , _snake_case=True , _snake_case=True , _snake_case=True , _snake_case=99 , _snake_case=32 , _snake_case=32 , _snake_case=2 , _snake_case=4 , _snake_case=37 , _snake_case=0.1 , _snake_case=0.1 , _snake_case=512 , _snake_case=0.02 , _snake_case=0 , _snake_case=None , ) -> Dict: '''simple docstring''' __a = parent __a = batch_size __a = seq_length __a = is_training __a = use_input_mask __a = use_labels __a = vocab_size __a = hidden_size __a = projection_dim __a = num_hidden_layers __a = num_attention_heads __a = intermediate_size __a = dropout __a = attention_dropout __a = max_position_embeddings __a = initializer_range __a = scope __a = bos_token_id def SCREAMING_SNAKE_CASE_ ( self ) -> Union[str, Any]: '''simple docstring''' __a = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __a = None if self.use_input_mask: __a = random_attention_mask([self.batch_size, self.seq_length] ) if input_mask is not None: __a = input_mask.numpy() __a , __a = input_mask.shape __a = np.random.randint(1 , seq_length - 1 , size=(batch_size,) ) for batch_idx, start_index in enumerate(_snake_case ): __a = 1 __a = 0 __a = self.get_config() return config, input_ids, tf.convert_to_tensor(_snake_case ) def SCREAMING_SNAKE_CASE_ ( self ) -> Any: '''simple docstring''' return BlipTextConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , projection_dim=self.projection_dim , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , dropout=self.dropout , attention_dropout=self.attention_dropout , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , bos_token_id=self.bos_token_id , ) def SCREAMING_SNAKE_CASE_ ( self , _snake_case , _snake_case , _snake_case ) -> Optional[Any]: '''simple docstring''' __a = TFBlipTextModel(config=_snake_case ) __a = model(_snake_case , attention_mask=_snake_case , training=_snake_case ) __a = model(_snake_case , training=_snake_case ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def SCREAMING_SNAKE_CASE_ ( self ) -> Dict: '''simple docstring''' __a = self.prepare_config_and_inputs() __a , __a , __a = config_and_inputs __a = {'''input_ids''': input_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_tf class __A( a , unittest.TestCase ): snake_case_ = (TFBlipTextModel,) if is_tf_available() else () snake_case_ = False snake_case_ = False snake_case_ = False def SCREAMING_SNAKE_CASE_ ( self ) -> Optional[int]: '''simple docstring''' __a = BlipTextModelTester(self ) __a = ConfigTester(self , config_class=_snake_case , hidden_size=37 ) def SCREAMING_SNAKE_CASE_ ( self ) -> Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_ ( self ) -> Tuple: '''simple docstring''' __a = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_snake_case ) def SCREAMING_SNAKE_CASE_ ( self ) -> str: '''simple docstring''' pass def SCREAMING_SNAKE_CASE_ ( self ) -> Optional[Any]: '''simple docstring''' pass @unittest.skip(reason='''Blip does not use inputs_embeds''' ) def SCREAMING_SNAKE_CASE_ ( self ) -> Dict: '''simple docstring''' pass @unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING''' ) def SCREAMING_SNAKE_CASE_ ( self ) -> List[Any]: '''simple docstring''' pass @unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING''' ) def SCREAMING_SNAKE_CASE_ ( self ) -> Dict: '''simple docstring''' pass @slow def SCREAMING_SNAKE_CASE_ ( self ) -> str: '''simple docstring''' for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __a = TFBlipTextModel.from_pretrained(_snake_case ) self.assertIsNotNone(_snake_case ) def SCREAMING_SNAKE_CASE_ ( self , _snake_case=True ) -> Optional[Any]: '''simple docstring''' super().test_pt_tf_model_equivalence(allow_missing_keys=_snake_case )
6
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
0
import numpy as np from cva import COLOR_BGR2GRAY, CV_8UC3, cvtColor, filteraD, imread, imshow, waitKey def _snake_case( SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : int ) -> np.ndarray: '''simple docstring''' if (ksize % 2) == 0: A__ = ksize + 1 A__ = np.zeros((ksize, ksize) , dtype=np.floataa ) # each value for y in range(SCREAMING_SNAKE_CASE__ ): for x in range(SCREAMING_SNAKE_CASE__ ): # distance from center A__ = x - ksize // 2 A__ = y - ksize // 2 # degree to radiant A__ = theta / 180 * np.pi A__ = np.cos(_theta ) A__ = np.sin(_theta ) # get kernel x A__ = cos_theta * px + sin_theta * py # get kernel y A__ = -sin_theta * px + cos_theta * py # fill kernel A__ = np.exp( -(_x**2 + gamma**2 * _y**2) / (2 * sigma**2) ) * np.cos(2 * np.pi * _x / lambd + psi ) return gabor if __name__ == "__main__": import doctest doctest.testmod() # read original image lowercase_ = imread("../image_data/lena.jpg") # turn image in gray scale value lowercase_ = cvtColor(img, COLOR_BGR2GRAY) # Apply multiple Kernel to detect edges lowercase_ = np.zeros(gray.shape[:2]) for theta in [0, 30, 60, 90, 120, 150]: lowercase_ = gabor_filter_kernel(10, 8, theta, 10, 0, 0) out += filteraD(gray, CV_8UC3, kernel_aa) lowercase_ = out / out.max() * 255 lowercase_ = out.astype(np.uinta) imshow("Original", gray) imshow("Gabor filter with 20x20 mask and 6 directions", out) waitKey(0)
7
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
0
def __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): return int((input_a, input_a).count(0 ) == 0 ) def __SCREAMING_SNAKE_CASE (): assert and_gate(0 , 0 ) == 0 assert and_gate(0 , 1 ) == 0 assert and_gate(1 , 0 ) == 0 assert and_gate(1 , 1 ) == 1 if __name__ == "__main__": test_and_gate() print(and_gate(1, 0)) print(and_gate(0, 0)) print(and_gate(0, 1)) print(and_gate(1, 1))
8
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.') if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
import numpy as np def _UpperCamelCase ( lowercase__ , lowercase__ , lowercase__ = 1e-12 , lowercase__ = 100 , ): assert np.shape(lowercase__ )[0] == np.shape(lowercase__ )[1] # Ensure proper dimensionality. assert np.shape(lowercase__ )[0] == np.shape(lowercase__ )[0] # Ensure inputs are either both complex or both real assert np.iscomplexobj(lowercase__ ) == np.iscomplexobj(lowercase__ ) __SCREAMING_SNAKE_CASE : Optional[int] = np.iscomplexobj(lowercase__ ) if is_complex: # Ensure complex input_matrix is Hermitian assert np.array_equal(lowercase__ , input_matrix.conj().T ) # Set convergence to False. Will define convergence when we exceed max_iterations # or when we have small changes from one iteration to next. __SCREAMING_SNAKE_CASE : Dict = False __SCREAMING_SNAKE_CASE : Optional[int] = 0 __SCREAMING_SNAKE_CASE : Any = 0 __SCREAMING_SNAKE_CASE : Dict = 1e12 while not convergence: # Multiple matrix by the vector. __SCREAMING_SNAKE_CASE : Optional[int] = np.dot(lowercase__ , lowercase__ ) # Normalize the resulting output vector. __SCREAMING_SNAKE_CASE : int = w / np.linalg.norm(lowercase__ ) # Find rayleigh quotient # (faster than usual b/c we know vector is normalized already) __SCREAMING_SNAKE_CASE : str = vector.conj().T if is_complex else vector.T __SCREAMING_SNAKE_CASE : Optional[Any] = np.dot(lowercase__ , np.dot(lowercase__ , lowercase__ ) ) # Check convergence. __SCREAMING_SNAKE_CASE : int = np.abs(lambda_ - lambda_previous ) / lambda_ iterations += 1 if error <= error_tol or iterations >= max_iterations: __SCREAMING_SNAKE_CASE : Optional[Any] = True __SCREAMING_SNAKE_CASE : Tuple = lambda_ if is_complex: __SCREAMING_SNAKE_CASE : Tuple = np.real(lambda_ ) return lambda_, vector def _UpperCamelCase ( ): __SCREAMING_SNAKE_CASE : Union[str, Any] = np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]] ) __SCREAMING_SNAKE_CASE : Tuple = np.array([41, 4, 20] ) __SCREAMING_SNAKE_CASE : Tuple = real_input_matrix.astype(np.complexaaa ) __SCREAMING_SNAKE_CASE : str = np.triu(1J * complex_input_matrix , 1 ) complex_input_matrix += imag_matrix complex_input_matrix += -1 * imag_matrix.T __SCREAMING_SNAKE_CASE : Union[str, Any] = np.array([41, 4, 20] ).astype(np.complexaaa ) for problem_type in ["real", "complex"]: if problem_type == "real": __SCREAMING_SNAKE_CASE : Any = real_input_matrix __SCREAMING_SNAKE_CASE : Optional[Any] = real_vector elif problem_type == "complex": __SCREAMING_SNAKE_CASE : List[str] = complex_input_matrix __SCREAMING_SNAKE_CASE : str = complex_vector # Our implementation. __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE : int = power_iteration(lowercase__ , lowercase__ ) # Numpy implementation. # Get eigenvalues and eigenvectors using built-in numpy # eigh (eigh used for symmetric or hermetian matrices). __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE : Optional[int] = np.linalg.eigh(lowercase__ ) # Last eigenvalue is the maximum one. __SCREAMING_SNAKE_CASE : List[str] = eigen_values[-1] # Last column in this matrix is eigenvector corresponding to largest eigenvalue. __SCREAMING_SNAKE_CASE : Optional[int] = eigen_vectors[:, -1] # Check our implementation and numpy gives close answers. assert np.abs(eigen_value - eigen_value_max ) <= 1e-6 # Take absolute values element wise of each eigenvector. # as they are only unique to a minus sign. assert np.linalg.norm(np.abs(lowercase__ ) - np.abs(lowercase__ ) ) <= 1e-6 if __name__ == "__main__": import doctest doctest.testmod() test_power_iteration()
9
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
from pathlib import Path from typing import List from transformers import is_torch_available, is_vision_available from transformers.testing_utils import get_tests_dir, is_tool_test from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText if is_torch_available(): import torch if is_vision_available(): from PIL import Image __A = ["text", "image", "audio"] def lowerCAmelCase_ ( __a ) -> List[Any]: """simple docstring""" lowerCamelCase__: Dict =[] for input_type in input_types: if input_type == "text": inputs.append("Text input" ) elif input_type == "image": inputs.append( Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO" ) ) / "000000039769.png" ).resize((512, 512) ) ) elif input_type == "audio": inputs.append(torch.ones(3000 ) ) elif isinstance(__a , __a ): inputs.append(create_inputs(__a ) ) else: raise ValueError(F"""Invalid type requested: {input_type}""" ) return inputs def lowerCAmelCase_ ( __a ) -> Tuple: """simple docstring""" lowerCamelCase__: Any =[] for output in outputs: if isinstance(__a , (str, AgentText) ): output_types.append("text" ) elif isinstance(__a , (Image.Image, AgentImage) ): output_types.append("image" ) elif isinstance(__a , (torch.Tensor, AgentAudio) ): output_types.append("audio" ) else: raise ValueError(F"""Invalid output: {output}""" ) return output_types @is_tool_test class _SCREAMING_SNAKE_CASE : '''simple docstring''' def SCREAMING_SNAKE_CASE_ (self : Tuple) ->List[Any]: '''simple docstring''' self.assertTrue(hasattr(self.tool , "inputs")) self.assertTrue(hasattr(self.tool , "outputs")) lowerCamelCase__: List[Any] =self.tool.inputs for _input in inputs: if isinstance(_input , UpperCAmelCase_): for __input in _input: self.assertTrue(__input in authorized_types) else: self.assertTrue(_input in authorized_types) lowerCamelCase__: List[str] =self.tool.outputs for _output in outputs: self.assertTrue(_output in authorized_types) def SCREAMING_SNAKE_CASE_ (self : str) ->Optional[int]: '''simple docstring''' lowerCamelCase__: Optional[int] =create_inputs(self.tool.inputs) lowerCamelCase__: Tuple =self.tool(*UpperCAmelCase_) # There is a single output if len(self.tool.outputs) == 1: lowerCamelCase__: Tuple =[outputs] self.assertListEqual(output_types(UpperCAmelCase_) , self.tool.outputs) def SCREAMING_SNAKE_CASE_ (self : str) ->Dict: '''simple docstring''' self.assertTrue(hasattr(self.tool , "description")) self.assertTrue(hasattr(self.tool , "default_checkpoint")) self.assertTrue(self.tool.description.startswith("This is a tool that")) def SCREAMING_SNAKE_CASE_ (self : Any) ->Union[str, Any]: '''simple docstring''' lowerCamelCase__: Optional[int] =create_inputs(self.tool.inputs) lowerCamelCase__: Tuple =self.tool(*UpperCAmelCase_) if not isinstance(UpperCAmelCase_ , UpperCAmelCase_): lowerCamelCase__: Optional[int] =[outputs] self.assertEqual(len(UpperCAmelCase_) , len(self.tool.outputs)) for output, output_type in zip(UpperCAmelCase_ , self.tool.outputs): lowerCamelCase__: Optional[Any] =AGENT_TYPE_MAPPING[output_type] self.assertTrue(isinstance(UpperCAmelCase_ , UpperCAmelCase_)) def SCREAMING_SNAKE_CASE_ (self : Any) ->Dict: '''simple docstring''' lowerCamelCase__: List[Any] =create_inputs(self.tool.inputs) lowerCamelCase__: Union[str, Any] =[] for _input, input_type in zip(UpperCAmelCase_ , self.tool.inputs): if isinstance(UpperCAmelCase_ , UpperCAmelCase_): _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input) for _input_type in input_type]) else: _inputs.append(AGENT_TYPE_MAPPING[input_type](_input)) # Should not raise an error lowerCamelCase__: Optional[int] =self.tool(*UpperCAmelCase_) if not isinstance(UpperCAmelCase_ , UpperCAmelCase_): lowerCamelCase__: int =[outputs] self.assertEqual(len(UpperCAmelCase_) , len(self.tool.outputs))
10
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
import torch from diffusers import UnCLIPScheduler from .test_schedulers import SchedulerCommonTest class lowerCAmelCase__ ( a): '''simple docstring''' __SCREAMING_SNAKE_CASE = (UnCLIPScheduler,) def _lowerCamelCase ( self , **__lowerCamelCase) -> Any: _A : Dict = { "num_train_timesteps": 1_0_0_0, "variance_type": "fixed_small_log", "clip_sample": True, "clip_sample_range": 1.0, "prediction_type": "epsilon", } config.update(**__lowerCamelCase) return config def _lowerCamelCase ( self) -> Dict: for timesteps in [1, 5, 1_0_0, 1_0_0_0]: self.check_over_configs(num_train_timesteps=__lowerCamelCase) def _lowerCamelCase ( self) -> str: for variance in ["fixed_small_log", "learned_range"]: self.check_over_configs(variance_type=__lowerCamelCase) def _lowerCamelCase ( self) -> Any: for clip_sample in [True, False]: self.check_over_configs(clip_sample=__lowerCamelCase) def _lowerCamelCase ( self) -> int: for clip_sample_range in [1, 5, 1_0, 2_0]: self.check_over_configs(clip_sample_range=__lowerCamelCase) def _lowerCamelCase ( self) -> List[Any]: for prediction_type in ["epsilon", "sample"]: self.check_over_configs(prediction_type=__lowerCamelCase) def _lowerCamelCase ( self) -> Dict: for time_step in [0, 5_0_0, 9_9_9]: for prev_timestep in [None, 5, 1_0_0, 2_5_0, 5_0_0, 7_5_0]: if prev_timestep is not None and prev_timestep >= time_step: continue self.check_over_forward(time_step=__lowerCamelCase , prev_timestep=__lowerCamelCase) def _lowerCamelCase ( self) -> Optional[int]: _A : List[Any] = self.scheduler_classes[0] _A : Dict = self.get_scheduler_config(variance_type="fixed_small_log") _A : Optional[Any] = scheduler_class(**__lowerCamelCase) assert torch.sum(torch.abs(scheduler._get_variance(0) - 1.00_00e-10)) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(4_8_7) - 0.0_5_4_9_6_2_5)) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(9_9_9) - 0.9_9_9_4_9_8_7)) < 1e-5 def _lowerCamelCase ( self) -> str: _A : List[Any] = self.scheduler_classes[0] _A : Union[str, Any] = self.get_scheduler_config(variance_type="learned_range") _A : List[str] = scheduler_class(**__lowerCamelCase) _A : Any = 0.5 assert scheduler._get_variance(1 , predicted_variance=__lowerCamelCase) - -1_0.1_7_1_2_7_9_0 < 1e-5 assert scheduler._get_variance(4_8_7 , predicted_variance=__lowerCamelCase) - -5.7_9_9_8_0_5_2 < 1e-5 assert scheduler._get_variance(9_9_9 , predicted_variance=__lowerCamelCase) - -0.0_0_1_0_0_1_1 < 1e-5 def _lowerCamelCase ( self) -> Optional[int]: _A : List[str] = self.scheduler_classes[0] _A : Dict = self.get_scheduler_config() _A : List[str] = scheduler_class(**__lowerCamelCase) _A : Optional[int] = scheduler.timesteps _A : Union[str, Any] = self.dummy_model() _A : List[Any] = self.dummy_sample_deter _A : Any = torch.manual_seed(0) for i, t in enumerate(__lowerCamelCase): # 1. predict noise residual _A : Optional[Any] = model(__lowerCamelCase , __lowerCamelCase) # 2. predict previous mean of sample x_t-1 _A : Optional[int] = scheduler.step(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , generator=__lowerCamelCase).prev_sample _A : List[Any] = pred_prev_sample _A : str = torch.sum(torch.abs(__lowerCamelCase)) _A : Optional[Any] = torch.mean(torch.abs(__lowerCamelCase)) assert abs(result_sum.item() - 2_5_2.2_6_8_2_4_9_5) < 1e-2 assert abs(result_mean.item() - 0.3_2_8_4_7_4_3) < 1e-3 def _lowerCamelCase ( self) -> Any: _A : Optional[Any] = self.scheduler_classes[0] _A : Union[str, Any] = self.get_scheduler_config() _A : Dict = scheduler_class(**__lowerCamelCase) scheduler.set_timesteps(2_5) _A : Dict = scheduler.timesteps _A : List[Any] = self.dummy_model() _A : Optional[int] = self.dummy_sample_deter _A : str = torch.manual_seed(0) for i, t in enumerate(__lowerCamelCase): # 1. predict noise residual _A : Optional[int] = model(__lowerCamelCase , __lowerCamelCase) if i + 1 == timesteps.shape[0]: _A : List[str] = None else: _A : int = timesteps[i + 1] # 2. predict previous mean of sample x_t-1 _A : Any = scheduler.step( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , prev_timestep=__lowerCamelCase , generator=__lowerCamelCase).prev_sample _A : Dict = pred_prev_sample _A : Dict = torch.sum(torch.abs(__lowerCamelCase)) _A : Any = torch.mean(torch.abs(__lowerCamelCase)) assert abs(result_sum.item() - 2_5_8.2_0_4_4_9_8_3) < 1e-2 assert abs(result_mean.item() - 0.3_3_6_2_0_3_8) < 1e-3 def _lowerCamelCase ( self) -> str: pass def _lowerCamelCase ( self) -> int: pass
11
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
import argparse import torch from transformers import ( WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaForAudioFrameClassification, WavaVecaForSequenceClassification, WavaVecaForXVector, logging, ) logging.set_verbosity_info() UpperCAmelCase_ = logging.get_logger(__name__) def lowerCamelCase__ ( A__ : Tuple , A__ : int , A__ : Any ): '''simple docstring''' __lowerCamelCase = WavaVecaForSequenceClassification.from_pretrained(A__ , config=A__ ) __lowerCamelCase = downstream_dict["""projector.weight"""] __lowerCamelCase = downstream_dict["""projector.bias"""] __lowerCamelCase = downstream_dict["""model.post_net.linear.weight"""] __lowerCamelCase = downstream_dict["""model.post_net.linear.bias"""] return model def lowerCamelCase__ ( A__ : Optional[Any] , A__ : Optional[Any] , A__ : Union[str, Any] ): '''simple docstring''' __lowerCamelCase = WavaVecaForAudioFrameClassification.from_pretrained(A__ , config=A__ ) __lowerCamelCase = downstream_dict["""model.linear.weight"""] __lowerCamelCase = downstream_dict["""model.linear.bias"""] return model def lowerCamelCase__ ( A__ : Optional[int] , A__ : Tuple , A__ : Dict ): '''simple docstring''' __lowerCamelCase = WavaVecaForXVector.from_pretrained(A__ , config=A__ ) __lowerCamelCase = downstream_dict["""connector.weight"""] __lowerCamelCase = downstream_dict["""connector.bias"""] for i, kernel_size in enumerate(hf_config.tdnn_kernel ): __lowerCamelCase = downstream_dict[ f'model.framelevel_feature_extractor.module.{i}.kernel.weight' ] __lowerCamelCase = downstream_dict[f'model.framelevel_feature_extractor.module.{i}.kernel.bias'] __lowerCamelCase = downstream_dict["""model.utterancelevel_feature_extractor.linear1.weight"""] __lowerCamelCase = downstream_dict["""model.utterancelevel_feature_extractor.linear1.bias"""] __lowerCamelCase = downstream_dict["""model.utterancelevel_feature_extractor.linear2.weight"""] __lowerCamelCase = downstream_dict["""model.utterancelevel_feature_extractor.linear2.bias"""] __lowerCamelCase = downstream_dict["""objective.W"""] return model @torch.no_grad() def lowerCamelCase__ ( A__ : List[str] , A__ : Dict , A__ : List[str] , A__ : Tuple ): '''simple docstring''' __lowerCamelCase = torch.load(A__ , map_location="""cpu""" ) __lowerCamelCase = checkpoint["""Downstream"""] __lowerCamelCase = WavaVecaConfig.from_pretrained(A__ ) __lowerCamelCase = WavaVecaFeatureExtractor.from_pretrained( A__ , return_attention_mask=A__ , do_normalize=A__ ) __lowerCamelCase = hf_config.architectures[0] if arch.endswith("""ForSequenceClassification""" ): __lowerCamelCase = convert_classification(A__ , A__ , A__ ) elif arch.endswith("""ForAudioFrameClassification""" ): __lowerCamelCase = convert_diarization(A__ , A__ , A__ ) elif arch.endswith("""ForXVector""" ): __lowerCamelCase = convert_xvector(A__ , A__ , A__ ) else: raise NotImplementedError(f'S3PRL weights conversion is not supported for {arch}' ) if hf_config.use_weighted_layer_sum: __lowerCamelCase = checkpoint["""Featurizer"""]["""weights"""] hf_feature_extractor.save_pretrained(A__ ) hf_model.save_pretrained(A__ ) if __name__ == "__main__": UpperCAmelCase_ = argparse.ArgumentParser() parser.add_argument( '--base_model_name', default=None, type=str, help='Name of the huggingface pretrained base model.' ) parser.add_argument('--config_path', default=None, type=str, help='Path to the huggingface classifier config.') parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to the s3prl checkpoint.') parser.add_argument('--model_dump_path', default=None, type=str, help='Path to the final converted model.') UpperCAmelCase_ = parser.parse_args() convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
12
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
import collections import inspect import unittest from typing import Dict, List, Tuple from transformers import MaskFormerSwinConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device from transformers.utils import is_torch_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import MaskFormerSwinBackbone from transformers.models.maskformer import MaskFormerSwinModel class __lowercase : """simple docstring""" def __init__( self : Optional[Any] , lowerCAmelCase__ : Optional[Any] , lowerCAmelCase__ : List[Any]=13 , lowerCAmelCase__ : List[str]=32 , lowerCAmelCase__ : List[str]=2 , lowerCAmelCase__ : Optional[int]=3 , lowerCAmelCase__ : List[Any]=16 , lowerCAmelCase__ : int=[1, 2, 1] , lowerCAmelCase__ : Optional[Any]=[2, 2, 4] , lowerCAmelCase__ : List[Any]=2 , lowerCAmelCase__ : str=2.0 , lowerCAmelCase__ : List[Any]=True , lowerCAmelCase__ : Tuple=0.0 , lowerCAmelCase__ : Tuple=0.0 , lowerCAmelCase__ : Dict=0.1 , lowerCAmelCase__ : Union[str, Any]="gelu" , lowerCAmelCase__ : Union[str, Any]=False , lowerCAmelCase__ : Tuple=True , lowerCAmelCase__ : List[str]=0.02 , lowerCAmelCase__ : List[str]=1E-5 , lowerCAmelCase__ : int=True , lowerCAmelCase__ : List[Any]=None , lowerCAmelCase__ : str=True , lowerCAmelCase__ : Tuple=10 , lowerCAmelCase__ : Any=8 , lowerCAmelCase__ : List[str]=["stage1", "stage2", "stage3"] , lowerCAmelCase__ : Optional[int]=[1, 2, 3] , ): SCREAMING_SNAKE_CASE_: Optional[int] = parent SCREAMING_SNAKE_CASE_: Optional[int] = batch_size SCREAMING_SNAKE_CASE_: List[str] = image_size SCREAMING_SNAKE_CASE_: int = patch_size SCREAMING_SNAKE_CASE_: Optional[int] = num_channels SCREAMING_SNAKE_CASE_: Optional[Any] = embed_dim SCREAMING_SNAKE_CASE_: List[str] = depths SCREAMING_SNAKE_CASE_: Any = num_heads SCREAMING_SNAKE_CASE_: Any = window_size SCREAMING_SNAKE_CASE_: str = mlp_ratio SCREAMING_SNAKE_CASE_: Optional[Any] = qkv_bias SCREAMING_SNAKE_CASE_: Any = hidden_dropout_prob SCREAMING_SNAKE_CASE_: Any = attention_probs_dropout_prob SCREAMING_SNAKE_CASE_: Optional[int] = drop_path_rate SCREAMING_SNAKE_CASE_: Union[str, Any] = hidden_act SCREAMING_SNAKE_CASE_: int = use_absolute_embeddings SCREAMING_SNAKE_CASE_: Tuple = patch_norm SCREAMING_SNAKE_CASE_: Union[str, Any] = layer_norm_eps SCREAMING_SNAKE_CASE_: Union[str, Any] = initializer_range SCREAMING_SNAKE_CASE_: Optional[Any] = is_training SCREAMING_SNAKE_CASE_: List[str] = scope SCREAMING_SNAKE_CASE_: List[Any] = use_labels SCREAMING_SNAKE_CASE_: Any = type_sequence_label_size SCREAMING_SNAKE_CASE_: int = encoder_stride SCREAMING_SNAKE_CASE_: List[str] = out_features SCREAMING_SNAKE_CASE_: Optional[Any] = out_indices def _SCREAMING_SNAKE_CASE ( self : int): SCREAMING_SNAKE_CASE_: Union[str, Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) SCREAMING_SNAKE_CASE_: List[str] = None if self.use_labels: SCREAMING_SNAKE_CASE_: Tuple = ids_tensor([self.batch_size] , self.type_sequence_label_size) SCREAMING_SNAKE_CASE_: Optional[int] = self.get_config() return config, pixel_values, labels def _SCREAMING_SNAKE_CASE ( self : List[Any]): return MaskFormerSwinConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , embed_dim=self.embed_dim , depths=self.depths , num_heads=self.num_heads , window_size=self.window_size , mlp_ratio=self.mlp_ratio , qkv_bias=self.qkv_bias , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , drop_path_rate=self.drop_path_rate , hidden_act=self.hidden_act , use_absolute_embeddings=self.use_absolute_embeddings , path_norm=self.patch_norm , layer_norm_eps=self.layer_norm_eps , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , out_features=self.out_features , out_indices=self.out_indices , ) def _SCREAMING_SNAKE_CASE ( self : Any , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : List[Any] , lowerCAmelCase__ : str): SCREAMING_SNAKE_CASE_: Optional[int] = MaskFormerSwinModel(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() SCREAMING_SNAKE_CASE_: Tuple = model(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1)) SCREAMING_SNAKE_CASE_: Dict = int(config.embed_dim * 2 ** (len(config.depths) - 1)) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, expected_seq_len, expected_dim)) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] , lowerCAmelCase__ : Any , lowerCAmelCase__ : Tuple , lowerCAmelCase__ : str): SCREAMING_SNAKE_CASE_: List[Any] = MaskFormerSwinBackbone(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() SCREAMING_SNAKE_CASE_: List[Any] = model(lowerCAmelCase__) # verify feature maps self.parent.assertEqual(len(result.feature_maps) , len(config.out_features)) self.parent.assertListEqual(list(result.feature_maps[0].shape) , [13, 16, 16, 16]) # verify channels self.parent.assertEqual(len(model.channels) , len(config.out_features)) self.parent.assertListEqual(model.channels , [16, 32, 64]) # verify ValueError with self.parent.assertRaises(lowerCAmelCase__): SCREAMING_SNAKE_CASE_: Optional[Any] = ["stem"] SCREAMING_SNAKE_CASE_: Dict = MaskFormerSwinBackbone(config=lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : List[str]): SCREAMING_SNAKE_CASE_: Tuple = self.prepare_config_and_inputs() SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Optional[int] = config_and_inputs SCREAMING_SNAKE_CASE_: int = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class __lowercase ( UpperCAmelCase_ , UpperCAmelCase_ , unittest.TestCase ): """simple docstring""" _UpperCAmelCase : Optional[int] = ( ( MaskFormerSwinModel, MaskFormerSwinBackbone, ) if is_torch_available() else () ) _UpperCAmelCase : List[Any] = {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {} _UpperCAmelCase : str = False _UpperCAmelCase : Optional[Any] = False _UpperCAmelCase : Union[str, Any] = False _UpperCAmelCase : Optional[Any] = False _UpperCAmelCase : Optional[int] = False def _SCREAMING_SNAKE_CASE ( self : List[Any]): SCREAMING_SNAKE_CASE_: Dict = MaskFormerSwinModelTester(self) SCREAMING_SNAKE_CASE_: Tuple = ConfigTester(self , config_class=lowerCAmelCase__ , embed_dim=37) @require_torch_multi_gpu @unittest.skip( reason=( "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with" " `nn.DataParallel`" )) def _SCREAMING_SNAKE_CASE ( self : List[str]): pass def _SCREAMING_SNAKE_CASE ( 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 _SCREAMING_SNAKE_CASE ( self : Optional[Any]): return def _SCREAMING_SNAKE_CASE ( self : Dict): SCREAMING_SNAKE_CASE_: List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : List[Any]): SCREAMING_SNAKE_CASE_: List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*lowerCAmelCase__) @unittest.skip("Swin does not use inputs_embeds") def _SCREAMING_SNAKE_CASE ( self : Optional[int]): pass @unittest.skip("Swin does not support feedforward chunking") def _SCREAMING_SNAKE_CASE ( self : List[str]): pass def _SCREAMING_SNAKE_CASE ( self : Dict): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: List[Any] = model_class(lowerCAmelCase__) self.assertIsInstance(model.get_input_embeddings() , (nn.Module)) SCREAMING_SNAKE_CASE_: Union[str, Any] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(lowerCAmelCase__ , nn.Linear)) def _SCREAMING_SNAKE_CASE ( self : int): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: Tuple = model_class(lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Dict = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic SCREAMING_SNAKE_CASE_: List[Any] = [*signature.parameters.keys()] SCREAMING_SNAKE_CASE_: Dict = ["pixel_values"] self.assertListEqual(arg_names[:1] , lowerCAmelCase__) @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions") def _SCREAMING_SNAKE_CASE ( self : List[Any]): pass @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone") def _SCREAMING_SNAKE_CASE ( self : Tuple): pass def _SCREAMING_SNAKE_CASE ( self : Optional[Any] , lowerCAmelCase__ : List[Any] , lowerCAmelCase__ : Any , lowerCAmelCase__ : Optional[Any] , lowerCAmelCase__ : Optional[Any]): SCREAMING_SNAKE_CASE_: List[str] = model_class(lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() with torch.no_grad(): SCREAMING_SNAKE_CASE_: List[Any] = model(**self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__)) SCREAMING_SNAKE_CASE_: List[Any] = outputs.hidden_states SCREAMING_SNAKE_CASE_: int = getattr( self.model_tester , "expected_num_hidden_layers" , len(self.model_tester.depths) + 1) self.assertEqual(len(lowerCAmelCase__) , lowerCAmelCase__) # Swin has a different seq_length SCREAMING_SNAKE_CASE_: Dict = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable) else (config.patch_size, config.patch_size) ) SCREAMING_SNAKE_CASE_: str = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) self.assertListEqual( list(hidden_states[0].shape[-2:]) , [num_patches, self.model_tester.embed_dim] , ) def _SCREAMING_SNAKE_CASE ( self : str): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: List[Any] = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_: List[Any] = ( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable) else (self.model_tester.image_size, self.model_tester.image_size) ) for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: Optional[Any] = True self.check_hidden_states_output(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] SCREAMING_SNAKE_CASE_: Optional[Any] = True self.check_hidden_states_output(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__) def _SCREAMING_SNAKE_CASE ( self : int): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_: int = 3 SCREAMING_SNAKE_CASE_: Tuple = ( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable) else (self.model_tester.image_size, self.model_tester.image_size) ) SCREAMING_SNAKE_CASE_: Tuple = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable) else (config.patch_size, config.patch_size) ) SCREAMING_SNAKE_CASE_: Dict = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0]) SCREAMING_SNAKE_CASE_: Union[str, Any] = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1]) for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: Optional[Any] = True self.check_hidden_states_output(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , (padded_height, padded_width)) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] SCREAMING_SNAKE_CASE_: Optional[Any] = True self.check_hidden_states_output(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , (padded_height, padded_width)) @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints") def _SCREAMING_SNAKE_CASE ( self : Any): pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin") def _SCREAMING_SNAKE_CASE ( self : str): pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin") def _SCREAMING_SNAKE_CASE ( self : Any): pass def _SCREAMING_SNAKE_CASE ( self : List[str]): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() def set_nan_tensor_to_zero(lowerCAmelCase__ : List[str]): SCREAMING_SNAKE_CASE_: Optional[int] = 0 return t def check_equivalence(lowerCAmelCase__ : Union[str, Any] , lowerCAmelCase__ : str , lowerCAmelCase__ : int , lowerCAmelCase__ : Union[str, Any]={}): with torch.no_grad(): SCREAMING_SNAKE_CASE_: Optional[Any] = model(**lowerCAmelCase__ , return_dict=lowerCAmelCase__ , **lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Union[str, Any] = model(**lowerCAmelCase__ , return_dict=lowerCAmelCase__ , **lowerCAmelCase__).to_tuple() def recursive_check(lowerCAmelCase__ : Tuple , lowerCAmelCase__ : Optional[int]): if isinstance(lowerCAmelCase__ , (List, Tuple)): for tuple_iterable_value, dict_iterable_value in zip(lowerCAmelCase__ , lowerCAmelCase__): recursive_check(lowerCAmelCase__ , lowerCAmelCase__) elif isinstance(lowerCAmelCase__ , lowerCAmelCase__): for tuple_iterable_value, dict_iterable_value in zip( tuple_object.values() , dict_object.values()): recursive_check(lowerCAmelCase__ , lowerCAmelCase__) elif tuple_object is None: return else: self.assertTrue( torch.allclose( set_nan_tensor_to_zero(lowerCAmelCase__) , set_nan_tensor_to_zero(lowerCAmelCase__) , atol=1E-5) , msg=( "Tuple and dict output are not equal. Difference:" F" {torch.max(torch.abs(tuple_object - dict_object))}. Tuple has `nan`:" F" {torch.isnan(lowerCAmelCase__).any()} and `inf`: {torch.isinf(lowerCAmelCase__)}. Dict has" F" `nan`: {torch.isnan(lowerCAmelCase__).any()} and `inf`: {torch.isinf(lowerCAmelCase__)}." ) , ) recursive_check(lowerCAmelCase__ , lowerCAmelCase__) for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: Optional[int] = model_class(lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() SCREAMING_SNAKE_CASE_: Optional[int] = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__) SCREAMING_SNAKE_CASE_: str = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__) check_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: str = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__) check_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Optional[Any] = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Dict = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__) check_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , {"output_hidden_states": True}) SCREAMING_SNAKE_CASE_: List[Any] = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__) SCREAMING_SNAKE_CASE_: Any = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__) check_equivalence(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , {"output_hidden_states": True}) @require_torch class __lowercase ( unittest.TestCase , UpperCAmelCase_ ): """simple docstring""" _UpperCAmelCase : Union[str, Any] = (MaskFormerSwinBackbone,) if is_torch_available() else () _UpperCAmelCase : str = MaskFormerSwinConfig def _SCREAMING_SNAKE_CASE ( self : Any): SCREAMING_SNAKE_CASE_: List[Any] = MaskFormerSwinModelTester(self) def _SCREAMING_SNAKE_CASE ( self : Optional[Any]): SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: Tuple = self.model_tester.prepare_config_and_inputs_for_common() SCREAMING_SNAKE_CASE_: Any = inputs_dict["pixel_values"].shape[0] for backbone_class in self.all_model_classes: SCREAMING_SNAKE_CASE_: List[str] = backbone_class(lowerCAmelCase__) backbone.to(lowerCAmelCase__) backbone.eval() SCREAMING_SNAKE_CASE_: Any = backbone(**lowerCAmelCase__) # Test default outputs and verify feature maps self.assertIsInstance(outputs.feature_maps , lowerCAmelCase__) self.assertTrue(len(outputs.feature_maps) == len(backbone.channels)) for feature_map, n_channels in zip(outputs.feature_maps , backbone.channels): self.assertTrue(feature_map.shape[:2] , (batch_size, n_channels)) self.assertIsNone(outputs.hidden_states) self.assertIsNone(outputs.attentions) # Test output_hidden_states=True SCREAMING_SNAKE_CASE_: str = backbone(**lowerCAmelCase__ , output_hidden_states=lowerCAmelCase__) self.assertIsNotNone(outputs.hidden_states) self.assertTrue(len(outputs.hidden_states) , len(backbone.stage_names)) # We skip the stem layer for hidden_states, n_channels in zip(outputs.hidden_states[1:] , backbone.channels): for hidden_state in hidden_states: # Hidden states are in the format (batch_size, (height * width), n_channels) SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_: List[Any] = hidden_state.shape self.assertTrue((h_batch_size, h_n_channels) , (batch_size, n_channels)) # Test output_attentions=True if self.has_attentions: SCREAMING_SNAKE_CASE_: Dict = backbone(**lowerCAmelCase__ , output_attentions=lowerCAmelCase__) self.assertIsNotNone(outputs.attentions)
13
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
from __future__ import annotations from collections import deque from collections.abc import Sequence from dataclasses import dataclass from typing import Any @dataclass class UpperCamelCase_ : '''simple docstring''' UpperCAmelCase__ = 42 UpperCAmelCase__ = None UpperCAmelCase__ = None def SCREAMING_SNAKE_CASE ( ) -> Node | None: """simple docstring""" A__ = Node(1 ) A__ = Node(2 ) A__ = Node(3 ) A__ = Node(4 ) A__ = Node(5 ) return tree def SCREAMING_SNAKE_CASE ( lowercase_ ) -> list[int]: """simple docstring""" return [root.data, *preorder(root.left ), *preorder(root.right )] if root else [] def SCREAMING_SNAKE_CASE ( lowercase_ ) -> list[int]: """simple docstring""" return postorder(root.left ) + postorder(root.right ) + [root.data] if root else [] def SCREAMING_SNAKE_CASE ( lowercase_ ) -> list[int]: """simple docstring""" return [*inorder(root.left ), root.data, *inorder(root.right )] if root else [] def SCREAMING_SNAKE_CASE ( lowercase_ ) -> int: """simple docstring""" return (max(height(root.left ) , height(root.right ) ) + 1) if root else 0 def SCREAMING_SNAKE_CASE ( lowercase_ ) -> Sequence[Node | None]: """simple docstring""" A__ = [] if root is None: return output A__ = deque([root] ) while process_queue: A__ = process_queue.popleft() output.append(node.data ) if node.left: process_queue.append(node.left ) if node.right: process_queue.append(node.right ) return output def SCREAMING_SNAKE_CASE ( lowercase_ , lowercase_ ) -> Sequence[Node | None]: """simple docstring""" A__ = [] def populate_output(lowercase_ , lowercase_ ) -> None: if not root: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.left , level - 1 ) populate_output(root.right , level - 1 ) populate_output(lowercase_ , lowercase_ ) return output def SCREAMING_SNAKE_CASE ( lowercase_ , lowercase_ ) -> Sequence[Node | None]: """simple docstring""" A__ = [] def populate_output(lowercase_ , lowercase_ ) -> None: if root is None: return if level == 1: output.append(root.data ) elif level > 1: populate_output(root.right , level - 1 ) populate_output(root.left , level - 1 ) populate_output(lowercase_ , lowercase_ ) return output def SCREAMING_SNAKE_CASE ( lowercase_ ) -> Sequence[Node | None] | list[Any]: """simple docstring""" if root is None: return [] A__ = [] A__ = 0 A__ = height(lowercase_ ) for h in range(1 , height_tree + 1 ): if not flag: output.append(get_nodes_from_left_to_right(lowercase_ , lowercase_ ) ) A__ = 1 else: output.append(get_nodes_from_right_to_left(lowercase_ , lowercase_ ) ) A__ = 0 return output def SCREAMING_SNAKE_CASE ( ) -> None: # Main function for testing. """simple docstring""" A__ = make_tree() print(f"""In-order Traversal: {inorder(lowercase_ )}""" ) print(f"""Pre-order Traversal: {preorder(lowercase_ )}""" ) print(f"""Post-order Traversal: {postorder(lowercase_ )}""" , '''\n''' ) print(f"""Height of Tree: {height(lowercase_ )}""" , '''\n''' ) print('''Complete Level Order Traversal: ''' ) print(level_order(lowercase_ ) , '''\n''' ) print('''Level-wise order Traversal: ''' ) for level in range(1 , height(lowercase_ ) + 1 ): print(f"""Level {level}:""" , get_nodes_from_left_to_right(lowercase_ , level=lowercase_ ) ) print('''\nZigZag order Traversal: ''' ) print(zigzag(lowercase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
14
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness SCREAMING_SNAKE_CASE :Dict = '\\n@misc{chen2021evaluating,\n title={Evaluating Large Language Models Trained on Code},\n author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \\nand Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \\nand Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \\nand Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \\nand Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \\nand Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \\nand Mohammad Bavarian and Clemens Winter and Philippe Tillet \\nand Felipe Petroski Such and Dave Cummings and Matthias Plappert \\nand Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \\nand William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \\nand Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \\nand William Saunders and Christopher Hesse and Andrew N. Carr \\nand Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \\nand Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \\nand Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \\nand Sam McCandlish and Ilya Sutskever and Wojciech Zaremba},\n year={2021},\n eprint={2107.03374},\n archivePrefix={arXiv},\n primaryClass={cs.LG}\n}\n' SCREAMING_SNAKE_CASE :List[Any] = '\\nThis metric implements the evaluation harness for the HumanEval problem solving dataset\ndescribed in the paper "Evaluating Large Language Models Trained on Code"\n(https://arxiv.org/abs/2107.03374).\n' SCREAMING_SNAKE_CASE :Dict = '\nCalculates how good are predictions given some references, using certain scores\nArgs:\n predictions: list of candidates to evaluate. Each candidates should be a list\n of strings with several code candidates to solve the problem.\n references: a list with a test for each prediction. Each test should evaluate the\n correctness of a code candidate.\n k: number of code candidates to consider in the evaluation (Default: [1, 10, 100])\n num_workers: number of workers used to evaluate the canidate programs (Default: 4).\n timeout:\nReturns:\n pass_at_k: dict with pass rates for each k\n results: dict with granular results of each unittest\nExamples:\n >>> code_eval = datasets.load_metric("code_eval")\n >>> test_cases = ["assert add(2,3)==5"]\n >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]]\n >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2])\n >>> print(pass_at_k)\n {\'pass@1\': 0.5, \'pass@2\': 1.0}\n' SCREAMING_SNAKE_CASE :Union[str, Any] = '\n################################################################################\n !!!WARNING!!!\n################################################################################\nThe "code_eval" metric executes untrusted model-generated code in Python.\nAlthough it is highly unlikely that model-generated code will do something\novertly malicious in response to this test suite, model-generated code may act\ndestructively due to a lack of model capability or alignment.\nUsers are strongly encouraged to sandbox this evaluation suite so that it\ndoes not perform destructive actions on their host or network. For more\ninformation on how OpenAI sandboxes its code, see the paper "Evaluating Large\nLanguage Models Trained on Code" (https://arxiv.org/abs/2107.03374).\n\nOnce you have read this disclaimer and taken appropriate precautions,\nset the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this\nwith:\n\n>>> import os\n>>> os.environ["HF_ALLOW_CODE_EVAL"] = "1"\n\n################################################################################\\n' SCREAMING_SNAKE_CASE :List[Any] = 'The MIT License\n\nCopyright (c) OpenAI (https://openai.com)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the "Software"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class UpperCAmelCase ( datasets.Metric ): '''simple docstring''' def UpperCamelCase_ ( self : Optional[Any] ): return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION ,citation=_CITATION ,inputs_description=_KWARGS_DESCRIPTION ,features=datasets.Features( { "predictions": datasets.Sequence(datasets.Value("string" ) ), "references": datasets.Value("string" ), } ) ,homepage="https://github.com/openai/human-eval" ,codebase_urls=["https://github.com/openai/human-eval"] ,reference_urls=["https://github.com/openai/human-eval"] ,license=_LICENSE ,) def UpperCamelCase_ ( self : str ,A : int ,A : Union[str, Any] ,A : Optional[int]=[1, 10, 1_00] ,A : Union[str, Any]=4 ,A : Dict=3.0 ): if os.getenv("HF_ALLOW_CODE_EVAL" ,0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("This metric is currently not supported on Windows." ) with ThreadPoolExecutor(max_workers=A ) as executor: __A = [] __A = Counter() __A = 0 __A = defaultdict(A ) for task_id, (candidates, test_case) in enumerate(zip(A ,A ) ): for candidate in candidates: __A = candidate + "\n" + test_case __A = (test_program, timeout, task_id, completion_id[task_id]) __A = executor.submit(A ,*A ) futures.append(A ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(A ): __A = future.result() results[result["task_id"]].append((result["completion_id"], result) ) __A , __A = [], [] for result in results.values(): result.sort() __A = [r[1]["passed"] for r in result] total.append(len(A ) ) correct.append(sum(A ) ) __A = np.array(A ) __A = np.array(A ) __A = k __A = {f'''pass@{k}''': estimate_pass_at_k(A ,A ,A ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def UpperCAmelCase ( a_ , a_ , a_ ) -> Union[str, Any]: """simple docstring""" def estimator(a_ , a_ , a_ ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(a_ , a_ ): __A = itertools.repeat(a_ , len(a_ ) ) else: assert len(a_ ) == len(a_ ) __A = iter(a_ ) return np.array([estimator(int(a_ ) , int(a_ ) , a_ ) for n, c in zip(a_ , a_ )] )
15
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
"""simple docstring""" import logging import os import random import sys from dataclasses import dataclass, field from typing import Optional import datasets import numpy as np import pandas as pd from datasets import load_dataset import transformers from transformers import ( AutoConfig, BartForSequenceClassification, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, TapexTokenizer, Trainer, TrainingArguments, default_data_collator, set_seed, ) from transformers.trainer_utils import get_last_checkpoint from transformers.utils import check_min_version from transformers.utils.versions import require_version # Will error if the minimal version of Transformers is not installed. Remove at your own risks. check_min_version('4.17.0.dev0') require_version('datasets>=1.8.0', 'To fix: pip install -r examples/pytorch/text-classification/requirements.txt') lowerCAmelCase_ = logging.getLogger(__name__) @dataclass class __A : '''simple docstring''' lowerCAmelCase : Optional[str] = field( default="tab_fact" ,metadata={"help": "The name of the dataset to use (via the datasets library)."} ) lowerCAmelCase : Optional[str] = field( default="tab_fact" ,metadata={"help": "The configuration name of the dataset to use (via the datasets library)."} ,) lowerCAmelCase : int = field( default=1_0_2_4 ,metadata={ "help": ( "The maximum total input sequence length after tokenization. Sequences longer " "than this will be truncated, sequences shorter will be padded." ) } ,) lowerCAmelCase : bool = field( default=A_ ,metadata={"help": "Overwrite the cached preprocessed datasets or not."} ) lowerCAmelCase : bool = field( default=A_ ,metadata={ "help": ( "Whether to pad all samples to `max_seq_length`. " "If False, will pad the samples dynamically when batching to the maximum length in the batch." ) } ,) lowerCAmelCase : Optional[int] = field( default=A_ ,metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of training examples to this " "value if set." ) } ,) lowerCAmelCase : Optional[int] = field( default=A_ ,metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of evaluation examples to this " "value if set." ) } ,) lowerCAmelCase : Optional[int] = field( default=A_ ,metadata={ "help": ( "For debugging purposes or quicker training, truncate the number of prediction examples to this " "value if set." ) } ,) lowerCAmelCase : Optional[str] = field( default=A_ ,metadata={"help": "A csv or a json file containing the training data."} ) lowerCAmelCase : Optional[str] = field( default=A_ ,metadata={"help": "A csv or a json file containing the validation data."} ) lowerCAmelCase : Optional[str] = field(default=A_ ,metadata={"help": "A csv or a json file containing the test data."} ) def UpperCAmelCase ( self : str ) -> Any: """simple docstring""" if self.dataset_name is not None: pass elif self.train_file is None or self.validation_file is None: raise ValueError('''Need either a GLUE task, a training/validation file or a dataset name.''' ) else: lowercase__ : List[str] = self.train_file.split('''.''' )[-1] assert train_extension in ["csv", "json"], "`train_file` should be a csv or a json file." lowercase__ : Optional[int] = self.validation_file.split('''.''' )[-1] assert ( validation_extension == train_extension ), "`validation_file` should have the same extension (csv or json) as `train_file`." @dataclass class __A : '''simple docstring''' lowerCAmelCase : str = field( default=A_ ,metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} ) lowerCAmelCase : Optional[str] = field( default=A_ ,metadata={"help": "Pretrained config name or path if not the same as model_name"} ) lowerCAmelCase : Optional[str] = field( default=A_ ,metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} ) lowerCAmelCase : Optional[str] = field( default=A_ ,metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} ,) lowerCAmelCase : bool = field( default=A_ ,metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."} ,) lowerCAmelCase : str = field( default="main" ,metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."} ,) lowerCAmelCase : bool = field( default=A_ ,metadata={ "help": ( "Will use the token generated when running `huggingface-cli login` (necessary to use this script " "with private models)." ) } ,) def __UpperCAmelCase ( ) -> List[Any]: # See all possible arguments in src/transformers/training_args.py # or by passing the --help flag to this script. # We now keep distinct sets of args, for a cleaner separation of concerns. lowercase__ : Union[str, Any] = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) if len(sys.argv ) == 2 and sys.argv[1].endswith('''.json''' ): # If we pass only one argument to the script and it's the path to a json file, # let's parse it to get our arguments. lowercase__ , lowercase__ , lowercase__ : Optional[Any] = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) ) else: lowercase__ , lowercase__ , lowercase__ : Optional[Any] = parser.parse_args_into_dataclasses() # Setup logging logging.basicConfig( format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''' , datefmt='''%m/%d/%Y %H:%M:%S''' , handlers=[logging.StreamHandler(sys.stdout )] , ) lowercase__ : Tuple = training_args.get_process_log_level() logger.setLevel(__lowerCamelCase ) datasets.utils.logging.set_verbosity(__lowerCamelCase ) transformers.utils.logging.set_verbosity(__lowerCamelCase ) transformers.utils.logging.enable_default_handler() transformers.utils.logging.enable_explicit_format() # Log on each process the small summary: logger.warning( f"""Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}""" + f"""distributed training: {bool(training_args.local_rank != -1 )}, 16-bits training: {training_args.fpaa}""" ) logger.info(f"""Training/evaluation parameters {training_args}""" ) # Detecting last checkpoint. lowercase__ : List[Any] = None if os.path.isdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir: lowercase__ : List[Any] = get_last_checkpoint(training_args.output_dir ) if last_checkpoint is None and len(os.listdir(training_args.output_dir ) ) > 0: raise ValueError( f"""Output directory ({training_args.output_dir}) already exists and is not empty. """ '''Use --overwrite_output_dir to overcome.''' ) elif last_checkpoint is not None and training_args.resume_from_checkpoint is None: logger.info( f"""Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change """ '''the `--output_dir` or add `--overwrite_output_dir` to train from scratch.''' ) # Set seed before initializing model. set_seed(training_args.seed ) # Get the datasets: you can either provide your own CSV/JSON training and evaluation files (see below) # or specify a GLUE benchmark task (the dataset will be downloaded automatically from the datasets Hub). # # For JSON files, this script will use the `question` column for the input question and `table` column for the corresponding table. # # If the CSVs/JSONs contain only one non-label column, the script does single sentence classification on this # single column. You can easily tweak this behavior (see below) # # In distributed training, the load_dataset function guarantee that only one local process can concurrently # download the dataset. if data_args.dataset_name is not None: # Downloading and loading a dataset from the hub. lowercase__ : Union[str, Any] = load_dataset( data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) else: # Loading a dataset from your local files. # CSV/JSON training and evaluation files are needed. lowercase__ : Any = {'''train''': data_args.train_file, '''validation''': data_args.validation_file} # Get the test dataset: you can provide your own CSV/JSON test file (see below) # when you use `do_predict` without specifying a GLUE benchmark task. if training_args.do_predict: if data_args.test_file is not None: lowercase__ : str = data_args.train_file.split('''.''' )[-1] lowercase__ : Tuple = data_args.test_file.split('''.''' )[-1] assert ( test_extension == train_extension ), "`test_file` should have the same extension (csv or json) as `train_file`." lowercase__ : Dict = data_args.test_file else: raise ValueError('''Need either a GLUE task or a test file for `do_predict`.''' ) for key in data_files.keys(): logger.info(f"""load a local file for {key}: {data_files[key]}""" ) if data_args.train_file.endswith('''.csv''' ): # Loading a dataset from local csv files lowercase__ : Union[str, Any] = load_dataset('''csv''' , data_files=__lowerCamelCase , cache_dir=model_args.cache_dir ) else: # Loading a dataset from local json files lowercase__ : Optional[Any] = load_dataset('''json''' , data_files=__lowerCamelCase , cache_dir=model_args.cache_dir ) # See more about loading any type of standard or custom dataset at # https://huggingface.co/docs/datasets/loading_datasets.html. # Labels lowercase__ : int = raw_datasets['''train'''].features['''label'''].names lowercase__ : List[Any] = len(__lowerCamelCase ) # Load pretrained model and tokenizer # # In distributed training, the .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. lowercase__ : int = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=__lowerCamelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # load tapex tokenizer lowercase__ : List[Any] = TapexTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , use_fast=model_args.use_fast_tokenizer , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , add_prefix_space=__lowerCamelCase , ) lowercase__ : Any = BartForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_tf=bool('''.ckpt''' in model_args.model_name_or_path ) , config=__lowerCamelCase , cache_dir=model_args.cache_dir , revision=model_args.model_revision , use_auth_token=True if model_args.use_auth_token else None , ) # Padding strategy if data_args.pad_to_max_length: lowercase__ : str = '''max_length''' else: # We will pad later, dynamically at batch creation, to the max sequence length in each batch lowercase__ : List[Any] = False # Some models have set the order of the labels to use, so let's make sure we do use it. lowercase__ : Any = {'''Refused''': 0, '''Entailed''': 1} lowercase__ : str = {0: '''Refused''', 1: '''Entailed'''} if data_args.max_seq_length > tokenizer.model_max_length: logger.warning( f"""The max_seq_length passed ({data_args.max_seq_length}) is larger than the maximum length for the""" f"""model ({tokenizer.model_max_length}). Using max_seq_length={tokenizer.model_max_length}.""" ) lowercase__ : str = min(data_args.max_seq_length , tokenizer.model_max_length ) def preprocess_tabfact_function(__lowerCamelCase ): # Tokenize the texts def _convert_table_text_to_pandas(__lowerCamelCase ): lowercase__ : Dict = [_table_row.split('''#''' ) for _table_row in _table_text.strip('''\n''' ).split('''\n''' )] lowercase__ : List[Any] = pd.DataFrame.from_records(_table_content[1:] , columns=_table_content[0] ) return _table_pd lowercase__ : Tuple = examples['''statement'''] lowercase__ : str = list(map(_convert_table_text_to_pandas , examples['''table_text'''] ) ) lowercase__ : Dict = tokenizer(__lowerCamelCase , __lowerCamelCase , padding=__lowerCamelCase , max_length=__lowerCamelCase , truncation=__lowerCamelCase ) lowercase__ : List[Any] = examples['''label'''] return result with training_args.main_process_first(desc='''dataset map pre-processing''' ): lowercase__ : List[Any] = raw_datasets.map( __lowerCamelCase , batched=__lowerCamelCase , load_from_cache_file=not data_args.overwrite_cache , desc='''Running tokenizer on dataset''' , ) if training_args.do_train: if "train" not in raw_datasets: raise ValueError('''--do_train requires a train dataset''' ) lowercase__ : str = raw_datasets['''train'''] if data_args.max_train_samples is not None: lowercase__ : Union[str, Any] = train_dataset.select(range(data_args.max_train_samples ) ) if training_args.do_eval: if "validation" not in raw_datasets and "validation_matched" not in raw_datasets: raise ValueError('''--do_eval requires a validation dataset''' ) lowercase__ : Any = raw_datasets['''validation'''] if data_args.max_eval_samples is not None: lowercase__ : Optional[int] = eval_dataset.select(range(data_args.max_eval_samples ) ) if training_args.do_predict or data_args.test_file is not None: if "test" not in raw_datasets and "test_matched" not in raw_datasets: raise ValueError('''--do_predict requires a test dataset''' ) lowercase__ : Optional[Any] = raw_datasets['''test'''] if data_args.max_predict_samples is not None: lowercase__ : str = predict_dataset.select(range(data_args.max_predict_samples ) ) # Log a few random samples from the training set: if training_args.do_train: for index in random.sample(range(len(__lowerCamelCase ) ) , 3 ): logger.info(f"""Sample {index} of the training set: {train_dataset[index]}.""" ) # You can define your custom compute_metrics function. It takes an `EvalPrediction` object (a namedtuple with a # predictions and label_ids field) and has to return a dictionary string to float. def compute_metrics(__lowerCamelCase ): lowercase__ : Union[str, Any] = p.predictions[0] if isinstance(p.predictions , __lowerCamelCase ) else p.predictions lowercase__ : Dict = np.argmax(__lowerCamelCase , axis=1 ) return {"accuracy": (preds == p.label_ids).astype(np.floataa ).mean().item()} # Data collator will default to DataCollatorWithPadding, so we change it if we already did the padding. if data_args.pad_to_max_length: lowercase__ : List[str] = default_data_collator elif training_args.fpaa: lowercase__ : Any = DataCollatorWithPadding(__lowerCamelCase , pad_to_multiple_of=8 ) else: lowercase__ : List[Any] = None # Initialize our Trainer lowercase__ : Union[str, Any] = Trainer( model=__lowerCamelCase , args=__lowerCamelCase , train_dataset=train_dataset if training_args.do_train else None , eval_dataset=eval_dataset if training_args.do_eval else None , compute_metrics=__lowerCamelCase , tokenizer=__lowerCamelCase , data_collator=__lowerCamelCase , ) # Training if training_args.do_train: lowercase__ : Dict = None if training_args.resume_from_checkpoint is not None: lowercase__ : Dict = training_args.resume_from_checkpoint elif last_checkpoint is not None: lowercase__ : int = last_checkpoint lowercase__ : List[str] = trainer.train(resume_from_checkpoint=__lowerCamelCase ) lowercase__ : List[str] = train_result.metrics lowercase__ : List[str] = ( data_args.max_train_samples if data_args.max_train_samples is not None else len(__lowerCamelCase ) ) lowercase__ : Any = min(__lowerCamelCase , len(__lowerCamelCase ) ) trainer.save_model() # Saves the tokenizer too for easy upload trainer.log_metrics('''train''' , __lowerCamelCase ) trainer.save_metrics('''train''' , __lowerCamelCase ) trainer.save_state() # Evaluation if training_args.do_eval: logger.info('''*** Evaluate ***''' ) lowercase__ : Union[str, Any] = trainer.evaluate(eval_dataset=__lowerCamelCase ) lowercase__ : Union[str, Any] = data_args.max_eval_samples if data_args.max_eval_samples is not None else len(__lowerCamelCase ) lowercase__ : Tuple = min(__lowerCamelCase , len(__lowerCamelCase ) ) trainer.log_metrics('''eval''' , __lowerCamelCase ) trainer.save_metrics('''eval''' , __lowerCamelCase ) if training_args.do_predict: logger.info('''*** Predict ***''' ) # Removing the `label` columns because it contains -1 and Trainer won't like that. lowercase__ : Tuple = predict_dataset.remove_columns('''label''' ) lowercase__ : str = trainer.predict(__lowerCamelCase , metric_key_prefix='''predict''' ).predictions lowercase__ : Tuple = np.argmax(__lowerCamelCase , axis=1 ) lowercase__ : List[Any] = os.path.join(training_args.output_dir , '''predict_results_tabfact.txt''' ) if trainer.is_world_process_zero(): with open(__lowerCamelCase , '''w''' ) as writer: logger.info('''***** Predict Results *****''' ) writer.write('''index\tprediction\n''' ) for index, item in enumerate(__lowerCamelCase ): lowercase__ : Optional[Any] = label_list[item] writer.write(f"""{index}\t{item}\n""" ) lowercase__ : Dict = {'''finetuned_from''': model_args.model_name_or_path, '''tasks''': '''text-classification'''} if training_args.push_to_hub: trainer.push_to_hub(**__lowerCamelCase ) else: trainer.create_model_card(**__lowerCamelCase ) def __UpperCAmelCase ( __lowerCamelCase ) -> Optional[int]: # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
16
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
"""simple docstring""" from __future__ import annotations from typing import Any class _lowerCAmelCase : """simple docstring""" def __init__( self : Any, UpperCAmelCase__ : int ): __lowercase = num_of_nodes __lowercase = [] __lowercase = {} def _lowercase ( self : Optional[Any], UpperCAmelCase__ : int, UpperCAmelCase__ : int, UpperCAmelCase__ : int ): self.m_edges.append([u_node, v_node, weight] ) def _lowercase ( self : Union[str, Any], UpperCAmelCase__ : int ): if self.m_component[u_node] == u_node: return u_node return self.find_component(self.m_component[u_node] ) def _lowercase ( self : List[Any], UpperCAmelCase__ : int ): if self.m_component[u_node] != u_node: for k in self.m_component: __lowercase = self.find_component(UpperCAmelCase__ ) def _lowercase ( self : Union[str, Any], UpperCAmelCase__ : list[int], UpperCAmelCase__ : int, UpperCAmelCase__ : int ): if component_size[u_node] <= component_size[v_node]: __lowercase = v_node component_size[v_node] += component_size[u_node] self.set_component(UpperCAmelCase__ ) elif component_size[u_node] >= component_size[v_node]: __lowercase = self.find_component(UpperCAmelCase__ ) component_size[u_node] += component_size[v_node] self.set_component(UpperCAmelCase__ ) def _lowercase ( self : Any ): __lowercase = [] __lowercase = 0 __lowercase = [-1] * self.m_num_of_nodes # A list of components (initialized to all of the nodes) for node in range(self.m_num_of_nodes ): self.m_component.update({node: node} ) component_size.append(1 ) __lowercase = self.m_num_of_nodes while num_of_components > 1: for edge in self.m_edges: __lowercase ,__lowercase ,__lowercase = edge __lowercase = self.m_component[u] __lowercase = self.m_component[v] if u_component != v_component: for component in (u_component, v_component): if ( minimum_weight_edge[component] == -1 or minimum_weight_edge[component][2] > w ): __lowercase = [u, v, w] for edge in minimum_weight_edge: if isinstance(UpperCAmelCase__, UpperCAmelCase__ ): __lowercase ,__lowercase ,__lowercase = edge __lowercase = self.m_component[u] __lowercase = self.m_component[v] if u_component != v_component: mst_weight += w self.union(UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__ ) print(F"""Added edge [{u} - {v}]\nAdded weight: {w}\n""" ) num_of_components -= 1 __lowercase = [-1] * self.m_num_of_nodes print(F"""The total weight of the minimal spanning tree is: {mst_weight}""" ) def _A ( ) -> None: '''simple docstring''' if __name__ == "__main__": import doctest doctest.testmod()
17
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
0
__lowerCamelCase : Dict = { '''Pillow''': '''Pillow<10.0.0''', '''accelerate''': '''accelerate>=0.20.3''', '''av''': '''av==9.2.0''', '''beautifulsoup4''': '''beautifulsoup4''', '''black''': '''black~=23.1''', '''codecarbon''': '''codecarbon==1.2.0''', '''cookiecutter''': '''cookiecutter==1.7.3''', '''dataclasses''': '''dataclasses''', '''datasets''': '''datasets!=2.5.0''', '''decord''': '''decord==0.6.0''', '''deepspeed''': '''deepspeed>=0.9.3''', '''diffusers''': '''diffusers''', '''dill''': '''dill<0.3.5''', '''evaluate''': '''evaluate>=0.2.0''', '''fairscale''': '''fairscale>0.3''', '''faiss-cpu''': '''faiss-cpu''', '''fastapi''': '''fastapi''', '''filelock''': '''filelock''', '''flax''': '''flax>=0.4.1,<=0.7.0''', '''ftfy''': '''ftfy''', '''fugashi''': '''fugashi>=1.0''', '''GitPython''': '''GitPython<3.1.19''', '''hf-doc-builder''': '''hf-doc-builder>=0.3.0''', '''huggingface-hub''': '''huggingface-hub>=0.14.1,<1.0''', '''importlib_metadata''': '''importlib_metadata''', '''ipadic''': '''ipadic>=1.0.0,<2.0''', '''isort''': '''isort>=5.5.4''', '''jax''': '''jax>=0.2.8,!=0.3.2,<=0.4.13''', '''jaxlib''': '''jaxlib>=0.1.65,<=0.4.13''', '''jieba''': '''jieba''', '''kenlm''': '''kenlm''', '''keras-nlp''': '''keras-nlp>=0.3.1''', '''librosa''': '''librosa''', '''nltk''': '''nltk''', '''natten''': '''natten>=0.14.6''', '''numpy''': '''numpy>=1.17''', '''onnxconverter-common''': '''onnxconverter-common''', '''onnxruntime-tools''': '''onnxruntime-tools>=1.4.2''', '''onnxruntime''': '''onnxruntime>=1.4.0''', '''opencv-python''': '''opencv-python''', '''optuna''': '''optuna''', '''optax''': '''optax>=0.0.8,<=0.1.4''', '''packaging''': '''packaging>=20.0''', '''parameterized''': '''parameterized''', '''phonemizer''': '''phonemizer''', '''protobuf''': '''protobuf''', '''psutil''': '''psutil''', '''pyyaml''': '''pyyaml>=5.1''', '''pydantic''': '''pydantic<2''', '''pytest''': '''pytest>=7.2.0''', '''pytest-timeout''': '''pytest-timeout''', '''pytest-xdist''': '''pytest-xdist''', '''python''': '''python>=3.8.0''', '''ray[tune]''': '''ray[tune]''', '''regex''': '''regex!=2019.12.17''', '''requests''': '''requests''', '''rhoknp''': '''rhoknp>=1.1.0,<1.3.1''', '''rjieba''': '''rjieba''', '''rouge-score''': '''rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1''', '''ruff''': '''ruff>=0.0.241,<=0.0.259''', '''sacrebleu''': '''sacrebleu>=1.4.12,<2.0.0''', '''sacremoses''': '''sacremoses''', '''safetensors''': '''safetensors>=0.3.1''', '''sagemaker''': '''sagemaker>=2.31.0''', '''scikit-learn''': '''scikit-learn''', '''sentencepiece''': '''sentencepiece>=0.1.91,!=0.1.92''', '''sigopt''': '''sigopt''', '''starlette''': '''starlette''', '''sudachipy''': '''sudachipy>=0.6.6''', '''sudachidict_core''': '''sudachidict_core>=20220729''', '''tensorflow-cpu''': '''tensorflow-cpu>=2.6,<2.14''', '''tensorflow''': '''tensorflow>=2.6,<2.14''', '''tensorflow-text''': '''tensorflow-text<2.14''', '''tf2onnx''': '''tf2onnx''', '''timeout-decorator''': '''timeout-decorator''', '''timm''': '''timm''', '''tokenizers''': '''tokenizers>=0.11.1,!=0.11.3,<0.14''', '''torch''': '''torch>=1.9,!=1.12.0''', '''torchaudio''': '''torchaudio''', '''torchvision''': '''torchvision''', '''pyctcdecode''': '''pyctcdecode>=0.4.0''', '''tqdm''': '''tqdm>=4.27''', '''unidic''': '''unidic>=1.0.2''', '''unidic_lite''': '''unidic_lite>=1.0.7''', '''urllib3''': '''urllib3<2.0.0''', '''uvicorn''': '''uvicorn''', }
18
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 _lowerCamelCase( _a ): def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Tuple = self.config_class(**self.inputs_dict) self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier')) class _lowerCamelCase: def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, ) -> Any: """simple docstring""" _lowercase : Any = parent _lowercase : Optional[int] = batch_size _lowercase : Dict = image_size _lowercase : str = patch_size _lowercase : Optional[int] = num_channels _lowercase : Optional[Any] = make_divisible(5_12 * width_multiplier, divisor=8) _lowercase : str = hidden_act _lowercase : Dict = conv_kernel_size _lowercase : int = output_stride _lowercase : Optional[Any] = classifier_dropout_prob _lowercase : Tuple = use_labels _lowercase : int = is_training _lowercase : Optional[Any] = num_labels _lowercase : Dict = initializer_range _lowercase : List[str] = scope _lowercase : Tuple = width_multiplier _lowercase : List[str] = ffn_dropout _lowercase : Dict = attn_dropout def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _lowercase : Dict = None _lowercase : Optional[int] = None if self.use_labels: _lowercase : Optional[Any] = ids_tensor([self.batch_size], self.num_labels) _lowercase : str = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels) _lowercase : Union[str, Any] = self.get_config() return config, pixel_values, labels, pixel_labels def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : Optional[int] = MobileViTVaModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) 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 UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : int = self.num_labels _lowercase : Optional[int] = MobileViTVaForImageClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Any = self.num_labels _lowercase : Union[str, Any] = MobileViTVaForSemanticSegmentation(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[int] = model(lowerCamelCase) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) _lowercase : List[Any] = model(lowerCamelCase, labels=lowerCamelCase) 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 UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase , _lowercase : int = config_and_inputs _lowercase : List[str] = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : List[Any] = ( (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation) if is_torch_available() else () ) lowercase_ : Dict = ( { """feature-extraction""": MobileViTVaModel, """image-classification""": MobileViTVaForImageClassification, """image-segmentation""": MobileViTVaForSemanticSegmentation, } if is_torch_available() else {} ) lowercase_ : List[Any] = False lowercase_ : Optional[int] = False lowercase_ : List[Any] = False lowercase_ : Tuple = False def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = MobileViTVaModelTester(self) _lowercase : Tuple = MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason='MobileViTV2 does not use inputs_embeds') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not support input and output embeddings') def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" pass @unittest.skip(reason='MobileViTV2 does not output attentions') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.') def UpperCamelCase ( self) -> int: """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.') def UpperCamelCase ( self) -> List[Any]: """simple docstring""" pass def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(lowerCamelCase) _lowercase : Tuple = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : Any = [*signature.parameters.keys()] _lowercase : Union[str, Any] = ['pixel_values'] self.assertListEqual(arg_names[:1], lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase): _lowercase : Optional[Any] = model_class(lowerCamelCase) model.to(lowerCamelCase) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase)) _lowercase : List[Any] = outputs.hidden_states _lowercase : Tuple = 5 self.assertEqual(len(lowerCamelCase), lowerCamelCase) # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width) # with the width and height being successively divided by 2. _lowercase : Optional[int] = 2 for i in range(len(lowerCamelCase)): 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) _lowercase , _lowercase : Dict = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Tuple = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : Optional[Any] = True check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : str = MobileViTVaModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) def UpperCamelCase_( ) -> Dict: _lowercase : Tuple = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class _lowerCamelCase( unittest.TestCase ): @cached_property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return ( MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256') if is_vision_available() else None ) @slow def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to( lowerCamelCase) _lowercase : Dict = self.default_image_processor _lowercase : Union[str, Any] = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Tuple = model(**lowerCamelCase) # verify the logits _lowercase : Optional[int] = torch.Size((1, 10_00)) self.assertEqual(outputs.logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase) self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Optional[int] = model.to(lowerCamelCase) _lowercase : Optional[int] = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Union[str, Any] = prepare_img() _lowercase : Tuple = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**lowerCamelCase) _lowercase : str = outputs.logits # verify the logits _lowercase : Tuple = torch.Size((1, 21, 32, 32)) self.assertEqual(logits.shape, lowerCamelCase) _lowercase : Union[str, Any] = 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=lowerCamelCase, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4)) @slow def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : Tuple = model.to(lowerCamelCase) _lowercase : str = MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3') _lowercase : int = prepare_img() _lowercase : Dict = image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase) # forward pass with torch.no_grad(): _lowercase : Union[str, Any] = model(**lowerCamelCase) _lowercase : Any = outputs.logits.detach().cpu() _lowercase : Optional[int] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)]) _lowercase : Any = torch.Size((50, 60)) self.assertEqual(segmentation[0].shape, lowerCamelCase) _lowercase : Optional[Any] = image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase) _lowercase : Optional[int] = torch.Size((32, 32)) self.assertEqual(segmentation[0].shape, lowerCamelCase)
21
0
def lowerCamelCase_ ( lowerCamelCase__ ): return 1_0 - x * x def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # Bolzano theory in order to find if there is a root between a and b if equation(lowerCamelCase__ ) * equation(lowerCamelCase__ ) >= 0: raise ValueError("Wrong space!" ) lowerCamelCase_ = a while (b - a) >= 0.01: # Find middle point lowerCamelCase_ = (a + b) / 2 # Check if middle point is root if equation(lowerCamelCase__ ) == 0.0: break # Decide the side to repeat the steps if equation(lowerCamelCase__ ) * equation(lowerCamelCase__ ) < 0: lowerCamelCase_ = c else: lowerCamelCase_ = c return c if __name__ == "__main__": import doctest doctest.testmod() print(bisection(-2, 5)) print(bisection(0, 6))
19
import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer SCREAMING_SNAKE_CASE : str = "bart" SCREAMING_SNAKE_CASE : Optional[int] = True @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> int: if LOAD_DENSE_INDEX: _lowercase : str = AutoTokenizer.from_pretrained('yjernite/retribert-base-uncased' ) _lowercase : Union[str, Any] = AutoModel.from_pretrained('yjernite/retribert-base-uncased' ).to('cuda:0' ) _lowercase : str = qar_model.eval() else: _lowercase , _lowercase : Any = (None, None) if MODEL_TYPE == "bart": _lowercase : Dict = AutoTokenizer.from_pretrained('yjernite/bart_eli5' ) _lowercase : int = AutoModelForSeqaSeqLM.from_pretrained('yjernite/bart_eli5' ).to('cuda:0' ) _lowercase : Any = torch.load('seq2seq_models/eli5_bart_model_blm_2.pth' ) sas_model.load_state_dict(save_dict['model'] ) _lowercase : List[Any] = sas_model.eval() else: _lowercase , _lowercase : Union[str, Any] = make_qa_sas_model( model_name='t5-small' , from_file='seq2seq_models/eli5_t5_model_1024_4.pth' , device='cuda:0' ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> str: if LOAD_DENSE_INDEX: _lowercase : Optional[Any] = faiss.StandardGpuResources() _lowercase : Optional[int] = datasets.load_dataset(path='wiki_snippets' , name='wiki40b_en_100_0' )['train'] _lowercase : Tuple = np.memmap( 'wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat' , dtype='float32' , mode='r' , shape=(wikiaab_passages.num_rows, 128) , ) _lowercase : Any = faiss.IndexFlatIP(128 ) _lowercase : Union[str, Any] = faiss.index_cpu_to_gpu(lowerCamelCase_ , 1 , lowerCamelCase_ ) wikiaab_gpu_index_flat.add(lowerCamelCase_ ) # TODO fix for larger GPU else: _lowercase , _lowercase : Any = (None, None) _lowercase : List[str] = Elasticsearch([{'host': 'localhost', 'port': '9200'}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=lowerCamelCase_ ) def UpperCamelCase_( ) -> Any: _lowercase : List[str] = datasets.load_dataset('eli5' , name='LFQA_reddit' ) _lowercase : Optional[Any] = elia['train_eli5'] _lowercase : Tuple = np.memmap( 'eli5_questions_reps.dat' , dtype='float32' , mode='r' , shape=(elia_train.num_rows, 128) ) _lowercase : Union[str, Any] = faiss.IndexFlatIP(128 ) eli5_train_q_index.add(lowerCamelCase_ ) return (elia_train, eli5_train_q_index) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = load_indexes() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[Any] = load_models() SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : List[Any] = load_train_data() def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_=10 ) -> List[str]: _lowercase : Any = embed_questions_for_retrieval([question] , lowerCamelCase_ , lowerCamelCase_ ) _lowercase , _lowercase : List[str] = eli5_train_q_index.search(lowerCamelCase_ , lowerCamelCase_ ) _lowercase : List[str] = [elia_train[int(lowerCamelCase_ )] for i in I[0]] return nn_examples def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_="wiki40b" , lowerCamelCase_="dense" , lowerCamelCase_=10 ) -> Dict: if source == "none": _lowercase , _lowercase : Union[str, Any] = (' <P> '.join(['' for _ in range(11 )] ).strip(), []) else: if method == "dense": _lowercase , _lowercase : Dict = query_qa_dense_index( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) else: _lowercase , _lowercase : str = query_es_index( lowerCamelCase_ , lowerCamelCase_ , index_name='english_wiki40b_snippets_100w' , n_results=lowerCamelCase_ , ) _lowercase : List[Any] = [ (res['article_title'], res['section_title'].strip(), res['score'], res['passage_text']) for res in hit_lst ] _lowercase : Union[str, Any] = 'question: {} context: {}'.format(lowerCamelCase_ , lowerCamelCase_ ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda lowerCamelCase_ : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda lowerCamelCase_ : None), } ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=64 , lowerCamelCase_=256 , lowerCamelCase_=False , lowerCamelCase_=2 , lowerCamelCase_=0.95 , lowerCamelCase_=0.8 ) -> Dict: with torch.no_grad(): _lowercase : str = qa_sas_generate( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , num_answers=1 , num_beams=lowerCamelCase_ , min_len=lowerCamelCase_ , max_len=lowerCamelCase_ , do_sample=lowerCamelCase_ , temp=lowerCamelCase_ , top_p=lowerCamelCase_ , top_k=lowerCamelCase_ , max_input_length=1024 , device='cuda:0' , )[0] return (answer, support_list) st.title("Long Form Question Answering with ELI5") # Start sidebar SCREAMING_SNAKE_CASE : Union[str, Any] = "<img src='https://huggingface.co/front/assets/huggingface_logo.svg'>" SCREAMING_SNAKE_CASE : List[Any] = "\n<html>\n <head>\n <style>\n .img-container {\n padding-left: 90px;\n padding-right: 90px;\n padding-top: 50px;\n padding-bottom: 50px;\n background-color: #f0f3f9;\n }\n </style>\n </head>\n <body>\n <span class=\"img-container\"> <!-- Inline parent element -->\n %s\n </span>\n </body>\n</html>\n" % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia SCREAMING_SNAKE_CASE : Any = "\nThis demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html).\nFirst, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset,\na pre-processed fixed snapshot of Wikipedia.\n" st.sidebar.markdown(description, unsafe_allow_html=True) SCREAMING_SNAKE_CASE : Union[str, Any] = [ "Answer the question", "View the retrieved document only", "View the most similar ELI5 question and answer", "Show me everything, please!", ] SCREAMING_SNAKE_CASE : Optional[int] = st.sidebar.checkbox("Demo options") if demo_options: SCREAMING_SNAKE_CASE : List[str] = st.sidebar.selectbox( "", action_list, index=3, ) SCREAMING_SNAKE_CASE : Optional[int] = action_list.index(action_st) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.selectbox( "", ["Show full text of passages", "Show passage section titles"], index=0, ) SCREAMING_SNAKE_CASE : int = show_type == "Show full text of passages" else: SCREAMING_SNAKE_CASE : Any = 3 SCREAMING_SNAKE_CASE : Dict = True SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.checkbox("Retrieval options") if retrieval_options: SCREAMING_SNAKE_CASE : Tuple = "\n ### Information retriever options\n\n The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding\n trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs.\n The answer is then generated by sequence to sequence model which takes the question and retrieved document as input.\n " st.sidebar.markdown(retriever_info) SCREAMING_SNAKE_CASE : Dict = st.sidebar.selectbox("Which Wikipedia format should the model use?", ["wiki40b", "none"]) SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.selectbox("Which Wikipedia indexer should the model use?", ["dense", "sparse", "mixed"]) else: SCREAMING_SNAKE_CASE : int = "wiki40b" SCREAMING_SNAKE_CASE : int = "dense" SCREAMING_SNAKE_CASE : str = "beam" SCREAMING_SNAKE_CASE : Optional[Any] = 2 SCREAMING_SNAKE_CASE : List[str] = 64 SCREAMING_SNAKE_CASE : Union[str, Any] = 256 SCREAMING_SNAKE_CASE : Union[str, Any] = None SCREAMING_SNAKE_CASE : List[Any] = None SCREAMING_SNAKE_CASE : str = st.sidebar.checkbox("Generation options") if generate_options: SCREAMING_SNAKE_CASE : Any = "\n ### Answer generation options\n\n The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large)\n weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with\n **beam** search, or **sample** from the decoder's output probabilities.\n " st.sidebar.markdown(generate_info) SCREAMING_SNAKE_CASE : List[Any] = st.sidebar.selectbox("Would you like to use beam search or sample an answer?", ["beam", "sampled"]) SCREAMING_SNAKE_CASE : Tuple = st.sidebar.slider( "Minimum generation length", min_value=8, max_value=256, value=64, step=8, format=None, key=None ) SCREAMING_SNAKE_CASE : int = st.sidebar.slider( "Maximum generation length", min_value=64, max_value=512, value=256, step=16, format=None, key=None ) if sampled == "beam": SCREAMING_SNAKE_CASE : int = st.sidebar.slider("Beam size", min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: SCREAMING_SNAKE_CASE : Union[str, Any] = st.sidebar.slider( "Nucleus sampling p", min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : Any = st.sidebar.slider( "Temperature", min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) SCREAMING_SNAKE_CASE : str = None # start main text SCREAMING_SNAKE_CASE : List[str] = [ "<MY QUESTION>", "How do people make chocolate?", "Why do we get a fever when we are sick?", "How can different animals perceive different colors?", "What is natural language processing?", "What's the best way to treat a sunburn?", "What exactly are vitamins ?", "How does nuclear energy provide electricity?", "What's the difference between viruses and bacteria?", "Why are flutes classified as woodwinds when most of them are made out of metal ?", "Why do people like drinking coffee even though it tastes so bad?", "What happens when wine ages? How does it make the wine taste better?", "If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?", "How can we set a date to the beginning or end of an artistic period? Doesn't the change happen gradually?", "How does New Zealand have so many large bird predators?", ] SCREAMING_SNAKE_CASE : str = st.selectbox( "What would you like to ask? ---- select <MY QUESTION> to enter a new query", questions_list, index=1, ) if question_s == "<MY QUESTION>": SCREAMING_SNAKE_CASE : List[str] = st.text_input("Enter your question here:", "") else: SCREAMING_SNAKE_CASE : Optional[int] = question_s if st.button("Show me!"): if action in [0, 1, 3]: if index_type == "mixed": SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Optional[int] = make_support(question, source=wiki_source, method="dense", n_results=10) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method="sparse", n_results=10) SCREAMING_SNAKE_CASE : Tuple = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] SCREAMING_SNAKE_CASE : Optional[Any] = support_list[:10] SCREAMING_SNAKE_CASE : int = "<P> " + " <P> ".join([res[-1] for res in support_list]) else: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = make_support(question, source=wiki_source, method=index_type, n_results=10) if action in [0, 3]: SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Tuple = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == "sampled"), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown("### The model generated answer is:") st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown("--- \n ### The model is drawing information from the following Wikipedia passages:") for i, res in enumerate(support_list): SCREAMING_SNAKE_CASE : Optional[Any] = "https://en.wikipedia.org/wiki/{}".format(res[0].replace(" ", "_")) SCREAMING_SNAKE_CASE : List[Any] = res[1].strip() if sec_titles == "": SCREAMING_SNAKE_CASE : Union[str, Any] = "[{}]({})".format(res[0], wiki_url) else: SCREAMING_SNAKE_CASE : Any = sec_titles.split(" & ") SCREAMING_SNAKE_CASE : List[Any] = " & ".join( ["[{}]({}#{})".format(sec.strip(), wiki_url, sec.strip().replace(" ", "_")) for sec in sec_list] ) st.markdown( "{0:02d} - **Article**: {1:<18} <br> _Section_: {2}".format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( "> <span style=\"font-family:arial; font-size:10pt;\">" + res[-1] + "</span>", unsafe_allow_html=True ) if action in [2, 3]: SCREAMING_SNAKE_CASE : str = find_nearest_training(question) SCREAMING_SNAKE_CASE : Any = nn_train_list[0] st.markdown( "--- \n ### The most similar question in the ELI5 training set was: \n\n {}".format(train_exple["title"]) ) SCREAMING_SNAKE_CASE : str = [ "{}. {}".format(i + 1, " \n".join([line.strip() for line in ans.split("\n") if line.strip() != ""])) for i, (ans, sc) in enumerate(zip(train_exple["answers"]["text"], train_exple["answers"]["score"])) if i == 0 or sc > 2 ] st.markdown("##### Its answers were: \n\n {}".format("\n".join(answers_st))) SCREAMING_SNAKE_CASE : Tuple = "\n---\n\n**Disclaimer**\n\n*The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system.\nEvaluating biases of such a model and ensuring factual generations are still very much open research problems.\nTherefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.*\n" st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
21
0
def _snake_case( SCREAMING_SNAKE_CASE__ ) -> int: return 1 if digit in (0, 1) else (digit * factorial(digit - 1 )) def _snake_case( SCREAMING_SNAKE_CASE__ ) -> bool: lowercase : Optional[int] = 0 lowercase : str = number while duplicate > 0: lowercase , lowercase : List[Any] = divmod(SCREAMING_SNAKE_CASE__ , 10 ) fact_sum += factorial(SCREAMING_SNAKE_CASE__ ) return fact_sum == number if __name__ == "__main__": print("""Program to check whether a number is a Krisnamurthy Number or not.""") lowercase : List[str] = int(input("""Enter number: """).strip()) print( F'''{number} is {"" if krishnamurthy(number) else "not "}a Krishnamurthy Number.''' )
20
import collections from typing import List, Optional, Union from ...tokenization_utils_base import BatchEncoding from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging from ..bert.tokenization_bert import BertTokenizer SCREAMING_SNAKE_CASE : Any = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : Union[str, Any] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} SCREAMING_SNAKE_CASE : Union[str, Any] = { "vocab_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-ctx_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-ctx_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "vocab_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-question_encoder-single-nq-base": ( "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-question_encoder-multiset-base": ( "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : str = { "vocab_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt" ), }, "tokenizer_file": { "facebook/dpr-reader-single-nq-base": ( "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json" ), "facebook/dpr-reader-multiset-base": ( "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json" ), }, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-ctx_encoder-single-nq-base": 512, "facebook/dpr-ctx_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Optional[Any] = { "facebook/dpr-question_encoder-single-nq-base": 512, "facebook/dpr-question_encoder-multiset-base": 512, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": 512, "facebook/dpr-reader-multiset-base": 512, } SCREAMING_SNAKE_CASE : List[Any] = { "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True}, "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True}, } SCREAMING_SNAKE_CASE : Dict = { "facebook/dpr-reader-single-nq-base": {"do_lower_case": True}, "facebook/dpr-reader-multiset-base": {"do_lower_case": True}, } class _lowerCamelCase( _a ): lowercase_ : Any = VOCAB_FILES_NAMES lowercase_ : Optional[int] = CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : str = CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION class _lowerCamelCase( _a ): lowercase_ : Optional[int] = VOCAB_FILES_NAMES lowercase_ : Any = QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : str = QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Union[str, Any] = QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION SCREAMING_SNAKE_CASE : Optional[int] = collections.namedtuple( "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"] ) SCREAMING_SNAKE_CASE : Any = collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"]) SCREAMING_SNAKE_CASE : str = r"\n Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n with the format:\n\n ```\n [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n ```\n\n Args:\n questions (`str` or `List[str]`):\n The questions to be encoded. You can specify one question for many passages. In this case, the question\n will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n `titles` or `texts`.\n titles (`str` or `List[str]`):\n The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n texts (`str` or `List[str]`):\n The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n Activates and controls padding. Accepts the following values:\n\n - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n if provided).\n - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided.\n - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n lengths).\n truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n Activates and controls truncation. Accepts the following values:\n\n - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n the maximum acceptable input length for the model if that argument is not provided. This will truncate\n token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n of pairs) is provided.\n - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the first\n sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n acceptable input length for the model if that argument is not provided. This will only truncate the\n second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n greater than the model maximum admissible input size).\n max_length (`int`, *optional*):\n Controls the maximum length to use by one of the truncation/padding parameters.\n\n If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n is required by one of the truncation/padding parameters. If the model has no specific maximum input\n length (like XLNet) truncation/padding to a maximum length will be deactivated.\n return_tensors (`str` or [`~utils.TensorType`], *optional*):\n If set, will return tensors instead of list of python integers. Acceptable values are:\n\n - `'tf'`: Return TensorFlow `tf.constant` objects.\n - `'pt'`: Return PyTorch `torch.Tensor` objects.\n - `'np'`: Return Numpy `np.ndarray` objects.\n return_attention_mask (`bool`, *optional*):\n Whether or not to return the attention mask. If not set, will return the attention mask according to the\n specific tokenizer's default, defined by the `return_outputs` attribute.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Returns:\n `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n - `input_ids`: List of token ids to be fed to a model.\n - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n " @add_start_docstrings(_a ) class _lowerCamelCase: def __call__( self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = False, lowerCamelCase = False, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = None, **lowerCamelCase, ) -> BatchEncoding: """simple docstring""" if titles is None and texts is None: return super().__call__( lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) elif titles is None or texts is None: _lowercase : Dict = titles if texts is None else texts return super().__call__( lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase, return_attention_mask=lowerCamelCase, **lowerCamelCase, ) _lowercase : Union[str, Any] = titles if not isinstance(lowerCamelCase, lowerCamelCase) else [titles] _lowercase : Tuple = texts if not isinstance(lowerCamelCase, lowerCamelCase) else [texts] _lowercase : Optional[Any] = len(lowerCamelCase) _lowercase : Any = questions if not isinstance(lowerCamelCase, lowerCamelCase) else [questions] * n_passages if len(lowerCamelCase) != len(lowerCamelCase): raise ValueError( F'''There should be as many titles than texts but got {len(lowerCamelCase)} titles and {len(lowerCamelCase)} texts.''') _lowercase : Any = super().__call__(lowerCamelCase, lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : Tuple = super().__call__(lowerCamelCase, add_special_tokens=lowerCamelCase, padding=lowerCamelCase, truncation=lowerCamelCase)['input_ids'] _lowercase : int = { 'input_ids': [ (encoded_question_and_title + encoded_text)[:max_length] if max_length is not None and truncation else encoded_question_and_title + encoded_text for encoded_question_and_title, encoded_text in zip(lowerCamelCase, lowerCamelCase) ] } if return_attention_mask is not False: _lowercase : Optional[Any] = [] for input_ids in encoded_inputs["input_ids"]: attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids]) _lowercase : Union[str, Any] = attention_mask return self.pad(lowerCamelCase, padding=lowerCamelCase, max_length=lowerCamelCase, return_tensors=lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 16, lowerCamelCase = 64, lowerCamelCase = 4, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : Union[str, Any] = reader_input['input_ids'] _lowercase , _lowercase , _lowercase : Tuple = reader_output[:3] _lowercase : Tuple = len(lowerCamelCase) _lowercase : str = sorted(range(lowerCamelCase), reverse=lowerCamelCase, key=relevance_logits.__getitem__) _lowercase : List[DPRReaderOutput] = [] for doc_id in sorted_docs: _lowercase : str = list(input_ids[doc_id]) # assuming question & title information is at the beginning of the sequence _lowercase : Any = sequence_ids.index(self.sep_token_id, 2) + 1 # second sep id if sequence_ids[-1] == self.pad_token_id: _lowercase : List[Any] = sequence_ids.index(self.pad_token_id) else: _lowercase : List[str] = len(lowerCamelCase) _lowercase : Tuple = self._get_best_spans( start_logits=start_logits[doc_id][passage_offset:sequence_len], end_logits=end_logits[doc_id][passage_offset:sequence_len], max_answer_length=lowerCamelCase, top_spans=lowerCamelCase, ) for start_index, end_index in best_spans: start_index += passage_offset end_index += passage_offset nbest_spans_predictions.append( DPRSpanPrediction( span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index], relevance_score=relevance_logits[doc_id], doc_id=lowerCamelCase, start_index=lowerCamelCase, end_index=lowerCamelCase, text=self.decode(sequence_ids[start_index : end_index + 1]), )) if len(lowerCamelCase) >= num_spans: break return nbest_spans_predictions[:num_spans] def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[DPRSpanPrediction]: """simple docstring""" _lowercase : str = [] for start_index, start_score in enumerate(lowerCamelCase): for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]): scores.append(((start_index, start_index + answer_length), start_score + end_score)) _lowercase : Dict = sorted(lowerCamelCase, key=lambda lowerCamelCase: x[1], reverse=lowerCamelCase) _lowercase : List[str] = [] for (start_index, end_index), score in scores: if start_index > end_index: raise ValueError(F'''Wrong span indices: [{start_index}:{end_index}]''') _lowercase : Dict = end_index - start_index + 1 if length > max_answer_length: raise ValueError(F'''Span is too long: {length} > {max_answer_length}''') if any( start_index <= prev_start_index <= prev_end_index <= end_index or prev_start_index <= start_index <= end_index <= prev_end_index for (prev_start_index, prev_end_index) in chosen_span_intervals): continue chosen_span_intervals.append((start_index, end_index)) if len(lowerCamelCase) == top_spans: break return chosen_span_intervals @add_end_docstrings(_a ) class _lowerCamelCase( _a, _a ): lowercase_ : Union[str, Any] = VOCAB_FILES_NAMES lowercase_ : Any = READER_PRETRAINED_VOCAB_FILES_MAP lowercase_ : Dict = READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase_ : Optional[int] = READER_PRETRAINED_INIT_CONFIGURATION lowercase_ : str = ["""input_ids""", """attention_mask"""]
21
0
'''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
def UpperCamelCase_( lowerCamelCase_ ) -> int: if not numbers: return 0 if not isinstance(lowerCamelCase_ , (list, tuple) ) or not all( isinstance(lowerCamelCase_ , lowerCamelCase_ ) for number in numbers ): raise ValueError('numbers must be an iterable of integers' ) _lowercase : int = numbers[0] for i in range(1 , len(lowerCamelCase_ ) ): # update the maximum and minimum subarray products _lowercase : Union[str, Any] = numbers[i] if number < 0: _lowercase , _lowercase : Any = min_till_now, max_till_now _lowercase : Union[str, Any] = max(lowerCamelCase_ , max_till_now * number ) _lowercase : Union[str, Any] = min(lowerCamelCase_ , min_till_now * number ) # update the maximum product found till now _lowercase : Optional[Any] = max(lowerCamelCase_ , lowerCamelCase_ ) return max_prod
21
0
'''simple docstring''' from __future__ import annotations def snake_case_ ( _lowerCAmelCase : int ) -> bool: UpperCAmelCase : Tuple = str(_lowerCAmelCase ) return len(_lowerCAmelCase ) == 9 and set(_lowerCAmelCase ) == set('''123456789''' ) def snake_case_ ( ) -> int | None: for base_num in range(9999 , 4999 , -1 ): UpperCAmelCase : Tuple = 100002 * base_num if is_9_pandigital(_lowerCAmelCase ): return candidate for base_num in range(333 , 99 , -1 ): UpperCAmelCase : Tuple = 1002003 * base_num if is_9_pandigital(_lowerCAmelCase ): return candidate return None if __name__ == "__main__": print(F"{solution() = }")
23
from __future__ import annotations from collections.abc import Iterable, Iterator from dataclasses import dataclass SCREAMING_SNAKE_CASE : Tuple = (3, 9, -11, 0, 7, 5, 1, -1) SCREAMING_SNAKE_CASE : Union[str, Any] = (4, 6, 2, 0, 8, 10, 3, -2) @dataclass class _lowerCamelCase: lowercase_ : int lowercase_ : Node | None class _lowerCamelCase: def __init__( self, lowerCamelCase) -> None: """simple docstring""" _lowercase : Node | None = None for i in sorted(lowerCamelCase, reverse=lowerCamelCase): _lowercase : Tuple = Node(lowerCamelCase, self.head) def __iter__( self) -> Iterator[int]: """simple docstring""" _lowercase : Union[str, Any] = self.head while node: yield node.data _lowercase : int = node.next_node def __len__( self) -> int: """simple docstring""" return sum(1 for _ in self) def __str__( self) -> str: """simple docstring""" return " -> ".join([str(lowerCamelCase) for node in self]) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> SortedLinkedList: return SortedLinkedList(list(lowerCamelCase_ ) + list(lowerCamelCase_ ) ) if __name__ == "__main__": import doctest doctest.testmod() SCREAMING_SNAKE_CASE : int = SortedLinkedList print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))
21
0
from __future__ import annotations import unittest import numpy as np from transformers import BlipTextConfig from transformers.testing_utils import require_tf, slow from transformers.utils import is_tf_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask if is_tf_available(): import tensorflow as tf from transformers import TFBlipTextModel from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST class SCREAMING_SNAKE_CASE__ : def __init__(self : Optional[int] , a__ : Optional[int] , a__ : List[str]=12 , a__ : Dict=7 , a__ : Union[str, Any]=True , a__ : List[str]=True , a__ : List[str]=True , a__ : Any=99 , a__ : int=32 , a__ : Optional[int]=32 , a__ : Optional[Any]=2 , a__ : List[Any]=4 , a__ : int=37 , a__ : List[Any]=0.1 , a__ : List[str]=0.1 , a__ : List[str]=512 , a__ : Dict=0.0_2 , a__ : int=0 , a__ : Tuple=None , ): """simple docstring""" __snake_case = parent __snake_case = batch_size __snake_case = seq_length __snake_case = is_training __snake_case = use_input_mask __snake_case = use_labels __snake_case = vocab_size __snake_case = hidden_size __snake_case = projection_dim __snake_case = num_hidden_layers __snake_case = num_attention_heads __snake_case = intermediate_size __snake_case = dropout __snake_case = attention_dropout __snake_case = max_position_embeddings __snake_case = initializer_range __snake_case = scope __snake_case = bos_token_id def a (self : int ): """simple docstring""" __snake_case = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __snake_case = None if self.use_input_mask: __snake_case = random_attention_mask([self.batch_size, self.seq_length] ) if input_mask is not None: __snake_case = input_mask.numpy() __snake_case , __snake_case = input_mask.shape __snake_case = np.random.randint(1 , seq_length - 1 , size=(batch_size,) ) for batch_idx, start_index in enumerate(a__ ): __snake_case = 1 __snake_case = 0 __snake_case = self.get_config() return config, input_ids, tf.convert_to_tensor(a__ ) def a (self : Any ): """simple docstring""" return BlipTextConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , projection_dim=self.projection_dim , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , dropout=self.dropout , attention_dropout=self.attention_dropout , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , bos_token_id=self.bos_token_id , ) def a (self : Any , a__ : Optional[int] , a__ : Tuple , a__ : List[Any] ): """simple docstring""" __snake_case = TFBlipTextModel(config=a__ ) __snake_case = model(a__ , attention_mask=a__ , training=a__ ) __snake_case = model(a__ , training=a__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def a (self : Dict ): """simple docstring""" __snake_case = self.prepare_config_and_inputs() __snake_case , __snake_case , __snake_case = config_and_inputs __snake_case = {'''input_ids''': input_ids, '''attention_mask''': input_mask} return config, inputs_dict @require_tf class SCREAMING_SNAKE_CASE__ ( _UpperCAmelCase , unittest.TestCase ): A_ : Dict = (TFBlipTextModel,) if is_tf_available() else () A_ : List[Any] = False A_ : List[str] = False A_ : Tuple = False def a (self : List[Any] ): """simple docstring""" __snake_case = BlipTextModelTester(self ) __snake_case = ConfigTester(self , config_class=a__ , hidden_size=37 ) def a (self : str ): """simple docstring""" self.config_tester.run_common_tests() def a (self : Optional[Any] ): """simple docstring""" __snake_case = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*a__ ) def a (self : str ): """simple docstring""" pass def a (self : Any ): """simple docstring""" pass @unittest.skip(reason='''Blip does not use inputs_embeds''' ) def a (self : Union[str, Any] ): """simple docstring""" pass @unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING''' ) def a (self : Any ): """simple docstring""" pass @unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING''' ) def a (self : Union[str, Any] ): """simple docstring""" pass @slow def a (self : List[Any] ): """simple docstring""" for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __snake_case = TFBlipTextModel.from_pretrained(a__ ) self.assertIsNotNone(a__ ) def a (self : Tuple , a__ : List[str]=True ): """simple docstring""" super().test_pt_tf_model_equivalence(allow_missing_keys=a__ )
24
import gc import random import unittest import numpy as np import torch from PIL import Image from transformers import XLMRobertaTokenizerFast from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Any = KandinskyImgaImgPipeline lowercase_ : Union[str, Any] = ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""] lowercase_ : Any = [ """prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds""", """image""", ] lowercase_ : List[Any] = [ """generator""", """height""", """width""", """strength""", """guidance_scale""", """negative_prompt""", """num_inference_steps""", """return_dict""", """guidance_scale""", """num_images_per_prompt""", """output_type""", """return_dict""", ] lowercase_ : Union[str, Any] = False @property def UpperCamelCase ( self) -> str: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> int: """simple docstring""" return 32 @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" return self.time_input_dim @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" return self.time_input_dim * 4 @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" return 1_00 @property def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base') return tokenizer @property def UpperCamelCase ( self) -> int: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = MCLIPConfig( numDims=self.cross_attention_dim, transformerDimensions=self.text_embedder_hidden_size, hidden_size=self.text_embedder_hidden_size, intermediate_size=37, num_attention_heads=4, num_hidden_layers=5, vocab_size=10_05, ) _lowercase : Optional[int] = MultilingualCLIP(lowerCamelCase) _lowercase : List[str] = text_encoder.eval() return text_encoder @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Union[str, Any] = { 'in_channels': 4, # Out channels is double in channels because predicts mean and variance 'out_channels': 8, 'addition_embed_type': 'text_image', 'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'), 'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'), 'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn', 'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2), 'layers_per_block': 1, 'encoder_hid_dim': self.text_embedder_hidden_size, 'encoder_hid_dim_type': 'text_image_proj', 'cross_attention_dim': self.cross_attention_dim, 'attention_head_dim': 4, 'resnet_time_scale_shift': 'scale_shift', 'class_embed_type': None, } _lowercase : Optional[Any] = UNetaDConditionModel(**lowerCamelCase) return model @property def UpperCamelCase ( self) -> str: """simple docstring""" return { "block_out_channels": [32, 64], "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"], "in_channels": 3, "latent_channels": 4, "layers_per_block": 1, "norm_num_groups": 8, "norm_type": "spatial", "num_vq_embeddings": 12, "out_channels": 3, "up_block_types": [ "AttnUpDecoderBlock2D", "UpDecoderBlock2D", ], "vq_embed_dim": 4, } @property def UpperCamelCase ( self) -> List[str]: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = VQModel(**self.dummy_movq_kwargs) return model def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.dummy_text_encoder _lowercase : List[Any] = self.dummy_tokenizer _lowercase : int = self.dummy_unet _lowercase : int = self.dummy_movq _lowercase : Optional[int] = { 'num_train_timesteps': 10_00, 'beta_schedule': 'linear', 'beta_start': 0.0_0_0_8_5, 'beta_end': 0.0_1_2, 'clip_sample': False, 'set_alpha_to_one': False, 'steps_offset': 0, 'prediction_type': 'epsilon', 'thresholding': False, } _lowercase : List[Any] = DDIMScheduler(**lowerCamelCase) _lowercase : List[Any] = { 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'unet': unet, 'scheduler': scheduler, 'movq': movq, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Dict: """simple docstring""" _lowercase : List[str] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[Any] = floats_tensor((1, self.cross_attention_dim), rng=random.Random(seed + 1)).to(lowerCamelCase) # create init_image _lowercase : Tuple = floats_tensor((1, 3, 64, 64), rng=random.Random(lowerCamelCase)).to(lowerCamelCase) _lowercase : Optional[int] = image.cpu().permute(0, 2, 3, 1)[0] _lowercase : Tuple = Image.fromarray(np.uinta(lowerCamelCase)).convert('RGB').resize((2_56, 2_56)) if str(lowerCamelCase).startswith('mps'): _lowercase : List[str] = torch.manual_seed(lowerCamelCase) else: _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'prompt': 'horse', 'image': init_image, 'image_embeds': image_embeds, 'negative_image_embeds': negative_image_embeds, 'generator': generator, 'height': 64, 'width': 64, 'num_inference_steps': 10, 'guidance_scale': 7.0, 'strength': 0.2, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Dict = 'cpu' _lowercase : Tuple = self.get_dummy_components() _lowercase : str = self.pipeline_class(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = pipe(**self.get_dummy_inputs(lowerCamelCase)) _lowercase : Optional[int] = output.images _lowercase : List[Any] = pipe( **self.get_dummy_inputs(lowerCamelCase), return_dict=lowerCamelCase, )[0] _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : List[Any] = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _lowercase : Tuple = np.array( [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]) assert ( np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}''' assert ( np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2 ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}''' @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/kandinsky_img2img_frog.npy') _lowercase : str = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png') _lowercase : Optional[int] = 'A red cartoon frog, 4k' _lowercase : Union[str, Any] = KandinskyPriorPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1-prior', torch_dtype=torch.floataa) pipe_prior.to(lowerCamelCase) _lowercase : Optional[Any] = KandinskyImgaImgPipeline.from_pretrained( 'kandinsky-community/kandinsky-2-1', torch_dtype=torch.floataa) _lowercase : List[Any] = pipeline.to(lowerCamelCase) pipeline.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = torch.Generator(device='cpu').manual_seed(0) _lowercase , _lowercase : List[Any] = pipe_prior( lowerCamelCase, generator=lowerCamelCase, num_inference_steps=5, negative_prompt='', ).to_tuple() _lowercase : Union[str, Any] = pipeline( lowerCamelCase, image=lowerCamelCase, image_embeds=lowerCamelCase, negative_image_embeds=lowerCamelCase, generator=lowerCamelCase, num_inference_steps=1_00, height=7_68, width=7_68, strength=0.2, output_type='np', ) _lowercase : Dict = output.images[0] assert image.shape == (7_68, 7_68, 3) assert_mean_pixel_difference(lowerCamelCase, lowerCamelCase)
21
0
"""simple docstring""" import copy import json import os import tempfile from transformers import is_torch_available from .test_configuration_utils import config_common_kwargs class lowerCAmelCase_ (a__ ): """simple docstring""" def __init__(self , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__=None , SCREAMING_SNAKE_CASE__=True , SCREAMING_SNAKE_CASE__=None , **SCREAMING_SNAKE_CASE__ ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Any = parent SCREAMING_SNAKE_CASE__ : List[Any] = config_class SCREAMING_SNAKE_CASE__ : int = has_text_modality SCREAMING_SNAKE_CASE__ : Optional[Any] = kwargs SCREAMING_SNAKE_CASE__ : Optional[Any] = common_properties def __magic_name__ (self ) -> int: """simple docstring""" SCREAMING_SNAKE_CASE__ : Any = self.config_class(**self.inputs_dict ) SCREAMING_SNAKE_CASE__ : Dict = ( ["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""] if self.common_properties is None else self.common_properties ) # Add common fields for text models if self.has_text_modality: common_properties.extend(["""vocab_size"""] ) # Test that config has the common properties as getters for prop in common_properties: self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) , msg=F'''`{prop}` does not exist''' ) # Test that config has the common properties as setter for idx, name in enumerate(SCREAMING_SNAKE_CASE__ ): try: setattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual( getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ , msg=F'''`{name} value {idx} expected, but was {getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )}''' ) except NotImplementedError: # Some models might not be able to implement setters for common_properties # In that case, a NotImplementedError is raised pass # Test if config class can be called with Config(prop_name=..) for idx, name in enumerate(SCREAMING_SNAKE_CASE__ ): try: SCREAMING_SNAKE_CASE__ : Tuple = self.config_class(**{name: idx} ) self.parent.assertEqual( getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) , SCREAMING_SNAKE_CASE__ , msg=F'''`{name} value {idx} expected, but was {getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ )}''' ) except NotImplementedError: # Some models might not be able to implement setters for common_properties # In that case, a NotImplementedError is raised pass def __magic_name__ (self ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Optional[int] = self.config_class(**self.inputs_dict ) SCREAMING_SNAKE_CASE__ : Any = json.loads(config.to_json_string() ) for key, value in self.inputs_dict.items(): self.parent.assertEqual(obj[key] , SCREAMING_SNAKE_CASE__ ) def __magic_name__ (self ) -> Optional[Any]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Dict = self.config_class(**self.inputs_dict ) with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE__ : Any = os.path.join(SCREAMING_SNAKE_CASE__ , """config.json""" ) config_first.to_json_file(SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : str = self.config_class.from_json_file(SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() ) def __magic_name__ (self ) -> List[str]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Tuple = self.config_class(**self.inputs_dict ) with tempfile.TemporaryDirectory() as tmpdirname: config_first.save_pretrained(SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : Any = self.config_class.from_pretrained(SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() ) def __magic_name__ (self ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Union[str, Any] = self.config_class(**self.inputs_dict ) SCREAMING_SNAKE_CASE__ : Union[str, Any] = """test""" with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE__ : Union[str, Any] = os.path.join(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) config_first.save_pretrained(SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : Any = self.config_class.from_pretrained(SCREAMING_SNAKE_CASE__ , subfolder=SCREAMING_SNAKE_CASE__ ) self.parent.assertEqual(config_second.to_dict() , config_first.to_dict() ) def __magic_name__ (self ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Union[str, Any] = self.config_class(**self.inputs_dict , num_labels=5 ) self.parent.assertEqual(len(config.idalabel ) , 5 ) self.parent.assertEqual(len(config.labelaid ) , 5 ) SCREAMING_SNAKE_CASE__ : Union[str, Any] = 3 self.parent.assertEqual(len(config.idalabel ) , 3 ) self.parent.assertEqual(len(config.labelaid ) , 3 ) def __magic_name__ (self ) -> Any: """simple docstring""" if self.config_class.is_composition: return SCREAMING_SNAKE_CASE__ : str = self.config_class() self.parent.assertIsNotNone(SCREAMING_SNAKE_CASE__ ) def __magic_name__ (self ) -> Union[str, Any]: """simple docstring""" SCREAMING_SNAKE_CASE__ : Optional[Any] = copy.deepcopy(SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : Union[str, Any] = self.config_class(**SCREAMING_SNAKE_CASE__ ) SCREAMING_SNAKE_CASE__ : str = [] for key, value in config_common_kwargs.items(): if key == "torch_dtype": if not is_torch_available(): continue else: import torch if config.torch_dtype != torch.floataa: wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa) ) elif getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) != value: wrong_values.append((key, getattr(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ), value) ) if len(SCREAMING_SNAKE_CASE__ ) > 0: SCREAMING_SNAKE_CASE__ : Union[str, Any] = """\n""".join([F'''- {v[0]}: got {v[1]} instead of {v[2]}''' for v in wrong_values] ) raise ValueError(F'''The following keys were not properly set in the config:\n{errors}''' ) def __magic_name__ (self ) -> Optional[Any]: """simple docstring""" self.create_and_test_config_common_properties() self.create_and_test_config_to_json_string() self.create_and_test_config_to_json_file() self.create_and_test_config_from_and_save_pretrained() self.create_and_test_config_from_and_save_pretrained_subfolder() self.create_and_test_config_with_num_labels() self.check_config_can_be_init_without_params() self.check_config_arguments_init()
25
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) @add_end_docstrings(_a ) class _lowerCamelCase( _a ): def __init__( self, *lowerCamelCase, **lowerCamelCase) -> int: """simple docstring""" super().__init__(*lowerCamelCase, **lowerCamelCase) requires_backends(self, 'vision') self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING) def UpperCamelCase ( self, lowerCamelCase=None) -> int: """simple docstring""" _lowercase : Dict = {} if top_k is not None: _lowercase : List[str] = top_k return {}, {}, postprocess_params def __call__( self, lowerCamelCase, **lowerCamelCase) -> Tuple: """simple docstring""" return super().__call__(lowerCamelCase, **lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = load_image(lowerCamelCase) _lowercase : List[str] = self.image_processor(images=lowerCamelCase, return_tensors=self.framework) return model_inputs def UpperCamelCase ( self, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.model(**lowerCamelCase) return model_outputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=5) -> Dict: """simple docstring""" if top_k > self.model.config.num_labels: _lowercase : List[Any] = self.model.config.num_labels if self.framework == "pt": _lowercase : int = model_outputs.logits.softmax(-1)[0] _lowercase , _lowercase : Union[str, Any] = probs.topk(lowerCamelCase) elif self.framework == "tf": _lowercase : int = stable_softmax(model_outputs.logits, axis=-1)[0] _lowercase : List[Any] = tf.math.top_k(lowerCamelCase, k=lowerCamelCase) _lowercase , _lowercase : Any = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(F'''Unsupported framework: {self.framework}''') _lowercase : str = scores.tolist() _lowercase : str = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase, lowerCamelCase)]
21
0
from __future__ import annotations _snake_case = 1.6021e-19 # units = C def lowerCAmelCase_ ( snake_case_,snake_case_,snake_case_,): if (conductivity, electron_conc, mobility).count(0 ) != 1: raise ValueError("""You cannot supply more or less than 2 values""" ) elif conductivity < 0: raise ValueError("""Conductivity cannot be negative""" ) elif electron_conc < 0: raise ValueError("""Electron concentration cannot be negative""" ) elif mobility < 0: raise ValueError("""mobility cannot be negative""" ) elif conductivity == 0: return ( "conductivity", mobility * electron_conc * ELECTRON_CHARGE, ) elif electron_conc == 0: return ( "electron_conc", conductivity / (mobility * ELECTRON_CHARGE), ) else: return ( "mobility", conductivity / (electron_conc * ELECTRON_CHARGE), ) if __name__ == "__main__": import doctest doctest.testmod()
26
def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> float: _lowercase : Tuple = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff) # formula for sum of series return total def UpperCamelCase_( ) -> Optional[int]: print(sum_of_series(1 , 1 , 10 ) ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
'''simple docstring''' import argparse import torch from torch import nn from transformers import MBartConfig, MBartForConditionalGeneration def lowerCamelCase (_SCREAMING_SNAKE_CASE : int ): __a : Tuple = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', '_float_tensor', 'decoder.output_projection.weight', ] for k in ignore_keys: state_dict.pop(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) def lowerCamelCase (_SCREAMING_SNAKE_CASE : Optional[Any] ): __a , __a : Dict = emb.weight.shape __a : Optional[Any] = nn.Linear(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , bias=_SCREAMING_SNAKE_CASE ) __a : Tuple = emb.weight.data return lin_layer def lowerCamelCase (_SCREAMING_SNAKE_CASE : List[Any] , _SCREAMING_SNAKE_CASE : Union[str, Any]="facebook/mbart-large-en-ro" , _SCREAMING_SNAKE_CASE : int=False , _SCREAMING_SNAKE_CASE : Tuple=False ): __a : Tuple = torch.load(_SCREAMING_SNAKE_CASE , map_location='cpu' )['model'] remove_ignore_keys_(_SCREAMING_SNAKE_CASE ) __a : Optional[Any] = state_dict['encoder.embed_tokens.weight'].shape[0] __a : int = MBartConfig.from_pretrained(_SCREAMING_SNAKE_CASE , vocab_size=_SCREAMING_SNAKE_CASE ) if mbart_aa and finetuned: __a : Union[str, Any] = 'relu' __a : Tuple = state_dict['decoder.embed_tokens.weight'] __a : Union[str, Any] = MBartForConditionalGeneration(_SCREAMING_SNAKE_CASE ) model.model.load_state_dict(_SCREAMING_SNAKE_CASE ) if finetuned: __a : int = make_linear_from_emb(model.model.shared ) return model if __name__ == "__main__": __lowercase : Optional[int] = argparse.ArgumentParser() # Required parameters parser.add_argument( 'fairseq_path', type=str, help='bart.large, bart.large.cnn or a path to a model.pt on local filesystem.' ) parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.') parser.add_argument( '--hf_config', default='facebook/mbart-large-cc25', type=str, help='Which huggingface architecture to use: mbart-large', ) parser.add_argument('--mbart_50', action='store_true', help='whether the model is mMART-50 checkpoint') parser.add_argument('--finetuned', action='store_true', help='whether the model is a fine-tuned checkpoint') __lowercase : Any = parser.parse_args() __lowercase : int = convert_fairseq_mbart_checkpoint_from_disk( args.fairseq_path, hf_config_path=args.hf_config, finetuned=args.finetuned, mbart_aa=args.mbart_aa ) model.save_pretrained(args.pytorch_dump_folder_path)
27
import unittest from transformers import SqueezeBertConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, SqueezeBertModel, ) class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=7, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=True, lowerCamelCase=99, lowerCamelCase=32, lowerCamelCase=5, lowerCamelCase=4, lowerCamelCase=64, lowerCamelCase="gelu", lowerCamelCase=0.1, lowerCamelCase=0.1, lowerCamelCase=5_12, lowerCamelCase=16, lowerCamelCase=2, lowerCamelCase=0.0_2, lowerCamelCase=3, lowerCamelCase=4, lowerCamelCase=None, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=2, lowerCamelCase=4, lowerCamelCase=1, ) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = parent _lowercase : Optional[Any] = batch_size _lowercase : Any = seq_length _lowercase : Optional[Any] = is_training _lowercase : Optional[Any] = use_input_mask _lowercase : List[Any] = use_token_type_ids _lowercase : List[str] = use_labels _lowercase : str = vocab_size _lowercase : List[str] = hidden_size _lowercase : Dict = num_hidden_layers _lowercase : List[str] = num_attention_heads _lowercase : int = intermediate_size _lowercase : Union[str, Any] = hidden_act _lowercase : int = hidden_dropout_prob _lowercase : List[Any] = attention_probs_dropout_prob _lowercase : Dict = max_position_embeddings _lowercase : Union[str, Any] = type_vocab_size _lowercase : List[Any] = type_sequence_label_size _lowercase : Any = initializer_range _lowercase : List[str] = num_labels _lowercase : Any = num_choices _lowercase : Tuple = scope _lowercase : Optional[Any] = q_groups _lowercase : List[str] = k_groups _lowercase : Optional[int] = v_groups _lowercase : List[str] = post_attention_groups _lowercase : Union[str, Any] = intermediate_groups _lowercase : int = output_groups def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.vocab_size) _lowercase : Any = None if self.use_input_mask: _lowercase : Tuple = random_attention_mask([self.batch_size, self.seq_length]) _lowercase : Dict = None _lowercase : int = None _lowercase : List[Any] = None if self.use_labels: _lowercase : List[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size) _lowercase : int = ids_tensor([self.batch_size, self.seq_length], self.num_labels) _lowercase : Dict = ids_tensor([self.batch_size], self.num_choices) _lowercase : Optional[Any] = self.get_config() return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" return SqueezeBertConfig( embedding_size=self.hidden_size, 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, attention_probs_dropout_prob=self.hidden_dropout_prob, attention_dropout=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, initializer_range=self.initializer_range, q_groups=self.q_groups, k_groups=self.k_groups, v_groups=self.v_groups, post_attention_groups=self.post_attention_groups, intermediate_groups=self.intermediate_groups, output_groups=self.output_groups, ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : List[str] = SqueezeBertModel(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = model(lowerCamelCase, lowerCamelCase) _lowercase : Any = model(lowerCamelCase) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> int: """simple docstring""" _lowercase : Dict = SqueezeBertForMaskedLM(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Optional[Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.vocab_size)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForQuestionAnswering(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : List[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, start_positions=lowerCamelCase, end_positions=lowerCamelCase) self.parent.assertEqual(result.start_logits.shape, (self.batch_size, self.seq_length)) self.parent.assertEqual(result.end_logits.shape, (self.batch_size, self.seq_length)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> str: """simple docstring""" _lowercase : Optional[Any] = self.num_labels _lowercase : int = SqueezeBertForSequenceClassification(lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Any = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = self.num_labels _lowercase : List[str] = SqueezeBertForTokenClassification(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Union[str, Any] = model(lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.seq_length, self.num_labels)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = self.num_choices _lowercase : str = SqueezeBertForMultipleChoice(config=lowerCamelCase) model.to(lowerCamelCase) model.eval() _lowercase : Dict = input_ids.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : int = input_mask.unsqueeze(1).expand(-1, self.num_choices, -1).contiguous() _lowercase : Optional[Any] = model( lowerCamelCase, attention_mask=lowerCamelCase, labels=lowerCamelCase, ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_choices)) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() ((_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase) , (_lowercase)) : Dict = config_and_inputs _lowercase : Tuple = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _lowerCamelCase( _a, _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ( ( SqueezeBertModel, SqueezeBertForMaskedLM, SqueezeBertForMultipleChoice, SqueezeBertForQuestionAnswering, SqueezeBertForSequenceClassification, SqueezeBertForTokenClassification, ) if is_torch_available() else None ) lowercase_ : Optional[int] = ( { """feature-extraction""": SqueezeBertModel, """fill-mask""": SqueezeBertForMaskedLM, """question-answering""": SqueezeBertForQuestionAnswering, """text-classification""": SqueezeBertForSequenceClassification, """token-classification""": SqueezeBertForTokenClassification, """zero-shot""": SqueezeBertForSequenceClassification, } if is_torch_available() else {} ) lowercase_ : Tuple = False lowercase_ : List[str] = True lowercase_ : int = False def UpperCamelCase ( self) -> int: """simple docstring""" _lowercase : str = SqueezeBertModelTester(self) _lowercase : Dict = ConfigTester(self, config_class=lowerCamelCase, dim=37) def UpperCamelCase ( self) -> List[str]: """simple docstring""" self.config_tester.run_common_tests() def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_model(*lowerCamelCase) def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_question_answering(*lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_token_classification(*lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowerCamelCase) @slow def UpperCamelCase ( self) -> Dict: """simple docstring""" for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : List[Any] = SqueezeBertModel.from_pretrained(lowerCamelCase) self.assertIsNotNone(lowerCamelCase) @require_sentencepiece @require_tokenizers @require_torch class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Union[str, Any] = SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli') _lowercase : Optional[int] = torch.tensor([[1, 2_94_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 13, 15_88, 2]]) _lowercase : List[str] = model(lowerCamelCase)[0] _lowercase : Union[str, Any] = torch.Size((1, 3)) self.assertEqual(output.shape, lowerCamelCase) _lowercase : Tuple = torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]) self.assertTrue(torch.allclose(lowerCamelCase, lowerCamelCase, atol=1E-4))
21
0
'''simple docstring''' from timeit import timeit _lowerCamelCase : List[str] = { "MALAYALAM": True, "String": False, "rotor": True, "level": True, "A": True, "BB": True, "ABC": False, "amanaplanacanalpanama": True, # "a man a plan a canal panama" } # Ensure our test data is valid assert all((key == key[::-1]) is value for key, value in test_data.items()) def __lowerCamelCase ( A__ ) -> bool: """simple docstring""" UpperCamelCase = 0 UpperCamelCase = len(A__ ) - 1 while start_i < end_i: if s[start_i] == s[end_i]: start_i += 1 end_i -= 1 else: return False return True def __lowerCamelCase ( A__ ) -> bool: """simple docstring""" UpperCamelCase = len(A__ ) // 2 UpperCamelCase = len(A__ ) # We need to traverse till half of the length of string # as we can get access of the i'th last element from # i'th index. # eg: [0,1,2,3,4,5] => 4th index can be accessed # with the help of 1st index (i==n-i-1) # where n is length of string return all(s[i] == s[n - i - 1] for i in range(A__ ) ) def __lowerCamelCase ( A__ ) -> bool: """simple docstring""" if len(A__ ) <= 2: return True if s[0] == s[len(A__ ) - 1]: return is_palindrome_recursive(s[1:-1] ) else: return False def __lowerCamelCase ( A__ ) -> bool: """simple docstring""" return s == s[::-1] def __lowerCamelCase ( A__ ) -> None: """simple docstring""" UpperCamelCase = F"""all({name}(key) is value for key, value in test_data.items())""" UpperCamelCase = F"""from __main__ import test_data, {name}""" UpperCamelCase = 500_000 UpperCamelCase = timeit(stmt=A__ , setup=A__ , number=A__ ) print(F"""{name:<35} finished {number:,} runs in {result:.5f} seconds""" ) if __name__ == "__main__": for key, value in test_data.items(): assert is_palindrome(key) is is_palindrome_recursive(key) assert is_palindrome(key) is is_palindrome_slice(key) print(f'''{key:21} {value}''') print("a man a plan a canal panama") # finished 500,000 runs in 0.46793 seconds benchmark_function("is_palindrome_slice") # finished 500,000 runs in 0.85234 seconds benchmark_function("is_palindrome") # finished 500,000 runs in 1.32028 seconds benchmark_function("is_palindrome_recursive") # finished 500,000 runs in 2.08679 seconds benchmark_function("is_palindrome_traversal")
28
import unittest from transformers import JukeboxTokenizer from transformers.testing_utils import require_torch class _lowerCamelCase( unittest.TestCase ): lowercase_ : Dict = JukeboxTokenizer lowercase_ : Dict = { """artist""": """Zac Brown Band""", """genres""": """Country""", """lyrics""": """I met a traveller from an antique land, Who said \"Two vast and trunkless legs of stone Stand in the desert. . . . Near them, on the sand, Half sunk a shattered visage lies, whose frown, And wrinkled lip, and sneer of cold command, Tell that its sculptor well those passions read Which yet survive, stamped on these lifeless things, The hand that mocked them, and the heart that fed; And on the pedestal, these words appear: My name is Ozymandias, King of Kings; Look on my Works, ye Mighty, and despair! Nothing beside remains. Round the decay Of that colossal Wreck, boundless and bare The lone and level sands stretch far away """, } @require_torch def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" import torch _lowercase : str = JukeboxTokenizer.from_pretrained('openai/jukebox-1b-lyrics') _lowercase : Optional[Any] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 71_69, 5_07, 9, 76, 39, 31, 46, 76, 27, 76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32, 44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43, 47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35, 30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76, 27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45, 45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46, 41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31, 76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63, 76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39, 64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8, 27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45, 34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45, 27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34, 41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49, 44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64, 76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41, 32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27, 40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46, 45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49, 31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27, 45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78, 76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29, 34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48, 31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41, 40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31, 38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39, 41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76, 27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44, 46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45, 46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49, 41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65, 78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76, 40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33, 76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76, 76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76, 41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64, 76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76, 27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67, 78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46, 34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76, 44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47, 40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76, 46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27, 38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47, 40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28, 27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30, 76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45, 76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44, 76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76, 76, 76]]), torch.tensor([[0, 0, 0, 10_69, 11]]), torch.tensor([[0, 0, 0, 10_69, 11]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2])) @require_torch def UpperCamelCase ( self) -> int: """simple docstring""" import torch _lowercase : List[str] = JukeboxTokenizer.from_pretrained('openai/jukebox-5b-lyrics') _lowercase : List[str] = tokenizer(**self.metas)['input_ids'] # fmt: off _lowercase : Optional[int] = [ torch.tensor([[ 0, 0, 0, 10_69, 11, -1, -1, -1, -1, 9, 77, 39, 31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38, 31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27, 40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41, 77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48, 27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40, 37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41, 32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40, 77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63, 77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77, 46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31, 77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37, 77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30, 77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45, 64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49, 40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77, 38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31, 31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29, 41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27, 46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46, 41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45, 31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44, 31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47, 44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42, 31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77, 38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35, 40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34, 27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34, 31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77, 34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32, 31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42, 31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31, 45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42, 31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77, 77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77, 15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77, 11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33, 45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12, 41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41, 44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34, 46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42, 27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77, 77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45, 35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63, 77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30, 31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38, 41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64, 77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27, 40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77, 77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31, 77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45, 27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34, 77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77, 77]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), torch.tensor([[0, 0, 0, 10_69, 11, -1, -1, -1, -1]]), ] # fmt: on self.assertTrue(torch.allclose(tokens[0], EXPECTED_OUTPUT[0])) self.assertTrue(torch.allclose(tokens[1], EXPECTED_OUTPUT[1])) self.assertTrue(torch.allclose(tokens[2], EXPECTED_OUTPUT[2]))
21
0
import logging import sys from dataclasses import dataclass, field from typing import Any, Dict, List, Optional, Union import librosa import torch from datasets import DatasetDict, load_dataset from packaging import version from torch import nn from transformers import ( HfArgumentParser, Trainer, TrainingArguments, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaForPreTraining, is_apex_available, trainer_utils, ) from transformers.models.wavaveca.modeling_wavaveca import _compute_mask_indices if is_apex_available(): from apex import amp if version.parse(version.parse(torch.__version__).base_version) >= version.parse('1.6'): __UpperCAmelCase = True from torch.cuda.amp import autocast __UpperCAmelCase = logging.getLogger(__name__) @dataclass class lowerCamelCase : '''simple docstring''' _snake_case : str = field( metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} ) _snake_case : Optional[str] = field( default=_snake_case , metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} , ) _snake_case : Optional[bool] = field( default=_snake_case , metadata={'''help''': '''Whether to freeze the feature extractor layers of the model.'''} ) _snake_case : Optional[bool] = field( default=_snake_case , metadata={'''help''': '''Whether to log verbose messages or not.'''} , ) _snake_case : Optional[float] = field( default=2.0 , metadata={'''help''': '''Maximum temperature for gumbel softmax.'''} ) _snake_case : Optional[float] = field( default=0.5 , metadata={'''help''': '''Minimum temperature for gumbel softmax.'''} ) _snake_case : Optional[float] = field( default=0.999995 , metadata={'''help''': '''Decay of gumbel temperature during training.'''} ) def lowercase__ ( __snake_case : ModelArguments , __snake_case : TrainingArguments ): '''simple docstring''' logging.basicConfig( format='%(asctime)s - %(levelname)s - %(name)s - %(message)s' , datefmt='%m/%d/%Y %H:%M:%S' , handlers=[logging.StreamHandler(sys.stdout )] , ) UpperCAmelCase_ : List[str] = logging.WARNING if model_args.verbose_logging: UpperCAmelCase_ : Any = logging.DEBUG elif trainer_utils.is_main_process(training_args.local_rank ): UpperCAmelCase_ : Any = logging.INFO logger.setLevel(__snake_case ) @dataclass class lowerCamelCase : '''simple docstring''' _snake_case : str = field( default=_snake_case , metadata={'''help''': '''The name of the dataset to use (via the datasets library).'''} ) _snake_case : Optional[str] = field( default=_snake_case , metadata={'''help''': '''The configuration name of the dataset to use (via the datasets library).'''} ) _snake_case : Optional[str] = field( default='''train''' , metadata={ '''help''': '''The name of the training data set split to use (via the datasets library). Defaults to \'train\'''' } , ) _snake_case : Optional[str] = field( default='''validation''' , metadata={ '''help''': ( '''The name of the validation data set split to use (via the datasets library). Defaults to \'validation\'''' ) } , ) _snake_case : Optional[str] = field( default='''file''' , metadata={'''help''': '''Column in the dataset that contains speech file path. Defaults to \'file\''''} , ) _snake_case : bool = field( default=_snake_case , metadata={'''help''': '''Overwrite the cached preprocessed datasets or not.'''} ) _snake_case : Optional[int] = field( default=1 , metadata={ '''help''': '''The percentage of the train set used as validation set in case there\'s no validation split''' } , ) _snake_case : Optional[int] = field( default=_snake_case , metadata={'''help''': '''The number of processes to use for the preprocessing.'''} , ) _snake_case : Optional[float] = field( default=20.0 , metadata={'''help''': '''Filter audio files that are longer than `max_duration_in_seconds` seconds'''} ) @dataclass class lowerCamelCase : '''simple docstring''' _snake_case : WavaVecaForPreTraining _snake_case : WavaVecaFeatureExtractor _snake_case : Union[bool, str] = "longest" _snake_case : Optional[int] = None _snake_case : Optional[int] = None def __call__( self , _UpperCamelCase ) -> Dict[str, torch.Tensor]: # reformat list to dict and set to pytorch format UpperCAmelCase_ : int = self.feature_extractor.pad( _UpperCamelCase , max_length=self.max_length , padding=self.padding , pad_to_multiple_of=self.pad_to_multiple_of , return_tensors='pt' , ) UpperCAmelCase_ : Any = self.model._get_feat_extract_output_lengths(batch['input_values'].shape[-1] ) UpperCAmelCase_ : Union[str, Any] = batch['input_values'].shape[0] # make sure that no loss is computed on padded inputs if batch["attention_mask"] is not None: # compute real output lengths according to convolution formula UpperCAmelCase_ : Tuple = self.model._get_feat_extract_output_lengths(batch['attention_mask'].sum(-1 ) ).to( torch.long ) UpperCAmelCase_ : str = torch.zeros( (batch_size, mask_indices_seq_length) , dtype=torch.long , device=batch['input_values'].device ) # these two operations makes sure that all values # before the output lengths indices are attended to UpperCAmelCase_ : Union[str, Any] = 1 UpperCAmelCase_ : Dict = attention_mask.flip([-1] ).cumsum(-1 ).flip([-1] ).bool() # sample randomly masked indices UpperCAmelCase_ : int = _compute_mask_indices( (batch_size, mask_indices_seq_length) , self.model.config.mask_time_prob , self.model.config.mask_time_length , attention_mask=_UpperCamelCase , min_masks=2 , ) return batch class lowerCamelCase (_snake_case ): '''simple docstring''' def __init__( self , *_UpperCamelCase , _UpperCamelCase=1 , _UpperCamelCase=0 , _UpperCamelCase=1.0 , **_UpperCamelCase ) -> Dict: super().__init__(*_UpperCamelCase , **_UpperCamelCase ) UpperCAmelCase_ : List[Any] = 0 UpperCAmelCase_ : Any = max_gumbel_temp UpperCAmelCase_ : int = min_gumbel_temp UpperCAmelCase_ : Dict = gumbel_temp_decay def __UpperCAmelCase ( self , _UpperCamelCase , _UpperCamelCase ) -> torch.Tensor: model.train() UpperCAmelCase_ : int = self._prepare_inputs(_UpperCamelCase ) if self.use_amp: with autocast(): UpperCAmelCase_ : Union[str, Any] = self.compute_loss(_UpperCamelCase , _UpperCamelCase ) else: UpperCAmelCase_ : Any = self.compute_loss(_UpperCamelCase , _UpperCamelCase ) if self.args.n_gpu > 1 or self.deepspeed: if model.module.config.ctc_loss_reduction == "mean": UpperCAmelCase_ : List[Any] = loss.mean() elif model.module.config.ctc_loss_reduction == "sum": UpperCAmelCase_ : Optional[Any] = loss.sum() / (inputs['mask_time_indices']).sum() else: raise ValueError(f"{model.config.ctc_loss_reduction} is not valid. Choose one of ['mean', 'sum']" ) if self.args.gradient_accumulation_steps > 1: UpperCAmelCase_ : int = loss / self.args.gradient_accumulation_steps if self.use_amp: self.scaler.scale(_UpperCamelCase ).backward() elif self.use_apex: with amp.scale_loss(_UpperCamelCase , self.optimizer ) as scaled_loss: scaled_loss.backward() elif self.deepspeed: self.deepspeed.backward(_UpperCamelCase ) else: loss.backward() self.num_update_step += 1 # make sure gumbel softmax temperature is decayed if self.args.n_gpu > 1 or self.deepspeed: model.module.set_gumbel_temperature( max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) ) else: model.set_gumbel_temperature( max(self.max_gumbel_temp * self.gumbel_temp_decay**self.num_update_step , self.min_gumbel_temp ) ) return loss.detach() def lowercase__ ( ): '''simple docstring''' UpperCAmelCase_ : Union[str, Any] = HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments) ) UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = parser.parse_args_into_dataclasses() configure_logger(__snake_case , __snake_case ) # Downloading and loading a dataset from the hub. UpperCAmelCase_ : Optional[Any] = load_dataset(data_args.dataset_name , data_args.dataset_config_name , cache_dir=model_args.cache_dir ) if "validation" not in datasets.keys(): # make sure only "validation" and "train" keys remain" UpperCAmelCase_ : Tuple = DatasetDict() UpperCAmelCase_ : List[Any] = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=F"{data_args.train_split_name}[:{data_args.validation_split_percentage}%]" , cache_dir=model_args.cache_dir , ) UpperCAmelCase_ : Any = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=F"{data_args.train_split_name}[{data_args.validation_split_percentage}%:]" , cache_dir=model_args.cache_dir , ) else: # make sure only "validation" and "train" keys remain" UpperCAmelCase_ : Optional[int] = DatasetDict() UpperCAmelCase_ : List[Any] = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split='validation' , cache_dir=model_args.cache_dir , ) UpperCAmelCase_ : Union[str, Any] = load_dataset( data_args.dataset_name , data_args.dataset_config_name , split=F"{data_args.train_split_name}" , cache_dir=model_args.cache_dir , ) # only normalized-inputs-training is supported UpperCAmelCase_ : int = WavaVecaFeatureExtractor.from_pretrained( model_args.model_name_or_path , cache_dir=model_args.cache_dir , do_normalize=__snake_case ) def prepare_dataset(__snake_case : Dict ): # check that all files have the correct sampling rate UpperCAmelCase_ , UpperCAmelCase_ : Any = librosa.load(batch[data_args.speech_file_column] , sr=feature_extractor.sampling_rate ) return batch # load audio files into numpy arrays UpperCAmelCase_ : List[Any] = datasets.map( __snake_case , num_proc=data_args.preprocessing_num_workers , remove_columns=datasets['train'].column_names ) # filter audio files that are too long UpperCAmelCase_ : str = vectorized_datasets.filter( lambda __snake_case : len(data['speech'] ) < int(data_args.max_duration_in_seconds * feature_extractor.sampling_rate ) ) def normalize(__snake_case : Union[str, Any] ): return feature_extractor(batch['speech'] , sampling_rate=feature_extractor.sampling_rate ) # normalize and transform to `BatchFeatures` UpperCAmelCase_ : Tuple = vectorized_datasets.map( __snake_case , batched=__snake_case , num_proc=data_args.preprocessing_num_workers , load_from_cache_file=not data_args.overwrite_cache , remove_columns=vectorized_datasets['train'].column_names , ) # pretraining is only supported for "newer" stable layer norm architecture # apply_spec_augment has to be True, mask_feature_prob has to be 0.0 UpperCAmelCase_ : Tuple = WavaVecaConfig.from_pretrained( model_args.model_name_or_path , cache_dir=model_args.cache_dir , gradient_checkpointing=training_args.gradient_checkpointing , ) if not config.do_stable_layer_norm or config.feat_extract_norm != "layer": raise ValueError( 'PreTraining is only supported for ``config.do_stable_layer_norm=True`` and' ' ``config.feat_extract_norm=\'layer\'' ) UpperCAmelCase_ : Optional[Any] = WavaVecaForPreTraining(__snake_case ) UpperCAmelCase_ : Optional[int] = DataCollatorForWavaVecaPretraining(model=__snake_case , feature_extractor=__snake_case ) UpperCAmelCase_ : Optional[int] = WavaVecaPreTrainer( model=__snake_case , data_collator=__snake_case , args=__snake_case , train_dataset=vectorized_datasets['train'] , eval_dataset=vectorized_datasets['validation'] , tokenizer=__snake_case , max_gumbel_temp=model_args.max_gumbel_temperature , min_gumbel_temp=model_args.min_gumbel_temperature , gumbel_temp_decay=model_args.gumbel_temperature_decay , ) trainer.train() if __name__ == "__main__": main()
29
import random import unittest import numpy as np import torch from diffusers import ( DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, LMSDiscreteScheduler, OnnxStableDiffusionUpscalePipeline, PNDMScheduler, ) from diffusers.utils import floats_tensor from diffusers.utils.testing_utils import ( is_onnx_available, load_image, nightly, require_onnxruntime, require_torch_gpu, ) from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin if is_onnx_available(): import onnxruntime as ort class _lowerCamelCase( _a, unittest.TestCase ): # TODO: is there an appropriate internal test set? lowercase_ : int = """ssube/stable-diffusion-x4-upscaler-onnx""" def UpperCamelCase ( self, lowerCamelCase=0) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = floats_tensor((1, 3, 1_28, 1_28), rng=random.Random(lowerCamelCase)) _lowercase : Union[str, Any] = torch.manual_seed(lowerCamelCase) _lowercase : Optional[Any] = { 'prompt': 'A painting of a squirrel eating a burger', 'image': image, 'generator': generator, 'num_inference_steps': 3, 'guidance_scale': 7.5, 'output_type': 'numpy', } return inputs def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1].flatten() # started as 128, should now be 512 assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : int = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : str = PNDMScheduler.from_config(pipe.scheduler.config, skip_prk_steps=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[str] = self.get_dummy_inputs() _lowercase : List[Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : int = np.array( [0.6_8_9_8_8_9_2, 0.5_9_2_4_0_5_5_6, 0.5_2_4_9_9_5_2_7, 0.5_8_8_6_6_2_1_5, 0.5_2_2_5_8_2_3_5, 0.5_2_5_7_2_7_1_5, 0.6_2_4_1_4_4_7_3, 0.6_1_7_4_3_8_7, 0.6_2_1_4_9_6_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Optional[int] = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = self.get_dummy_inputs() _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images _lowercase : str = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Optional[int] = np.array( [0.7_6_5_9_2_7_8, 0.7_6_4_3_7_6_6_4, 0.7_5_5_7_9_1_0_7, 0.7_6_9_1_1_1_6, 0.7_7_6_6_6_9_8_6, 0.7_7_2_7_6_7_2, 0.7_7_5_8_6_6_4, 0.7_8_1_2_2_2_6, 0.7_6_9_4_2_5_1_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : List[str] = EulerDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Dict = self.get_dummy_inputs() _lowercase : Optional[Any] = pipe(**lowerCamelCase).images _lowercase : Optional[int] = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.6_9_7_4_7_8_2, 0.6_8_9_0_2_0_9_3, 0.7_0_1_3_5_8_8_5, 0.7_5_8_3_6_1_8, 0.7_8_0_4_5_4_5, 0.7_8_5_4_9_1_2, 0.7_8_6_6_7_4_2_6, 0.7_8_7_4_3_8_6_3, 0.7_8_0_7_0_2_2_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint, provider='CPUExecutionProvider') _lowercase : Any = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs() _lowercase : List[str] = pipe(**lowerCamelCase).images _lowercase : Any = image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.7_7_4_2_4_4_9_6, 0.7_7_3_6_0_1, 0.7_6_4_5_2_8_8, 0.7_7_6_9_5_9_8, 0.7_7_7_2_7_3_9, 0.7_7_3_8_6_8_8, 0.7_8_1_8_7_2_3_3, 0.7_7_8_7_9_5_8_4, 0.7_6_7_0_4_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-1 @nightly @require_onnxruntime @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" return ( "CUDAExecutionProvider", { "gpu_mem_limit": "15000000000", # 15GB "arena_extend_strategy": "kSameAsRequested", }, ) @property def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = ort.SessionOptions() _lowercase : str = False return options def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) # using the PNDM scheduler by default _lowercase : Tuple = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=10, generator=lowerCamelCase, output_type='np', ) _lowercase : List[Any] = output.images _lowercase : List[Any] = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : List[Any] = np.array([0.4_8_8_3, 0.4_9_4_7, 0.4_9_8_0, 0.4_9_7_5, 0.4_9_8_2, 0.4_9_8_0, 0.5_0_0_0, 0.5_0_0_6, 0.4_9_7_2]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : int = init_image.resize((1_28, 1_28)) _lowercase : str = LMSDiscreteScheduler.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', subfolder='scheduler') _lowercase : Dict = OnnxStableDiffusionUpscalePipeline.from_pretrained( 'ssube/stable-diffusion-x4-upscaler-onnx', scheduler=lowerCamelCase, provider=self.gpu_provider, sess_options=self.gpu_options, ) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[int] = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : str = pipe( prompt=lowerCamelCase, image=lowerCamelCase, guidance_scale=7.5, num_inference_steps=20, generator=lowerCamelCase, output_type='np', ) _lowercase : str = output.images _lowercase : str = images[0, 2_55:2_58, 3_83:3_86, -1] assert images.shape == (1, 5_12, 5_12, 3) _lowercase : Union[str, Any] = np.array( [0.5_0_1_7_3_7_5_3, 0.5_0_2_2_3_3_5_6, 0.5_0_2_0_3_9, 0.5_0_2_3_3_0_3_6, 0.5_0_2_3_7_2_5, 0.5_0_2_2_6_0_1, 0.5_0_1_8_7_5_8, 0.5_0_2_3_4_0_8_5, 0.5_0_2_4_1_5_6_6]) # TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2
21
0
import math from enum import Enum from typing import Optional, Union from torch.optim import Optimizer from torch.optim.lr_scheduler import LambdaLR from .utils import logging __a = logging.get_logger(__name__) class lowercase__( UpperCAmelCase ): """simple docstring""" a :Union[str, Any] = 'linear' a :Union[str, Any] = 'cosine' a :List[str] = 'cosine_with_restarts' a :Dict = 'polynomial' a :Tuple = 'constant' a :int = 'constant_with_warmup' a :Union[str, Any] = 'piecewise_constant' def a ( snake_case__: Optimizer , snake_case__: int = -1 ): '''simple docstring''' return LambdaLR(snake_case__ , lambda snake_case__ : 1 , last_epoch=snake_case__ ) def a ( snake_case__: Optimizer , snake_case__: int , snake_case__: int = -1 ): '''simple docstring''' def lr_lambda(snake_case__: int ): if current_step < num_warmup_steps: return float(snake_case__ ) / float(max(1.0 , snake_case__ ) ) return 1.0 return LambdaLR(snake_case__ , snake_case__ , last_epoch=snake_case__ ) def a ( snake_case__: Optimizer , snake_case__: str , snake_case__: int = -1 ): '''simple docstring''' lowercase_ = {} lowercase_ = step_rules.split(''',''' ) for rule_str in rule_list[:-1]: lowercase_ , lowercase_ = rule_str.split(''':''' ) lowercase_ = int(snake_case__ ) lowercase_ = float(snake_case__ ) lowercase_ = value lowercase_ = float(rule_list[-1] ) def create_rules_function(snake_case__: Optional[int] , snake_case__: int ): def rule_func(snake_case__: int ) -> float: lowercase_ = sorted(rules_dict.keys() ) for i, sorted_step in enumerate(snake_case__ ): if steps < sorted_step: return rules_dict[sorted_steps[i]] return last_lr_multiple return rule_func lowercase_ = create_rules_function(snake_case__ , snake_case__ ) return LambdaLR(snake_case__ , snake_case__ , last_epoch=snake_case__ ) def a ( snake_case__: List[str] , snake_case__: List[Any] , snake_case__: Dict , snake_case__: int=-1 ): '''simple docstring''' def lr_lambda(snake_case__: int ): if current_step < num_warmup_steps: return float(snake_case__ ) / float(max(1 , snake_case__ ) ) return max( 0.0 , float(num_training_steps - current_step ) / float(max(1 , num_training_steps - num_warmup_steps ) ) ) return LambdaLR(snake_case__ , snake_case__ , snake_case__ ) def a ( snake_case__: Optimizer , snake_case__: int , snake_case__: int , snake_case__: float = 0.5 , snake_case__: int = -1 ): '''simple docstring''' def lr_lambda(snake_case__: List[Any] ): if current_step < num_warmup_steps: return float(snake_case__ ) / float(max(1 , snake_case__ ) ) lowercase_ = float(current_step - num_warmup_steps ) / float(max(1 , num_training_steps - num_warmup_steps ) ) return max(0.0 , 0.5 * (1.0 + math.cos(math.pi * float(snake_case__ ) * 2.0 * progress )) ) return LambdaLR(snake_case__ , snake_case__ , snake_case__ ) def a ( snake_case__: Optimizer , snake_case__: int , snake_case__: int , snake_case__: int = 1 , snake_case__: int = -1 ): '''simple docstring''' def lr_lambda(snake_case__: Any ): if current_step < num_warmup_steps: return float(snake_case__ ) / float(max(1 , snake_case__ ) ) lowercase_ = float(current_step - num_warmup_steps ) / float(max(1 , num_training_steps - num_warmup_steps ) ) if progress >= 1.0: return 0.0 return max(0.0 , 0.5 * (1.0 + math.cos(math.pi * ((float(snake_case__ ) * progress) % 1.0) )) ) return LambdaLR(snake_case__ , snake_case__ , snake_case__ ) def a ( snake_case__: Dict , snake_case__: Dict , snake_case__: List[str] , snake_case__: Union[str, Any]=1e-7 , snake_case__: Tuple=1.0 , snake_case__: Optional[Any]=-1 ): '''simple docstring''' lowercase_ = optimizer.defaults['''lr'''] if not (lr_init > lr_end): raise ValueError(F'''lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})''' ) def lr_lambda(snake_case__: int ): if current_step < num_warmup_steps: return float(snake_case__ ) / float(max(1 , snake_case__ ) ) elif current_step > num_training_steps: return lr_end / lr_init # as LambdaLR multiplies by lr_init else: lowercase_ = lr_init - lr_end lowercase_ = num_training_steps - num_warmup_steps lowercase_ = 1 - (current_step - num_warmup_steps) / decay_steps lowercase_ = lr_range * pct_remaining**power + lr_end return decay / lr_init # as LambdaLR multiplies by lr_init return LambdaLR(snake_case__ , snake_case__ , snake_case__ ) __a = { SchedulerType.LINEAR: get_linear_schedule_with_warmup, SchedulerType.COSINE: get_cosine_schedule_with_warmup, SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup, SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup, SchedulerType.CONSTANT: get_constant_schedule, SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup, SchedulerType.PIECEWISE_CONSTANT: get_piecewise_constant_schedule, } def a ( snake_case__: Union[str, SchedulerType] , snake_case__: Optimizer , snake_case__: Optional[str] = None , snake_case__: Optional[int] = None , snake_case__: Optional[int] = None , snake_case__: int = 1 , snake_case__: float = 1.0 , snake_case__: int = -1 , ): '''simple docstring''' lowercase_ = SchedulerType(snake_case__ ) lowercase_ = TYPE_TO_SCHEDULER_FUNCTION[name] if name == SchedulerType.CONSTANT: return schedule_func(snake_case__ , last_epoch=snake_case__ ) if name == SchedulerType.PIECEWISE_CONSTANT: return schedule_func(snake_case__ , step_rules=snake_case__ , last_epoch=snake_case__ ) # All other schedulers require `num_warmup_steps` if num_warmup_steps is None: raise ValueError(F'''{name} requires `num_warmup_steps`, please provide that argument.''' ) if name == SchedulerType.CONSTANT_WITH_WARMUP: return schedule_func(snake_case__ , num_warmup_steps=snake_case__ , last_epoch=snake_case__ ) # All other schedulers require `num_training_steps` if num_training_steps is None: raise ValueError(F'''{name} requires `num_training_steps`, please provide that argument.''' ) if name == SchedulerType.COSINE_WITH_RESTARTS: return schedule_func( snake_case__ , num_warmup_steps=snake_case__ , num_training_steps=snake_case__ , num_cycles=snake_case__ , last_epoch=snake_case__ , ) if name == SchedulerType.POLYNOMIAL: return schedule_func( snake_case__ , num_warmup_steps=snake_case__ , num_training_steps=snake_case__ , power=snake_case__ , last_epoch=snake_case__ , ) return schedule_func( snake_case__ , num_warmup_steps=snake_case__ , num_training_steps=snake_case__ , last_epoch=snake_case__ )
30
import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : Optional[Any] = 1 _lowercase : Any = 3 _lowercase : Tuple = (32, 32) _lowercase : Tuple = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(lowerCamelCase) return image @property def UpperCamelCase ( self) -> str: """simple docstring""" torch.manual_seed(0) _lowercase : Dict = UNetaDConditionModel( block_out_channels=(32, 64), layers_per_block=2, sample_size=32, in_channels=4, out_channels=4, down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'), up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'), cross_attention_dim=32, ) return model @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : str = AutoencoderKL( block_out_channels=[32, 64], in_channels=3, out_channels=3, down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'], up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'], latent_channels=4, ) return model @property def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" torch.manual_seed(0) _lowercase : Optional[int] = RobertaSeriesConfig( hidden_size=32, project_dim=32, intermediate_size=37, layer_norm_eps=1E-05, num_attention_heads=4, num_hidden_layers=5, pad_token_id=1, vocab_size=50_06, ) return RobertaSeriesModelWithTransformation(lowerCamelCase) @property def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" def extract(*lowerCamelCase, **lowerCamelCase): class _lowerCamelCase: def __init__( self) -> Optional[Any]: """simple docstring""" _lowercase : Optional[int] = torch.ones([0]) def UpperCamelCase ( self, lowerCamelCase) -> int: """simple docstring""" self.pixel_values.to(lowerCamelCase) return self return Out() return extract def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Any = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Union[str, Any] = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : Optional[Any] = self.dummy_vae _lowercase : List[Any] = self.dummy_text_encoder _lowercase : Any = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Tuple = 77 _lowercase : int = self.dummy_image.to(lowerCamelCase) _lowercase : int = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[Any] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Optional[int] = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = 'A painting of a squirrel eating a burger' _lowercase : Dict = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Any = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, ) _lowercase : Optional[int] = output.images _lowercase : Optional[Any] = torch.Generator(device=lowerCamelCase).manual_seed(0) _lowercase : Optional[Any] = alt_pipe( [prompt], generator=lowerCamelCase, guidance_scale=6.0, num_inference_steps=2, output_type='np', image=lowerCamelCase, return_dict=lowerCamelCase, )[0] _lowercase : Optional[int] = image[0, -3:, -3:, -1] _lowercase : Dict = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _lowercase : int = np.array([0.4_4_2_7, 0.3_7_3_1, 0.4_2_4_9, 0.4_9_4_1, 0.4_5_4_6, 0.4_1_4_8, 0.4_1_9_3, 0.4_6_6_6, 0.4_4_9_9]) assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3 @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = self.dummy_cond_unet _lowercase : Tuple = PNDMScheduler(skip_prk_steps=lowerCamelCase) _lowercase : str = self.dummy_vae _lowercase : Optional[Any] = self.dummy_text_encoder _lowercase : Optional[Any] = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta') _lowercase : Optional[Any] = 77 _lowercase : str = self.dummy_image.to(lowerCamelCase) # put models in fp16 _lowercase : List[str] = unet.half() _lowercase : List[Any] = vae.half() _lowercase : Any = bert.half() # make sure here that pndm scheduler skips prk _lowercase : Union[str, Any] = AltDiffusionImgaImgPipeline( unet=lowerCamelCase, scheduler=lowerCamelCase, vae=lowerCamelCase, text_encoder=lowerCamelCase, tokenizer=lowerCamelCase, safety_checker=lowerCamelCase, feature_extractor=self.dummy_extractor, ) _lowercase : List[str] = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor, do_normalize=lowerCamelCase) _lowercase : Any = alt_pipe.to(lowerCamelCase) alt_pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : int = 'A painting of a squirrel eating a burger' _lowercase : Optional[Any] = torch.manual_seed(0) _lowercase : Union[str, Any] = alt_pipe( [prompt], generator=lowerCamelCase, num_inference_steps=2, output_type='np', image=lowerCamelCase, ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != 'cuda', 'This test requires a GPU') def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : int = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') # resize to resolution that is divisible by 8 but not 16 or 32 _lowercase : str = init_image.resize((7_60, 5_04)) _lowercase : Optional[int] = 'BAAI/AltDiffusion' _lowercase : str = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : List[str] = 'A fantasy landscape, trending on artstation' _lowercase : Any = torch.manual_seed(0) _lowercase : Dict = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : List[str] = output.images[0] _lowercase : Tuple = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) _lowercase : Optional[Any] = np.array([0.9_3_5_8, 0.9_3_9_7, 0.9_5_9_9, 0.9_9_0_1, 1.0_0_0_0, 1.0_0_0_0, 0.9_8_8_2, 1.0_0_0_0, 1.0_0_0_0]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Optional[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Union[str, Any] = load_image( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/img2img/sketch-mountains-input.jpg') _lowercase : str = init_image.resize((7_68, 5_12)) _lowercase : Any = load_numpy( 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy') _lowercase : str = 'BAAI/AltDiffusion' _lowercase : Optional[Any] = AltDiffusionImgaImgPipeline.from_pretrained( lowerCamelCase, safety_checker=lowerCamelCase, ) pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) pipe.enable_attention_slicing() _lowercase : int = 'A fantasy landscape, trending on artstation' _lowercase : List[Any] = torch.manual_seed(0) _lowercase : int = pipe( prompt=lowerCamelCase, image=lowerCamelCase, strength=0.7_5, guidance_scale=7.5, generator=lowerCamelCase, output_type='np', ) _lowercase : Union[str, Any] = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image).max() < 1E-2
21
0
'''simple docstring''' import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() __SCREAMING_SNAKE_CASE : str = logging.get_logger(__name__) def UpperCamelCase_ ( _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Tuple=False , _UpperCAmelCase : Union[str, Any]=False ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase : List[str] = "backbone." if is_semantic else "" _UpperCAmelCase : Tuple = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((F"""{prefix}blocks.{i}.norm1.weight""", F"""beit.encoder.layer.{i}.layernorm_before.weight""") ) rename_keys.append((F"""{prefix}blocks.{i}.norm1.bias""", F"""beit.encoder.layer.{i}.layernorm_before.bias""") ) rename_keys.append( (F"""{prefix}blocks.{i}.attn.proj.weight""", F"""beit.encoder.layer.{i}.attention.output.dense.weight""") ) rename_keys.append( (F"""{prefix}blocks.{i}.attn.proj.bias""", F"""beit.encoder.layer.{i}.attention.output.dense.bias""") ) rename_keys.append((F"""{prefix}blocks.{i}.norm2.weight""", F"""beit.encoder.layer.{i}.layernorm_after.weight""") ) rename_keys.append((F"""{prefix}blocks.{i}.norm2.bias""", F"""beit.encoder.layer.{i}.layernorm_after.bias""") ) rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc1.weight""", F"""beit.encoder.layer.{i}.intermediate.dense.weight""") ) rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc1.bias""", F"""beit.encoder.layer.{i}.intermediate.dense.bias""") ) rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc2.weight""", F"""beit.encoder.layer.{i}.output.dense.weight""") ) rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc2.bias""", F"""beit.encoder.layer.{i}.output.dense.bias""") ) # projection layer + position embeddings rename_keys.extend( [ (F"""{prefix}cls_token""", "beit.embeddings.cls_token"), (F"""{prefix}patch_embed.proj.weight""", "beit.embeddings.patch_embeddings.projection.weight"), (F"""{prefix}patch_embed.proj.bias""", "beit.embeddings.patch_embeddings.projection.bias"), (F"""{prefix}pos_embed""", "beit.embeddings.position_embeddings"), ] ) if has_lm_head: # mask token + layernorm rename_keys.extend( [ ("mask_token", "beit.embeddings.mask_token"), ("norm.weight", "layernorm.weight"), ("norm.bias", "layernorm.bias"), ] ) else: # layernorm + classification head rename_keys.extend( [ ("fc_norm.weight", "beit.pooler.layernorm.weight"), ("fc_norm.bias", "beit.pooler.layernorm.bias"), ("head.weight", "classifier.weight"), ("head.bias", "classifier.bias"), ] ) return rename_keys def UpperCamelCase_ ( _UpperCAmelCase : List[Any] , _UpperCAmelCase : List[str] , _UpperCAmelCase : List[str]=False , _UpperCAmelCase : List[Any]=False ) -> int: """simple docstring""" for i in range(config.num_hidden_layers ): _UpperCAmelCase : List[str] = "backbone." if is_semantic else "" # queries, keys and values _UpperCAmelCase : int = state_dict.pop(F"""{prefix}blocks.{i}.attn.qkv.weight""" ) _UpperCAmelCase : Dict = state_dict.pop(F"""{prefix}blocks.{i}.attn.q_bias""" ) _UpperCAmelCase : Dict = state_dict.pop(F"""{prefix}blocks.{i}.attn.v_bias""" ) _UpperCAmelCase : Dict = in_proj_weight[ : config.hidden_size, : ] _UpperCAmelCase : Optional[int] = q_bias _UpperCAmelCase : Any = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] _UpperCAmelCase : Any = in_proj_weight[ -config.hidden_size :, : ] _UpperCAmelCase : Dict = v_bias # gamma_1 and gamma_2 # we call them lambda because otherwise they are renamed when using .from_pretrained _UpperCAmelCase : Any = state_dict.pop(F"""{prefix}blocks.{i}.gamma_1""" ) _UpperCAmelCase : Tuple = state_dict.pop(F"""{prefix}blocks.{i}.gamma_2""" ) _UpperCAmelCase : List[Any] = gamma_a _UpperCAmelCase : Any = gamma_a def UpperCamelCase_ ( _UpperCAmelCase : Dict , _UpperCAmelCase : Any , _UpperCAmelCase : List[str] ) -> List[str]: """simple docstring""" _UpperCAmelCase : int = dct.pop(_UpperCAmelCase ) _UpperCAmelCase : Optional[int] = val def UpperCamelCase_ ( ) -> List[str]: """simple docstring""" _UpperCAmelCase : Dict = "http://images.cocodataset.org/val2017/000000039769.jpg" _UpperCAmelCase : List[str] = Image.open(requests.get(_UpperCAmelCase , stream=_UpperCAmelCase ).raw ) return im @torch.no_grad() def UpperCamelCase_ ( _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : str , _UpperCAmelCase : List[Any]=False ) -> Dict: """simple docstring""" _UpperCAmelCase : List[str] = False if "rvlcdip" in checkpoint_url else True _UpperCAmelCase : Tuple = BeitConfig(use_absolute_position_embeddings=_UpperCAmelCase , use_mask_token=_UpperCAmelCase ) # size of the architecture if "large" in checkpoint_url or "dit-l" in checkpoint_url: _UpperCAmelCase : Optional[int] = 1_024 _UpperCAmelCase : Union[str, Any] = 4_096 _UpperCAmelCase : Tuple = 24 _UpperCAmelCase : int = 16 # labels if "rvlcdip" in checkpoint_url: _UpperCAmelCase : int = 16 _UpperCAmelCase : Optional[int] = "huggingface/label-files" _UpperCAmelCase : Dict = "rvlcdip-id2label.json" _UpperCAmelCase : Any = json.load(open(hf_hub_download(_UpperCAmelCase , _UpperCAmelCase , repo_type="dataset" ) , "r" ) ) _UpperCAmelCase : int = {int(_UpperCAmelCase ): v for k, v in idalabel.items()} _UpperCAmelCase : Optional[Any] = idalabel _UpperCAmelCase : int = {v: k for k, v in idalabel.items()} # load state_dict of original model, remove and rename some keys _UpperCAmelCase : Optional[int] = torch.hub.load_state_dict_from_url(_UpperCAmelCase , map_location="cpu" )["model"] _UpperCAmelCase : Tuple = create_rename_keys(_UpperCAmelCase , has_lm_head=_UpperCAmelCase ) for src, dest in rename_keys: rename_key(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) read_in_q_k_v(_UpperCAmelCase , _UpperCAmelCase , has_lm_head=_UpperCAmelCase ) # load HuggingFace model _UpperCAmelCase : Union[str, Any] = BeitForMaskedImageModeling(_UpperCAmelCase ) if has_lm_head else BeitForImageClassification(_UpperCAmelCase ) model.eval() model.load_state_dict(_UpperCAmelCase ) # Check outputs on an image _UpperCAmelCase : int = BeitImageProcessor( size=config.image_size , resample=PILImageResampling.BILINEAR , do_center_crop=_UpperCAmelCase ) _UpperCAmelCase : Union[str, Any] = prepare_img() _UpperCAmelCase : Any = image_processor(images=_UpperCAmelCase , return_tensors="pt" ) _UpperCAmelCase : Optional[int] = encoding["pixel_values"] _UpperCAmelCase : List[str] = model(_UpperCAmelCase ) _UpperCAmelCase : str = outputs.logits # verify logits _UpperCAmelCase : Any = [1, 16] if "rvlcdip" in checkpoint_url else [1, 196, 8_192] assert logits.shape == torch.Size(_UpperCAmelCase ), "Shape of logits not as expected" Path(_UpperCAmelCase ).mkdir(exist_ok=_UpperCAmelCase ) print(F"""Saving model to {pytorch_dump_folder_path}""" ) model.save_pretrained(_UpperCAmelCase ) print(F"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(_UpperCAmelCase ) if push_to_hub: if has_lm_head: _UpperCAmelCase : Optional[int] = "dit-base" if "base" in checkpoint_url else "dit-large" else: _UpperCAmelCase : List[str] = "dit-base-finetuned-rvlcdip" if "dit-b" in checkpoint_url else "dit-large-finetuned-rvlcdip" image_processor.push_to_hub( repo_path_or_name=Path(_UpperCAmelCase , _UpperCAmelCase ) , organization="nielsr" , commit_message="Add image processor" , use_temp_dir=_UpperCAmelCase , ) model.push_to_hub( repo_path_or_name=Path(_UpperCAmelCase , _UpperCAmelCase ) , organization="nielsr" , commit_message="Add model" , use_temp_dir=_UpperCAmelCase , ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE : Optional[Any] = argparse.ArgumentParser() parser.add_argument( """--checkpoint_url""", default="""https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth""", type=str, help="""URL to the original PyTorch checkpoint (.pth file).""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", ) __SCREAMING_SNAKE_CASE : List[str] = parser.parse_args() convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
31
import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING SCREAMING_SNAKE_CASE : int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE : List[str] = { "SenseTime/deformable-detr": "https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json", # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class _lowerCamelCase( _a ): lowercase_ : Dict = """deformable_detr""" lowercase_ : int = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self, lowerCamelCase=True, lowerCamelCase=None, lowerCamelCase=3, lowerCamelCase=3_00, lowerCamelCase=10_24, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=6, lowerCamelCase=10_24, lowerCamelCase=8, lowerCamelCase=0.0, lowerCamelCase=True, lowerCamelCase="relu", lowerCamelCase=2_56, lowerCamelCase=0.1, lowerCamelCase=0.0, lowerCamelCase=0.0, lowerCamelCase=0.0_2, lowerCamelCase=1.0, lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase="sine", lowerCamelCase="resnet50", lowerCamelCase=True, lowerCamelCase=False, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=4, lowerCamelCase=False, lowerCamelCase=3_00, lowerCamelCase=False, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=1, lowerCamelCase=1, lowerCamelCase=5, lowerCamelCase=2, lowerCamelCase=0.1, lowerCamelCase=0.2_5, lowerCamelCase=False, **lowerCamelCase, ) -> Optional[int]: """simple docstring""" if backbone_config is not None and use_timm_backbone: raise ValueError('You can\'t specify both `backbone_config` and `use_timm_backbone`.') if not use_timm_backbone: if backbone_config is None: logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.') _lowercase : List[str] = CONFIG_MAPPING['resnet'](out_features=['stage4']) elif isinstance(lowerCamelCase, lowerCamelCase): _lowercase : List[str] = backbone_config.get('model_type') _lowercase : str = CONFIG_MAPPING[backbone_model_type] _lowercase : Optional[int] = config_class.from_dict(lowerCamelCase) _lowercase : Tuple = use_timm_backbone _lowercase : List[str] = backbone_config _lowercase : Tuple = num_channels _lowercase : Optional[Any] = num_queries _lowercase : Optional[Any] = max_position_embeddings _lowercase : Optional[int] = d_model _lowercase : int = encoder_ffn_dim _lowercase : List[Any] = encoder_layers _lowercase : str = encoder_attention_heads _lowercase : str = decoder_ffn_dim _lowercase : Optional[Any] = decoder_layers _lowercase : List[str] = decoder_attention_heads _lowercase : Optional[int] = dropout _lowercase : Optional[Any] = attention_dropout _lowercase : int = activation_dropout _lowercase : Any = activation_function _lowercase : Optional[int] = init_std _lowercase : int = init_xavier_std _lowercase : Union[str, Any] = encoder_layerdrop _lowercase : Tuple = auxiliary_loss _lowercase : Union[str, Any] = position_embedding_type _lowercase : str = backbone _lowercase : List[Any] = use_pretrained_backbone _lowercase : Any = dilation # deformable attributes _lowercase : Any = num_feature_levels _lowercase : Dict = encoder_n_points _lowercase : Dict = decoder_n_points _lowercase : Dict = two_stage _lowercase : Union[str, Any] = two_stage_num_proposals _lowercase : str = with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('If two_stage is True, with_box_refine must be True.') # Hungarian matcher _lowercase : Tuple = class_cost _lowercase : int = bbox_cost _lowercase : Optional[int] = giou_cost # Loss coefficients _lowercase : Optional[Any] = mask_loss_coefficient _lowercase : Dict = dice_loss_coefficient _lowercase : Tuple = bbox_loss_coefficient _lowercase : Optional[int] = giou_loss_coefficient _lowercase : Union[str, Any] = eos_coefficient _lowercase : Union[str, Any] = focal_alpha _lowercase : Dict = disable_custom_kernels super().__init__(is_encoder_decoder=lowerCamelCase, **lowerCamelCase) @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.encoder_attention_heads @property def UpperCamelCase ( self) -> int: """simple docstring""" return self.d_model def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Union[str, Any] = copy.deepcopy(self.__dict__) if self.backbone_config is not None: _lowercase : Union[str, Any] = self.backbone_config.to_dict() _lowercase : Tuple = self.__class__.model_type return output
21
0
import re import jax.numpy as jnp from flax.traverse_util import flatten_dict, unflatten_dict from jax.random import PRNGKey from ..utils import logging UpperCAmelCase_ : Optional[int] = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE_ ( __A : List[str] ) -> int: """simple docstring""" a_ : Tuple = R'\w+[.]\d+' a_ : List[Any] = re.findall(__A , __A ) for pat in pats: a_ : Union[str, Any] = key.replace(__A , '_'.join(pat.split('.' ) ) ) return key def SCREAMING_SNAKE_CASE_ ( __A : str , __A : Optional[Any] , __A : Optional[Any] ) -> str: """simple docstring""" a_ : Dict = pt_tuple_key[:-1] + ('scale',) if ( any('norm' in str_ for str_ in pt_tuple_key ) and (pt_tuple_key[-1] == "bias") and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict) and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict) ): a_ : Any = pt_tuple_key[:-1] + ('scale',) return renamed_pt_tuple_key, pt_tensor elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict: a_ : Tuple = pt_tuple_key[:-1] + ('scale',) return renamed_pt_tuple_key, pt_tensor # embedding if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict: a_ : List[Any] = pt_tuple_key[:-1] + ('embedding',) return renamed_pt_tuple_key, pt_tensor # conv layer a_ : int = pt_tuple_key[:-1] + ('kernel',) if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4: a_ : Union[str, Any] = pt_tensor.transpose(2 , 3 , 1 , 0 ) return renamed_pt_tuple_key, pt_tensor # linear layer a_ : Any = pt_tuple_key[:-1] + ('kernel',) if pt_tuple_key[-1] == "weight": a_ : Union[str, Any] = pt_tensor.T return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm weight a_ : Optional[Any] = pt_tuple_key[:-1] + ('weight',) if pt_tuple_key[-1] == "gamma": return renamed_pt_tuple_key, pt_tensor # old PyTorch layer norm bias a_ : List[str] = pt_tuple_key[:-1] + ('bias',) if pt_tuple_key[-1] == "beta": return renamed_pt_tuple_key, pt_tensor return pt_tuple_key, pt_tensor def SCREAMING_SNAKE_CASE_ ( __A : Optional[int] , __A : Dict , __A : Any=42 ) -> List[Any]: """simple docstring""" a_ : str = {k: v.numpy() for k, v in pt_state_dict.items()} # Step 2: Since the model is stateless, get random Flax params a_ : int = flax_model.init_weights(PRNGKey(__A ) ) a_ : Tuple = flatten_dict(__A ) a_ : Dict = {} # Need to change some parameters name to match Flax names for pt_key, pt_tensor in pt_state_dict.items(): a_ : Optional[int] = rename_key(__A ) a_ : List[Any] = tuple(renamed_pt_key.split('.' ) ) # Correctly rename weight parameters a_ , a_ : Optional[Any] = rename_key_and_reshape_tensor(__A , __A , __A ) if flax_key in random_flax_state_dict: if flax_tensor.shape != random_flax_state_dict[flax_key].shape: raise ValueError( F"""PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape """ F"""{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.""" ) # also add unexpected weight so that warning is thrown a_ : Optional[int] = jnp.asarray(__A ) return unflatten_dict(__A )
32
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_speech_available, is_tf_available, is_torch_available, ) SCREAMING_SNAKE_CASE : List[str] = { "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"], "processing_speech_to_text": ["Speech2TextProcessor"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Union[str, Any] = ["Speech2TextTokenizer"] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = ["Speech2TextFeatureExtractor"] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = [ "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFSpeech2TextForConditionalGeneration", "TFSpeech2TextModel", "TFSpeech2TextPreTrainedModel", ] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : str = [ "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST", "Speech2TextForConditionalGeneration", "Speech2TextModel", "Speech2TextPreTrainedModel", ] if TYPE_CHECKING: from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig from .processing_speech_to_text import SpeechaTextProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_speech_to_text import SpeechaTextTokenizer try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_speech_to_text import ( TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, TFSpeechaTextForConditionalGeneration, TFSpeechaTextModel, TFSpeechaTextPreTrainedModel, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_speech_to_text import ( SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST, SpeechaTextForConditionalGeneration, SpeechaTextModel, SpeechaTextPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
"""simple docstring""" import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import VivitImageProcessor class _UpperCAmelCase ( unittest.TestCase ): def __init__( self : Any , A : Union[str, Any] , A : Union[str, Any]=7 , A : Dict=3 , A : Any=10 , A : Optional[int]=18 , A : List[str]=30 , A : str=4_00 , A : Any=True , A : Union[str, Any]=None , A : Optional[int]=True , A : List[str]=[0.5, 0.5, 0.5] , A : Union[str, Any]=[0.5, 0.5, 0.5] , A : Tuple=None , ) -> Tuple: lowercase_ : int = size if size is not None else {'''shortest_edge''': 18} lowercase_ : str = crop_size if crop_size is not None else {'''height''': 18, '''width''': 18} lowercase_ : List[Any] = parent lowercase_ : List[Any] = batch_size lowercase_ : Tuple = num_channels lowercase_ : Union[str, Any] = num_frames lowercase_ : Dict = image_size lowercase_ : List[Any] = min_resolution lowercase_ : Dict = max_resolution lowercase_ : Optional[Any] = do_resize lowercase_ : Any = size lowercase_ : Dict = do_normalize lowercase_ : Optional[Any] = image_mean lowercase_ : Optional[Any] = image_std lowercase_ : List[Any] = crop_size def A ( self : List[str] ) -> Tuple: return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, "crop_size": self.crop_size, } @require_torch @require_vision class _UpperCAmelCase ( _A , unittest.TestCase ): SCREAMING_SNAKE_CASE_ : Any = VivitImageProcessor if is_vision_available() else None def A ( self : List[Any] ) -> List[Any]: lowercase_ : Optional[Any] = VivitImageProcessingTester(self ) @property def A ( self : Optional[Any] ) -> Optional[int]: return self.image_processor_tester.prepare_image_processor_dict() def A ( self : Union[str, Any] ) -> Optional[Any]: lowercase_ : Optional[int] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(A , '''image_mean''' ) ) self.assertTrue(hasattr(A , '''image_std''' ) ) self.assertTrue(hasattr(A , '''do_normalize''' ) ) self.assertTrue(hasattr(A , '''do_resize''' ) ) self.assertTrue(hasattr(A , '''do_center_crop''' ) ) self.assertTrue(hasattr(A , '''size''' ) ) def A ( self : List[Any] ) -> List[str]: lowercase_ : Optional[int] = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {'''shortest_edge''': 18} ) self.assertEqual(image_processor.crop_size , {'''height''': 18, '''width''': 18} ) lowercase_ : int = self.image_processing_class.from_dict(self.image_processor_dict , size=42 , crop_size=84 ) self.assertEqual(image_processor.size , {'''shortest_edge''': 42} ) self.assertEqual(image_processor.crop_size , {'''height''': 84, '''width''': 84} ) def A ( self : int ) -> Optional[Any]: # Initialize image_processing lowercase_ : List[str] = self.image_processing_class(**self.image_processor_dict ) # create random PIL videos lowercase_ : List[Any] = prepare_video_inputs(self.image_processor_tester , equal_resolution=A ) for video in video_inputs: self.assertIsInstance(A , A ) self.assertIsInstance(video[0] , Image.Image ) # Test not batched input lowercase_ : Optional[Any] = image_processing(video_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( 1, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , ) # Test batched lowercase_ : Dict = image_processing(A , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , ) def A ( self : int ) -> Optional[int]: # Initialize image_processing lowercase_ : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowercase_ : Optional[Any] = prepare_video_inputs(self.image_processor_tester , equal_resolution=A , numpify=A ) for video in video_inputs: self.assertIsInstance(A , A ) self.assertIsInstance(video[0] , np.ndarray ) # Test not batched input lowercase_ : Any = image_processing(video_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( 1, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , ) # Test batched lowercase_ : List[Any] = image_processing(A , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , ) def A ( self : Tuple ) -> Dict: # Initialize image_processing lowercase_ : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowercase_ : Any = prepare_video_inputs(self.image_processor_tester , equal_resolution=A , torchify=A ) for video in video_inputs: self.assertIsInstance(A , A ) self.assertIsInstance(video[0] , torch.Tensor ) # Test not batched input lowercase_ : Any = image_processing(video_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( 1, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , ) # Test batched lowercase_ : Any = image_processing(A , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_videos.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_frames, self.image_processor_tester.num_channels, self.image_processor_tester.crop_size['''height'''], self.image_processor_tester.crop_size['''width'''], ) , )
33
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: if isinstance(lowerCamelCase_ , torch.Tensor ): return image elif isinstance(lowerCamelCase_ , PIL.Image.Image ): _lowercase : List[Any] = [image] if isinstance(image[0] , PIL.Image.Image ): _lowercase : Tuple = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] _lowercase : str = np.concatenate(lowerCamelCase_ , axis=0 ) _lowercase : Dict = np.array(lowerCamelCase_ ).astype(np.floataa ) / 2_55.0 _lowercase : Optional[int] = image.transpose(0 , 3 , 1 , 2 ) _lowercase : str = 2.0 * image - 1.0 _lowercase : Tuple = torch.from_numpy(lowerCamelCase_ ) elif isinstance(image[0] , torch.Tensor ): _lowercase : Any = torch.cat(lowerCamelCase_ , dim=0 ) return image def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_=0.99_95 ) -> Tuple: if not isinstance(lowerCamelCase_ , np.ndarray ): _lowercase : List[Any] = True _lowercase : Any = va.device _lowercase : Union[str, Any] = va.cpu().numpy() _lowercase : int = va.cpu().numpy() _lowercase : int = np.sum(va * va / (np.linalg.norm(lowerCamelCase_ ) * np.linalg.norm(lowerCamelCase_ )) ) if np.abs(lowerCamelCase_ ) > DOT_THRESHOLD: _lowercase : Any = (1 - t) * va + t * va else: _lowercase : Dict = np.arccos(lowerCamelCase_ ) _lowercase : str = np.sin(lowerCamelCase_ ) _lowercase : int = theta_a * t _lowercase : Dict = np.sin(lowerCamelCase_ ) _lowercase : Any = np.sin(theta_a - theta_t ) / sin_theta_a _lowercase : List[Any] = sin_theta_t / sin_theta_a _lowercase : Dict = sa * va + sa * va if inputs_are_torch: _lowercase : Optional[Any] = torch.from_numpy(lowerCamelCase_ ).to(lowerCamelCase_ ) return va def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> List[Any]: _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) _lowercase : Tuple = F.normalize(lowerCamelCase_ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ ) -> Optional[int]: for param in model.parameters(): _lowercase : Any = value class _lowerCamelCase( _a ): def __init__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=None, lowerCamelCase=None, ) -> Tuple: """simple docstring""" super().__init__() self.register_modules( vae=lowerCamelCase, text_encoder=lowerCamelCase, clip_model=lowerCamelCase, tokenizer=lowerCamelCase, unet=lowerCamelCase, scheduler=lowerCamelCase, feature_extractor=lowerCamelCase, coca_model=lowerCamelCase, coca_tokenizer=lowerCamelCase, coca_transform=lowerCamelCase, ) _lowercase : Tuple = ( feature_extractor.size if isinstance(feature_extractor.size, lowerCamelCase) else feature_extractor.size['shortest_edge'] ) _lowercase : Union[str, Any] = transforms.Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std) set_requires_grad(self.text_encoder, lowerCamelCase) set_requires_grad(self.clip_model, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase = "auto") -> Any: """simple docstring""" if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory _lowercase : Optional[Any] = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" self.enable_attention_slicing(lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" set_requires_grad(self.vae, lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self) -> int: """simple docstring""" set_requires_grad(self.unet, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = min(int(num_inference_steps * strength), lowerCamelCase) _lowercase : List[Any] = max(num_inference_steps - init_timestep, 0) _lowercase : int = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None) -> Optional[Any]: """simple docstring""" if not isinstance(lowerCamelCase, torch.Tensor): raise ValueError(F'''`image` has to be of type `torch.Tensor` but is {type(lowerCamelCase)}''') _lowercase : Any = image.to(device=lowerCamelCase, dtype=lowerCamelCase) if isinstance(lowerCamelCase, lowerCamelCase): _lowercase : Dict = [ self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(lowerCamelCase) ] _lowercase : int = torch.cat(lowerCamelCase, dim=0) else: _lowercase : int = self.vae.encode(lowerCamelCase).latent_dist.sample(lowerCamelCase) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : str = 0.1_8_2_1_5 * init_latents _lowercase : List[str] = init_latents.repeat_interleave(lowerCamelCase, dim=0) _lowercase : List[str] = randn_tensor(init_latents.shape, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) # get latents _lowercase : Any = self.scheduler.add_noise(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : str = init_latents return latents def UpperCamelCase ( self, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : str = self.coca_transform(lowerCamelCase).unsqueeze(0) with torch.no_grad(), torch.cuda.amp.autocast(): _lowercase : List[str] = self.coca_model.generate(transformed_image.to(device=self.device, dtype=self.coca_model.dtype)) _lowercase : int = self.coca_tokenizer.decode(generated[0].cpu().numpy()) return generated.split('<end_of_text>')[0].replace('<start_of_text>', '').rstrip(' .,') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> List[str]: """simple docstring""" _lowercase : Tuple = self.feature_extractor.preprocess(lowerCamelCase) _lowercase : List[str] = torch.from_numpy(clip_image_input['pixel_values'][0]).unsqueeze(0).to(self.device).half() _lowercase : int = self.clip_model.get_image_features(lowerCamelCase) _lowercase : Dict = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : int = image_embeddings_clip.repeat_interleave(lowerCamelCase, dim=0) return image_embeddings_clip @torch.enable_grad() def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) -> List[str]: """simple docstring""" _lowercase : List[Any] = latents.detach().requires_grad_() _lowercase : Union[str, Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Tuple = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample if isinstance(self.scheduler, (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)): _lowercase : Any = self.scheduler.alphas_cumprod[timestep] _lowercase : Any = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf _lowercase : List[Any] = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 _lowercase : List[str] = torch.sqrt(lowerCamelCase) _lowercase : Dict = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler, lowerCamelCase): _lowercase : Dict = self.scheduler.sigmas[index] _lowercase : List[Any] = latents - sigma * noise_pred else: raise ValueError(F'''scheduler type {type(self.scheduler)} not supported''') # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Dict = 1 / 0.1_8_2_1_5 * sample _lowercase : Optional[Any] = self.vae.decode(lowerCamelCase).sample _lowercase : int = (image / 2 + 0.5).clamp(0, 1) _lowercase : Any = transforms.Resize(self.feature_extractor_size)(lowerCamelCase) _lowercase : Optional[Any] = self.normalize(lowerCamelCase).to(latents.dtype) _lowercase : List[str] = self.clip_model.get_image_features(lowerCamelCase) _lowercase : List[Any] = image_embeddings_clip / image_embeddings_clip.norm(p=2, dim=-1, keepdim=lowerCamelCase) _lowercase : Optional[Any] = spherical_dist_loss(lowerCamelCase, lowerCamelCase).mean() * clip_guidance_scale _lowercase : str = -torch.autograd.grad(lowerCamelCase, lowerCamelCase)[0] if isinstance(self.scheduler, lowerCamelCase): _lowercase : Union[str, Any] = latents.detach() + grads * (sigma**2) _lowercase : List[str] = noise_pred_original else: _lowercase : List[Any] = noise_pred_original - torch.sqrt(lowerCamelCase) * grads return noise_pred, latents @torch.no_grad() def __call__( self, lowerCamelCase, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = None, lowerCamelCase = 5_12, lowerCamelCase = 5_12, lowerCamelCase = 0.6, lowerCamelCase = 50, lowerCamelCase = 7.5, lowerCamelCase = 1, lowerCamelCase = 0.0, lowerCamelCase = 1_00, lowerCamelCase = None, lowerCamelCase = "pil", lowerCamelCase = True, lowerCamelCase = 0.8, lowerCamelCase = 0.1, lowerCamelCase = 0.1, ) -> int: """simple docstring""" if isinstance(lowerCamelCase, lowerCamelCase) and len(lowerCamelCase) != batch_size: raise ValueError(F'''You have passed {batch_size} batch_size, but only {len(lowerCamelCase)} generators.''') if height % 8 != 0 or width % 8 != 0: raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.''') if isinstance(lowerCamelCase, torch.Generator) and batch_size > 1: _lowercase : Dict = [generator] + [None] * (batch_size - 1) _lowercase : Optional[int] = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] _lowercase : Optional[int] = [x[0] for x in coca_is_none if x[1]] _lowercase : str = ', '.join(lowerCamelCase) # generate prompts with coca model if prompt is None if content_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Content prompt is None and CoCa [{coca_is_none_str}] is None.''' F'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : List[Any] = self.get_image_description(lowerCamelCase) if style_prompt is None: if len(lowerCamelCase): raise ValueError( F'''Style prompt is None and CoCa [{coca_is_none_str}] is None.''' F''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.''') _lowercase : Dict = self.get_image_description(lowerCamelCase) # get prompt text embeddings for content and style _lowercase : Optional[int] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : Optional[int] = self.text_encoder(content_text_input.input_ids.to(self.device))[0] _lowercase : Union[str, Any] = self.tokenizer( lowerCamelCase, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=lowerCamelCase, return_tensors='pt', ) _lowercase : List[Any] = self.text_encoder(style_text_input.input_ids.to(self.device))[0] _lowercase : Any = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) # duplicate text embeddings for each generation per prompt _lowercase : Dict = text_embeddings.repeat_interleave(lowerCamelCase, dim=0) # set timesteps _lowercase : Dict = 'offset' in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_offset: _lowercase : Any = 1 self.scheduler.set_timesteps(lowerCamelCase, **lowerCamelCase) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device) _lowercase , _lowercase : List[Any] = self.get_timesteps(lowerCamelCase, lowerCamelCase, self.device) _lowercase : str = timesteps[:1].repeat(lowerCamelCase) # Preprocess image _lowercase : str = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : int = preprocess(lowerCamelCase, lowerCamelCase, lowerCamelCase) _lowercase : List[str] = self.prepare_latents( lowerCamelCase, lowerCamelCase, lowerCamelCase, text_embeddings.dtype, self.device, lowerCamelCase) _lowercase : Optional[int] = slerp(lowerCamelCase, lowerCamelCase, lowerCamelCase) if clip_guidance_scale > 0: _lowercase : Optional[int] = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Dict = self.get_clip_image_embeddings(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = slerp( lowerCamelCase, lowerCamelCase, lowerCamelCase) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. _lowercase : Dict = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: _lowercase : Tuple = content_text_input.input_ids.shape[-1] _lowercase : Union[str, Any] = self.tokenizer([''], padding='max_length', max_length=lowerCamelCase, return_tensors='pt') _lowercase : int = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt _lowercase : Union[str, Any] = uncond_embeddings.repeat_interleave(lowerCamelCase, dim=0) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes _lowercase : Optional[Any] = torch.cat([uncond_embeddings, text_embeddings]) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. _lowercase : Tuple = (batch_size, self.unet.config.in_channels, height // 8, width // 8) _lowercase : Optional[int] = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps _lowercase : List[Any] = torch.randn(lowerCamelCase, generator=lowerCamelCase, device='cpu', dtype=lowerCamelCase).to( self.device) else: _lowercase : Any = torch.randn(lowerCamelCase, generator=lowerCamelCase, device=self.device, dtype=lowerCamelCase) else: if latents.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''') _lowercase : Tuple = latents.to(self.device) # scale the initial noise by the standard deviation required by the scheduler _lowercase : List[Any] = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] _lowercase : Dict = 'eta' in set(inspect.signature(self.scheduler.step).parameters.keys()) _lowercase : Optional[Any] = {} if accepts_eta: _lowercase : List[Any] = eta # check if the scheduler accepts generator _lowercase : Dict = 'generator' in set(inspect.signature(self.scheduler.step).parameters.keys()) if accepts_generator: _lowercase : str = generator with self.progress_bar(total=lowerCamelCase): for i, t in enumerate(lowerCamelCase): # expand the latents if we are doing classifier free guidance _lowercase : List[str] = torch.cat([latents] * 2) if do_classifier_free_guidance else latents _lowercase : List[Any] = self.scheduler.scale_model_input(lowerCamelCase, lowerCamelCase) # predict the noise residual _lowercase : Dict = self.unet(lowerCamelCase, lowerCamelCase, encoder_hidden_states=lowerCamelCase).sample # perform classifier free guidance if do_classifier_free_guidance: _lowercase , _lowercase : Optional[Any] = noise_pred.chunk(2) _lowercase : Optional[Any] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: _lowercase : Tuple = ( text_embeddings.chunk(2)[1] if do_classifier_free_guidance else text_embeddings ) _lowercase , _lowercase : List[Any] = self.cond_fn( lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, ) # compute the previous noisy sample x_t -> x_t-1 _lowercase : Optional[Any] = self.scheduler.step(lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor _lowercase : Any = 1 / 0.1_8_2_1_5 * latents _lowercase : List[str] = self.vae.decode(lowerCamelCase).sample _lowercase : Tuple = (image / 2 + 0.5).clamp(0, 1) _lowercase : List[Any] = image.cpu().permute(0, 2, 3, 1).numpy() if output_type == "pil": _lowercase : List[Any] = self.numpy_to_pil(lowerCamelCase) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=lowerCamelCase, nsfw_content_detected=lowerCamelCase)
21
0
'''simple docstring''' import unittest import numpy as np import requests from transformers.testing_utils import require_torch, require_vision from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11 else: A =False if is_vision_available(): from PIL import Image from transformers import PixaStructImageProcessor class _a ( unittest.TestCase ): def __init__( self : Optional[int] , lowercase : Any , lowercase : List[Any]=7 , lowercase : Dict=3 , lowercase : Optional[Any]=18 , lowercase : Dict=30 , lowercase : Optional[int]=400 , lowercase : Union[str, Any]=None , lowercase : List[Any]=True , lowercase : Optional[int]=True , lowercase : List[Any]=None , ): '''simple docstring''' UpperCAmelCase = size if size is not None else {'''height''': 20, '''width''': 20} UpperCAmelCase = parent UpperCAmelCase = batch_size UpperCAmelCase = num_channels UpperCAmelCase = image_size UpperCAmelCase = min_resolution UpperCAmelCase = max_resolution UpperCAmelCase = size UpperCAmelCase = do_normalize UpperCAmelCase = do_convert_rgb UpperCAmelCase = [512, 1_024, 2_048, 4_096] UpperCAmelCase = patch_size if patch_size is not None else {'''height''': 16, '''width''': 16} def A ( self : Optional[Any] ): '''simple docstring''' return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb} def A ( self : List[str] ): '''simple docstring''' UpperCAmelCase = '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg''' UpperCAmelCase = Image.open(requests.get(lowercase , stream=lowercase ).raw ).convert('''RGB''' ) return raw_image @unittest.skipIf( not is_torch_greater_or_equal_than_1_11 , reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`.""" , ) @require_torch @require_vision class _a ( __a , unittest.TestCase ): __a : Optional[Any] = PixaStructImageProcessor if is_vision_available() else None def A ( self : List[str] ): '''simple docstring''' UpperCAmelCase = PixaStructImageProcessingTester(self ) @property def A ( self : Tuple ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def A ( self : Tuple ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(lowercase , '''do_normalize''' ) ) self.assertTrue(hasattr(lowercase , '''do_convert_rgb''' ) ) def A ( self : Any ): '''simple docstring''' UpperCAmelCase = self.image_processor_tester.prepare_dummy_image() UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) UpperCAmelCase = 2_048 UpperCAmelCase = image_processor(lowercase , return_tensors='''pt''' , max_patches=lowercase ) self.assertTrue(torch.allclose(inputs.flattened_patches.mean() , torch.tensor(0.0606 ) , atol=1E-3 , rtol=1E-3 ) ) def A ( self : List[str] ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PIL images UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase ) for image in image_inputs: self.assertIsInstance(lowercase , Image.Image ) # Test not batched input UpperCAmelCase = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched UpperCAmelCase = image_processor( lowercase , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def A ( self : int ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PIL images UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase ) for image in image_inputs: self.assertIsInstance(lowercase , Image.Image ) # Test not batched input UpperCAmelCase = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 UpperCAmelCase = True for max_patch in self.image_processor_tester.max_patches: # Test not batched input with self.assertRaises(lowercase ): UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches UpperCAmelCase = '''Hello''' UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase , header_text=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched UpperCAmelCase = image_processor( lowercase , return_tensors='''pt''' , max_patches=lowercase , header_text=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def A ( self : List[Any] ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase , numpify=lowercase ) for image in image_inputs: self.assertIsInstance(lowercase , np.ndarray ) UpperCAmelCase = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched UpperCAmelCase = image_processor( lowercase , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) def A ( self : List[Any] ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase , torchify=lowercase ) for image in image_inputs: self.assertIsInstance(lowercase , torch.Tensor ) # Test not batched input UpperCAmelCase = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * self.image_processor_tester.num_channels ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched UpperCAmelCase = image_processor( lowercase , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , ) @unittest.skipIf( not is_torch_greater_or_equal_than_1_11 , reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`.""" , ) @require_torch @require_vision class _a ( __a , unittest.TestCase ): __a : Tuple = PixaStructImageProcessor if is_vision_available() else None def A ( self : Dict ): '''simple docstring''' UpperCAmelCase = PixaStructImageProcessingTester(self , num_channels=4 ) UpperCAmelCase = 3 @property def A ( self : int ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def A ( self : List[Any] ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(lowercase , '''do_normalize''' ) ) self.assertTrue(hasattr(lowercase , '''do_convert_rgb''' ) ) def A ( self : List[Any] ): '''simple docstring''' UpperCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PIL images UpperCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=lowercase ) for image in image_inputs: self.assertIsInstance(lowercase , Image.Image ) # Test not batched input UpperCAmelCase = ( (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width''']) * (self.image_processor_tester.num_channels - 1) ) + 2 for max_patch in self.image_processor_tester.max_patches: # Test not batched input UpperCAmelCase = image_processor( image_inputs[0] , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (1, max_patch, expected_hidden_dim) , ) # Test batched UpperCAmelCase = image_processor( lowercase , return_tensors='''pt''' , max_patches=lowercase ).flattened_patches self.assertEqual( encoded_images.shape , (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) , )
34
import gc import unittest import numpy as np import torch from torch.backends.cuda import sdp_kernel from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) from diffusers.utils import randn_tensor, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _lowerCamelCase( _a, unittest.TestCase ): lowercase_ : Union[str, Any] = ConsistencyModelPipeline lowercase_ : Tuple = UNCONDITIONAL_IMAGE_GENERATION_PARAMS lowercase_ : List[str] = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS # Override required_optional_params to remove num_images_per_prompt lowercase_ : List[str] = frozenset( [ """num_inference_steps""", """generator""", """latents""", """output_type""", """return_dict""", """callback""", """callback_steps""", ] ) @property def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet', ) return unet @property def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained( 'diffusers/consistency-models-test', subfolder='test_unet_class_cond', ) return unet def UpperCamelCase ( self, lowerCamelCase=False) -> Dict: """simple docstring""" if class_cond: _lowercase : Union[str, Any] = self.dummy_cond_unet else: _lowercase : Union[str, Any] = self.dummy_uncond_unet # Default to CM multistep sampler _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[Any] = { 'unet': unet, 'scheduler': scheduler, } return components def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase=0) -> Tuple: """simple docstring""" if str(lowerCamelCase).startswith('mps'): _lowercase : str = torch.manual_seed(lowerCamelCase) else: _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : Tuple = { 'batch_size': 1, 'num_inference_steps': None, 'timesteps': [22, 0], 'generator': generator, 'output_type': 'np', } return inputs def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Optional[int] = self.get_dummy_components() _lowercase : str = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Dict = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : int = image[0, -3:, -3:, -1] _lowercase : Dict = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Any: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Any = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : str = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_dummy_inputs(lowerCamelCase) _lowercase : Any = 0 _lowercase : List[str] = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.3_5_7_2, 0.6_2_7_3, 0.4_0_3_1, 0.3_9_6_1, 0.4_3_2_1, 0.5_7_3_0, 0.5_2_6_6, 0.4_7_8_0, 0.5_0_0_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : Optional[int] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Any = self.get_dummy_components() _lowercase : Optional[Any] = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : List[str] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Optional[Any] = self.get_dummy_inputs(lowerCamelCase) _lowercase : Union[str, Any] = 1 _lowercase : Tuple = None _lowercase : Tuple = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Union[str, Any] = 'cpu' # ensure determinism for the device-dependent torch.Generator _lowercase : Dict = self.get_dummy_components(class_cond=lowerCamelCase) _lowercase : Dict = ConsistencyModelPipeline(**lowerCamelCase) _lowercase : Optional[Any] = pipe.to(lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Tuple = self.get_dummy_inputs(lowerCamelCase) _lowercase : Tuple = 1 _lowercase : int = None _lowercase : Tuple = 0 _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 32, 32, 3) _lowercase : List[str] = image[0, -3:, -3:, -1] _lowercase : Any = np.array([0.5_0_0_4, 0.5_0_0_4, 0.4_9_9_4, 0.5_0_0_8, 0.4_9_7_6, 0.5_0_1_8, 0.4_9_9_0, 0.4_9_8_2, 0.4_9_8_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @slow @require_torch_gpu class _lowerCamelCase( unittest.TestCase ): def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase=False, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Optional[Any]: """simple docstring""" _lowercase : List[Any] = torch.manual_seed(lowerCamelCase) _lowercase : str = { 'num_inference_steps': None, 'timesteps': [22, 0], 'class_labels': 0, 'generator': generator, 'output_type': 'np', } if get_fixed_latents: _lowercase : Optional[Any] = self.get_fixed_latents(seed=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase, shape=lowerCamelCase) _lowercase : Tuple = latents return inputs def UpperCamelCase ( self, lowerCamelCase=0, lowerCamelCase="cpu", lowerCamelCase=torch.floataa, lowerCamelCase=(1, 3, 64, 64)) -> Any: """simple docstring""" if type(lowerCamelCase) == str: _lowercase : Union[str, Any] = torch.device(lowerCamelCase) _lowercase : int = torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase) _lowercase : List[str] = randn_tensor(lowerCamelCase, generator=lowerCamelCase, device=lowerCamelCase, dtype=lowerCamelCase) return latents def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : Tuple = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Any = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : str = self.get_inputs() _lowercase : Optional[int] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : str = image[0, -3:, -3:, -1] _lowercase : Optional[Any] = np.array([0.0_8_8_8, 0.0_8_8_1, 0.0_6_6_6, 0.0_4_7_9, 0.0_2_9_2, 0.0_1_9_5, 0.0_2_0_1, 0.0_1_6_3, 0.0_2_5_4]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[str] = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : List[str] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Union[str, Any] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs() _lowercase : int = 1 _lowercase : Optional[Any] = None _lowercase : str = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : List[Any] = image[0, -3:, -3:, -1] _lowercase : List[str] = np.array([0.0_3_4_0, 0.0_1_5_2, 0.0_0_6_3, 0.0_2_6_7, 0.0_2_2_1, 0.0_1_0_7, 0.0_4_1_6, 0.0_1_8_6, 0.0_2_1_7]) assert np.abs(image_slice.flatten() - expected_slice).max() < 2E-2 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : str = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[int] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : Optional[int] = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : Any = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Dict = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : Union[str, Any] = np.array([0.1_8_7_5, 0.1_4_2_8, 0.1_2_8_9, 0.2_1_5_1, 0.2_0_9_2, 0.1_4_7_7, 0.1_8_7_7, 0.1_6_4_1, 0.1_3_5_3]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3 @require_torch_a def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Dict = UNetaDModel.from_pretrained('diffusers/consistency_models', subfolder='diffusers_cd_imagenet64_l2') _lowercase : Optional[Any] = CMStochasticIterativeScheduler( num_train_timesteps=40, sigma_min=0.0_0_2, sigma_max=8_0.0, ) _lowercase : int = ConsistencyModelPipeline(unet=lowerCamelCase, scheduler=lowerCamelCase) pipe.to(torch_device=lowerCamelCase, torch_dtype=torch.floataa) pipe.set_progress_bar_config(disable=lowerCamelCase) _lowercase : List[Any] = self.get_inputs(get_fixed_latents=lowerCamelCase, device=lowerCamelCase) _lowercase : int = 1 _lowercase : str = None # Ensure usage of flash attention in torch 2.0 with sdp_kernel(enable_flash=lowerCamelCase, enable_math=lowerCamelCase, enable_mem_efficient=lowerCamelCase): _lowercase : Union[str, Any] = pipe(**lowerCamelCase).images assert image.shape == (1, 64, 64, 3) _lowercase : Any = image[0, -3:, -3:, -1] _lowercase : int = np.array([0.1_6_6_3, 0.1_9_4_8, 0.2_2_7_5, 0.1_6_8_0, 0.1_2_0_4, 0.1_2_4_5, 0.1_8_5_8, 0.1_3_3_8, 0.2_0_9_5]) assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3
21
0
'''simple docstring''' import os import jsonlines import numpy as np from tqdm import tqdm __a = 2048 __a = 4096 __a = 42 __a = os.environ.pop("PROCESS_TRAIN", "false") __a = {"null": 0, "short": 1, "long": 2, "yes": 3, "no": 4} def __snake_case( _lowerCAmelCase ) -> Union[str, Any]: def choose_first(_lowerCAmelCase , _lowerCAmelCase=False ): assert isinstance(_lowerCAmelCase , _lowerCAmelCase ) if len(_lowerCAmelCase ) == 1: snake_case__ : Optional[Any] = answer[0] return {k: [answer[k]] for k in answer} if is_long_answer else answer for a in answer: if is_long_answer: snake_case__ : Any = {k: [a[k]] for k in a} if len(a["""start_token"""] ) > 0: break return a snake_case__ : Union[str, Any] = {"""id""": example["""id"""]} snake_case__ : int = example["""annotations"""] snake_case__ : str = annotation["""yes_no_answer"""] if 0 in yes_no_answer or 1 in yes_no_answer: snake_case__ : Optional[Any] = ["""yes"""] if 1 in yes_no_answer else ["""no"""] snake_case__ : Dict = [] snake_case__ : int = [] snake_case__ : Optional[Any] = ["""<cls>"""] else: snake_case__ : Tuple = ["""short"""] snake_case__ : Tuple = choose_first(annotation["""short_answers"""] ) if len(out["""start_token"""] ) == 0: # answer will be long if short is not available snake_case__ : Any = ["""long"""] snake_case__ : List[str] = choose_first(annotation["""long_answer"""] , is_long_answer=_lowerCAmelCase ) snake_case__ : Tuple = [] answer.update(_lowerCAmelCase ) # disregard some samples if len(answer["""start_token"""] ) > 1 or answer["start_token"] == answer["end_token"]: snake_case__ : List[str] = True else: snake_case__ : str = False snake_case__ : Any = ["""start_token""", """end_token""", """start_byte""", """end_byte""", """text"""] if not all(isinstance(answer[k] , _lowerCAmelCase ) for k in cols ): raise ValueError("""Issue in ID""" , example["""id"""] ) return answer def __snake_case( _lowerCAmelCase , _lowerCAmelCase=False ) -> List[Any]: snake_case__ : Optional[Any] = _get_single_answer(_lowerCAmelCase ) # bytes are of no use del answer["start_byte"] del answer["end_byte"] # handle yes_no answers explicitly if answer["category"][0] in ["yes", "no"]: # category is list with one element snake_case__ : Optional[Any] = example["""document"""]["""tokens"""] snake_case__ : List[str] = [] for i in range(len(doc["""token"""] ) ): if not doc["is_html"][i]: context.append(doc["""token"""][i] ) return { "context": " ".join(_lowerCAmelCase ), "answer": { "start_token": -100, # ignore index in cross-entropy "end_token": -100, # ignore index in cross-entropy "category": answer["category"], "span": answer["category"], # extra }, } # later, help in removing all no answers if answer["start_token"] == [-1]: return { "context": "None", "answer": { "start_token": -1, "end_token": -1, "category": "null", "span": "None", # extra }, } # handling normal samples snake_case__ : Any = ["""start_token""", """end_token"""] answer.update({k: answer[k][0] if len(answer[k] ) > 0 else answer[k] for k in cols} ) # e.g. [10] == 10 snake_case__ : List[str] = example["""document"""]["""tokens"""] snake_case__ : str = answer["""start_token"""] snake_case__ : List[str] = answer["""end_token"""] snake_case__ : Tuple = [] for i in range(len(doc["""token"""] ) ): if not doc["is_html"][i]: context.append(doc["""token"""][i] ) else: if answer["start_token"] > i: start_token -= 1 if answer["end_token"] > i: end_token -= 1 snake_case__ : int = """ """.join(context[start_token:end_token] ) # checking above code if assertion: snake_case__ : List[str] = doc["""is_html"""][answer["""start_token"""] : answer["""end_token"""]] snake_case__ : List[str] = doc["""token"""][answer["""start_token"""] : answer["""end_token"""]] snake_case__ : Optional[int] = """ """.join([old[i] for i in range(len(_lowerCAmelCase ) ) if not is_html[i]] ) if new != old: print("""ID:""" , example["""id"""] ) print("""New:""" , _lowerCAmelCase , end="""\n""" ) print("""Old:""" , _lowerCAmelCase , end="""\n\n""" ) return { "context": " ".join(_lowerCAmelCase ), "answer": { "start_token": start_token, "end_token": end_token - 1, # this makes it inclusive "category": answer["category"], # either long or short "span": new, # extra }, } def __snake_case( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase=2_048 , _lowerCAmelCase=4_096 , _lowerCAmelCase=True ) -> Optional[Any]: # overlap will be of doc_stride - q_len snake_case__ : Optional[int] = get_context_and_ans(_lowerCAmelCase , assertion=_lowerCAmelCase ) snake_case__ : int = out["""answer"""] # later, removing these samples if answer["start_token"] == -1: return { "example_id": example["id"], "input_ids": [[-1]], "labels": { "start_token": [-1], "end_token": [-1], "category": ["null"], }, } snake_case__ : Union[str, Any] = tokenizer(example["""question"""]["""text"""] , out["""context"""] ).input_ids snake_case__ : int = input_ids.index(tokenizer.sep_token_id ) + 1 # return yes/no if answer["category"][0] in ["yes", "no"]: # category is list with one element snake_case__ : Tuple = [] snake_case__ : Dict = [] snake_case__ : Optional[Any] = input_ids[:q_len] snake_case__ : List[str] = range(_lowerCAmelCase , len(_lowerCAmelCase ) , max_length - doc_stride ) for i in doc_start_indices: snake_case__ : Any = i + max_length - q_len snake_case__ : str = input_ids[i:end_index] inputs.append(q_indices + slice ) category.append(answer["""category"""][0] ) if slice[-1] == tokenizer.sep_token_id: break return { "example_id": example["id"], "input_ids": inputs, "labels": { "start_token": [-100] * len(_lowerCAmelCase ), "end_token": [-100] * len(_lowerCAmelCase ), "category": category, }, } snake_case__ : int = out["""context"""].split() snake_case__ : Tuple = splitted_context[answer["""end_token"""]] snake_case__ : int = len( tokenizer( """ """.join(splitted_context[: answer["""start_token"""]] ) , add_special_tokens=_lowerCAmelCase , ).input_ids ) snake_case__ : int = len( tokenizer(""" """.join(splitted_context[: answer["""end_token"""]] ) , add_special_tokens=_lowerCAmelCase ).input_ids ) answer["start_token"] += q_len answer["end_token"] += q_len # fixing end token snake_case__ : Tuple = len(tokenizer(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids ) if num_sub_tokens > 1: answer["end_token"] += num_sub_tokens - 1 snake_case__ : int = input_ids[answer["""start_token"""] : answer["""end_token"""] + 1] # right & left are inclusive snake_case__ : Dict = answer["""start_token"""] snake_case__ : Optional[int] = answer["""end_token"""] if assertion: snake_case__ : Union[str, Any] = tokenizer.decode(_lowerCAmelCase ) if answer["span"] != new: print("""ISSUE IN TOKENIZATION""" ) print("""OLD:""" , answer["""span"""] ) print("""NEW:""" , _lowerCAmelCase , end="""\n\n""" ) if len(_lowerCAmelCase ) <= max_length: return { "example_id": example["id"], "input_ids": [input_ids], "labels": { "start_token": [answer["start_token"]], "end_token": [answer["end_token"]], "category": answer["category"], }, } snake_case__ : Tuple = input_ids[:q_len] snake_case__ : Optional[int] = range(_lowerCAmelCase , len(_lowerCAmelCase ) , max_length - doc_stride ) snake_case__ : Dict = [] snake_case__ : List[str] = [] snake_case__ : int = [] snake_case__ : Any = [] # null, yes, no, long, short for i in doc_start_indices: snake_case__ : int = i + max_length - q_len snake_case__ : List[Any] = input_ids[i:end_index] inputs.append(q_indices + slice ) assert len(inputs[-1] ) <= max_length, "Issue in truncating length" if start_token >= i and end_token <= end_index - 1: snake_case__ : List[Any] = start_token - i + q_len snake_case__ : Dict = end_token - i + q_len answers_category.append(answer["""category"""][0] ) # ["short"] -> "short" else: snake_case__ : Union[str, Any] = -100 snake_case__ : Any = -100 answers_category.append("""null""" ) snake_case__ : Tuple = inputs[-1][start_token : end_token + 1] answers_start_token.append(_lowerCAmelCase ) answers_end_token.append(_lowerCAmelCase ) if assertion: if new != old and new != [tokenizer.cls_token_id]: print("""ISSUE in strided for ID:""" , example["""id"""] ) print("""New:""" , tokenizer.decode(_lowerCAmelCase ) ) print("""Old:""" , tokenizer.decode(_lowerCAmelCase ) , end="""\n\n""" ) if slice[-1] == tokenizer.sep_token_id: break return { "example_id": example["id"], "input_ids": inputs, "labels": { "start_token": answers_start_token, "end_token": answers_end_token, "category": answers_category, }, } def __snake_case( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase=2_048 , _lowerCAmelCase=4_096 , _lowerCAmelCase=False ) -> Optional[Any]: snake_case__ : int = get_strided_contexts_and_ans( _lowerCAmelCase , _lowerCAmelCase , doc_stride=_lowerCAmelCase , max_length=_lowerCAmelCase , assertion=_lowerCAmelCase , ) return example def __snake_case( _lowerCAmelCase , _lowerCAmelCase ) -> Union[str, Any]: with jsonlines.open(_lowerCAmelCase , """a""" ) as writer: for example in tqdm(_lowerCAmelCase , total=len(_lowerCAmelCase ) , desc="""Saving samples ... """ ): snake_case__ : Optional[Any] = example["""labels"""] for ids, start, end, cat in zip( example["""input_ids"""] , labels["""start_token"""] , labels["""end_token"""] , labels["""category"""] , ): if start == -1 and end == -1: continue # leave waste samples with no answer if cat == "null" and np.random.rand() < 0.6: continue # removing 50 % samples writer.write( { """input_ids""": ids, """start_token""": start, """end_token""": end, """category""": CATEGORY_MAPPING[cat], } ) if __name__ == "__main__": from datasets import load_dataset from transformers import BigBirdTokenizer __a = load_dataset("natural_questions") __a = BigBirdTokenizer.from_pretrained("google/bigbird-roberta-base") __a = data["train" if PROCESS_TRAIN == "true" else "validation"] __a = { "tokenizer": tokenizer, "doc_stride": DOC_STRIDE, "max_length": MAX_LENGTH, "assertion": False, } __a = data.map(prepare_inputs, fn_kwargs=fn_kwargs) __a = data.remove_columns(["annotations", "document", "id", "question"]) print(data) np.random.seed(SEED) __a = "nq-training.jsonl" if PROCESS_TRAIN == "true" else "nq-validation.jsonl" save_to_disk(data, file_name=cache_file_name)
35
from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def UpperCamelCase_( lowerCamelCase_ ) -> bool: _lowercase : int = int(number**0.5 ) return number == sq * sq def UpperCamelCase_( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) -> tuple[int, int]: _lowercase : int = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _lowercase : int = x_den * y_den * z_den _lowercase : int = gcd(lowerCamelCase_ , lowerCamelCase_ ) top //= hcf bottom //= hcf return top, bottom def UpperCamelCase_( lowerCamelCase_ = 35 ) -> int: _lowercase : set = set() _lowercase : int _lowercase : Fraction = Fraction(0 ) _lowercase : tuple[int, int] for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _lowercase : int = x_num * y_den + x_den * y_num _lowercase : int = x_den * y_den _lowercase : str = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : List[Any] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : Dict = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _lowercase : List[Any] = x_den * x_den * y_den * y_den if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : int = int(sqrt(lowerCamelCase_ ) ) _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Optional[int] = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=-1 _lowercase : Any = x_num * y_num _lowercase : str = x_den * y_num + x_num * y_den _lowercase : Any = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : int = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) # n=2 _lowercase : str = x_num * x_num * y_num * y_num _lowercase : Optional[Any] = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(lowerCamelCase_ ) and is_sq(lowerCamelCase_ ): _lowercase : Tuple = int(sqrt(lowerCamelCase_ ) ) _lowercase : List[str] = int(sqrt(lowerCamelCase_ ) ) _lowercase : Union[str, Any] = gcd(lowerCamelCase_ , lowerCamelCase_ ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _lowercase : Tuple = add_three( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) unique_s.add(lowerCamelCase_ ) for num, den in unique_s: total += Fraction(lowerCamelCase_ , lowerCamelCase_ ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
21
0
import os from distutils.util import strtobool def A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' for e in env_keys: _lowerCAmelCase : int = int(os.environ.get(_lowerCamelCase , -1 ) ) if val >= 0: return val return default def A ( _lowerCamelCase , _lowerCamelCase=False ): '''simple docstring''' _lowerCAmelCase : List[str] = os.environ.get(_lowerCamelCase , str(_lowerCamelCase ) ) return strtobool(_lowerCamelCase ) == 1 # As its name indicates `strtobool` actually returns an int... def A ( _lowerCamelCase , _lowerCamelCase="no" ): '''simple docstring''' _lowerCAmelCase : List[Any] = os.environ.get(_lowerCamelCase , str(_lowerCamelCase ) ) return value
36
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) SCREAMING_SNAKE_CASE : str = { "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"], } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Tuple = ["LlamaTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : Optional[Any] = ["LlamaTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE : int = [ "LlamaForCausalLM", "LlamaModel", "LlamaPreTrainedModel", "LlamaForSequenceClassification", ] if TYPE_CHECKING: from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama import LlamaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_llama_fast import LlamaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel else: import sys SCREAMING_SNAKE_CASE : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
21
0
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowerCAmelCase = { '''configuration_mvp''': ['''MVP_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MvpConfig''', '''MvpOnnxConfig'''], '''tokenization_mvp''': ['''MvpTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCAmelCase = ['''MvpTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCAmelCase = [ '''MVP_PRETRAINED_MODEL_ARCHIVE_LIST''', '''MvpForCausalLM''', '''MvpForConditionalGeneration''', '''MvpForQuestionAnswering''', '''MvpForSequenceClassification''', '''MvpModel''', '''MvpPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig from .tokenization_mvp import MvpTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mvp_fast import MvpTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mvp import ( MVP_PRETRAINED_MODEL_ARCHIVE_LIST, MvpForCausalLM, MvpForConditionalGeneration, MvpForQuestionAnswering, MvpForSequenceClassification, MvpModel, MvpPreTrainedModel, ) else: import sys _lowerCAmelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
37
from __future__ import annotations def UpperCamelCase_( lowerCamelCase_ ) -> bool: if len(lowerCamelCase_ ) < 2: raise ValueError('Monogons and Digons are not polygons in the Euclidean space' ) if any(i <= 0 for i in nums ): raise ValueError('All values must be greater than 0' ) _lowercase : Tuple = nums.copy() copy_nums.sort() return copy_nums[-1] < sum(copy_nums[:-1] ) if __name__ == "__main__": import doctest doctest.testmod()
21
0
import argparse import json import os import time import zipfile from get_ci_error_statistics import download_artifact, get_artifacts_links from transformers import logging UpperCAmelCase_ : Dict = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE_ ( __magic_name__ : Tuple , __magic_name__ : List[Any] ) -> str: """simple docstring""" UpperCamelCase :int = set() UpperCamelCase :Optional[Any] = [] def parse_line(__magic_name__ : Any ): for line in fp: if isinstance(__magic_name__ , __magic_name__ ): UpperCamelCase :Tuple = line.decode("""UTF-8""" ) if "warnings summary (final)" in line: continue # This means we are outside the body of a warning elif not line.startswith(""" """ ): # process a single warning and move it to `selected_warnings`. if len(__magic_name__ ) > 0: UpperCamelCase :List[Any] = """\n""".join(__magic_name__ ) # Only keep the warnings specified in `targets` if any(f""": {x}: """ in warning for x in targets ): selected_warnings.add(__magic_name__ ) buffer.clear() continue else: UpperCamelCase :Any = line.strip() buffer.append(__magic_name__ ) if from_gh: for filename in os.listdir(__magic_name__ ): UpperCamelCase :Tuple = os.path.join(__magic_name__ , __magic_name__ ) if not os.path.isdir(__magic_name__ ): # read the file if filename != "warnings.txt": continue with open(__magic_name__ ) as fp: parse_line(__magic_name__ ) else: try: with zipfile.ZipFile(__magic_name__ ) as z: for filename in z.namelist(): if not os.path.isdir(__magic_name__ ): # read the file if filename != "warnings.txt": continue with z.open(__magic_name__ ) as fp: parse_line(__magic_name__ ) except Exception: logger.warning( f"""{artifact_path} is either an invalid zip file or something else wrong. This file is skipped.""" ) return selected_warnings def SCREAMING_SNAKE_CASE_ ( __magic_name__ : str , __magic_name__ : List[str] ) -> Dict: """simple docstring""" UpperCamelCase :Optional[int] = set() UpperCamelCase :Optional[int] = [os.path.join(__magic_name__ , __magic_name__ ) for p in os.listdir(__magic_name__ ) if (p.endswith(""".zip""" ) or from_gh)] for p in paths: selected_warnings.update(extract_warnings_from_single_artifact(__magic_name__ , __magic_name__ ) ) return selected_warnings if __name__ == "__main__": def SCREAMING_SNAKE_CASE_ ( __magic_name__ : Optional[Any] ) -> Tuple: """simple docstring""" return values.split(""",""" ) UpperCAmelCase_ : str = argparse.ArgumentParser() # Required parameters parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''') parser.add_argument( '''--output_dir''', type=str, required=True, help='''Where to store the downloaded artifacts and other result files.''', ) parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''') # optional parameters parser.add_argument( '''--targets''', default='''DeprecationWarning,UserWarning,FutureWarning''', type=list_str, help='''Comma-separated list of target warning(s) which we want to extract.''', ) parser.add_argument( '''--from_gh''', action='''store_true''', help='''If running from a GitHub action workflow and collecting warnings from its artifacts.''', ) UpperCAmelCase_ : Optional[int] = parser.parse_args() UpperCAmelCase_ : List[str] = args.from_gh if from_gh: # The artifacts have to be downloaded using `actions/download-artifact@v3` pass else: os.makedirs(args.output_dir, exist_ok=True) # get download links UpperCAmelCase_ : List[str] = get_artifacts_links(args.workflow_run_id, token=args.token) with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(artifacts, fp, ensure_ascii=False, indent=4) # download artifacts for idx, (name, url) in enumerate(artifacts.items()): print(name) print(url) print('''=''' * 80) download_artifact(name, url, args.output_dir, args.token) # Be gentle to GitHub time.sleep(1) # extract warnings from artifacts UpperCAmelCase_ : Any = extract_warnings(args.output_dir, args.targets) UpperCAmelCase_ : str = sorted(selected_warnings) with open(os.path.join(args.output_dir, '''selected_warnings.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(selected_warnings, fp, ensure_ascii=False, indent=4)
38
from __future__ import annotations from math import ceil, floor, sqrt def UpperCamelCase_( lowerCamelCase_ = 200_0000 ) -> int: _lowercase : list[int] = [0] _lowercase : int for idx in range(1 , ceil(sqrt(target * 2 ) * 1.1 ) ): triangle_numbers.append(triangle_numbers[-1] + idx ) # we want this to be as close as possible to target _lowercase : int = 0 # the area corresponding to the grid that gives the product closest to target _lowercase : int = 0 # an estimate of b, using the quadratic formula _lowercase : float # the largest integer less than b_estimate _lowercase : int # the largest integer less than b_estimate _lowercase : int # the triangle number corresponding to b_floor _lowercase : int # the triangle number corresponding to b_ceil _lowercase : int for idx_a, triangle_a in enumerate(triangle_numbers[1:] , 1 ): _lowercase : Optional[int] = (-1 + sqrt(1 + 8 * target / triangle_a )) / 2 _lowercase : List[str] = floor(lowerCamelCase_ ) _lowercase : Dict = ceil(lowerCamelCase_ ) _lowercase : List[str] = triangle_numbers[b_floor] _lowercase : List[str] = triangle_numbers[b_ceil] if abs(target - triangle_b_first_guess * triangle_a ) < abs( target - best_product ): _lowercase : Union[str, Any] = triangle_b_first_guess * triangle_a _lowercase : Union[str, Any] = idx_a * b_floor if abs(target - triangle_b_second_guess * triangle_a ) < abs( target - best_product ): _lowercase : Any = triangle_b_second_guess * triangle_a _lowercase : Optional[Any] = idx_a * b_ceil return area if __name__ == "__main__": print(F"{solution() = }")
21
0
from math import pi def __A ( __lowerCAmelCase , __lowerCAmelCase )-> float: """simple docstring""" return 2 * pi * radius * (angle / 360) if __name__ == "__main__": print(arc_length(90, 10))
39
import collections import tempfile import unittest import numpy as np from transformers.testing_utils import ( is_pt_flax_cross_test, require_flax, require_torch, require_vision, slow, torch_device, ) from transformers.utils import is_flax_available, is_torch_available, is_vision_available from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask from ..bert.test_modeling_flax_bert import FlaxBertModelTester from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester from ..vit.test_modeling_flax_vit import FlaxViTModelTester if is_flax_available(): from transformers import ( FlaxBertModel, FlaxCLIPVisionModel, FlaxVisionTextDualEncoderModel, FlaxViTModel, VisionTextDualEncoderConfig, VisionTextDualEncoderProcessor, ) from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) if is_torch_available(): import torch from transformers import VisionTextDualEncoderModel if is_vision_available(): from PIL import Image def UpperCamelCase_( lowerCamelCase_ ) -> Optional[int]: if isinstance(lowerCamelCase_ , collections.abc.Iterable ): return x return (x, x) @require_flax class _lowerCamelCase: def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Union[str, Any]: """simple docstring""" pass def UpperCamelCase ( self) -> str: """simple docstring""" pass def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" pass def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : str = np.abs((a - b)).max() self.assertLessEqual(lowerCamelCase, lowerCamelCase, F'''Difference between torch and flax is {diff} (>= {tol}).''') def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase : Any = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Any = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Any: """simple docstring""" _lowercase , _lowercase : Union[str, Any] = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : str = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) self.assertEqual(output['text_embeds'].shape, (input_ids.shape[0], model.config.projection_dim)) self.assertEqual(output['image_embeds'].shape, (pixel_values.shape[0], model.config.projection_dim)) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> Union[str, Any]: """simple docstring""" _lowercase , _lowercase : Tuple = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : List[str] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : List[str] = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : Tuple = output[0] with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(lowerCamelCase) _lowercase : Any = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : Tuple = model(input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase) _lowercase : str = after_output[0] _lowercase : Optional[Any] = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-3) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase) -> str: """simple docstring""" _lowercase , _lowercase : Any = self.get_vision_text_model(lowerCamelCase, lowerCamelCase) _lowercase : Optional[int] = {'vision_model': vision_model, 'text_model': text_model} _lowercase : Dict = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase) _lowercase : Tuple = model( input_ids=lowerCamelCase, pixel_values=lowerCamelCase, attention_mask=lowerCamelCase, output_attentions=lowerCamelCase) _lowercase : int = output.vision_model_output.attentions self.assertEqual(len(lowerCamelCase), vision_config.num_hidden_layers) # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token) _lowercase : Optional[Any] = to_atuple(vision_model.config.image_size) _lowercase : Any = to_atuple(vision_model.config.patch_size) _lowercase : Dict = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) _lowercase : Dict = num_patches + 1 self.assertEqual(vision_attentions[0].shape[-3:], (vision_config.num_attention_heads, seq_len, seq_len)) _lowercase : List[str] = output.text_model_output.attentions self.assertEqual(len(lowerCamelCase), text_config.num_hidden_layers) self.assertEqual( text_attentions[0].shape[-3:], (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]), ) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" pt_model.to(lowerCamelCase) pt_model.eval() # prepare inputs _lowercase : Any = inputs_dict _lowercase : Optional[int] = {k: torch.tensor(v.tolist()) for k, v in flax_inputs.items()} with torch.no_grad(): _lowercase : Tuple = pt_model(**lowerCamelCase).to_tuple() _lowercase : Any = fx_model(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output in zip(fx_outputs[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # PT -> Flax with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_pt=lowerCamelCase) _lowercase : List[Any] = fx_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4], pt_outputs[:4]): self.assert_almost_equals(lowerCamelCase, pt_output.numpy(), 4E-2) # Flax -> PT with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(lowerCamelCase) _lowercase : List[Any] = VisionTextDualEncoderModel.from_pretrained(lowerCamelCase, from_flax=lowerCamelCase) pt_model_loaded.to(lowerCamelCase) pt_model_loaded.eval() with torch.no_grad(): _lowercase : Optional[Any] = pt_model_loaded(**lowerCamelCase).to_tuple() self.assertEqual(len(lowerCamelCase), len(lowerCamelCase), 'Output lengths differ between Flax and PyTorch') for fx_output, pt_output_loaded in zip(fx_outputs[:4], pt_outputs_loaded[:4]): self.assert_almost_equals(lowerCamelCase, pt_output_loaded.numpy(), 4E-2) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Tuple: """simple docstring""" _lowercase : Dict = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Optional[Any] = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : str = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : Tuple = convert_pytorch_state_dict_to_flax(pt_model.state_dict(), lowerCamelCase) _lowercase : List[Any] = fx_state self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase, lowerCamelCase) -> Dict: """simple docstring""" _lowercase : str = VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase, lowerCamelCase) _lowercase : Tuple = VisionTextDualEncoderModel(lowerCamelCase) _lowercase : Optional[int] = FlaxVisionTextDualEncoderModel(lowerCamelCase) _lowercase : List[str] = load_flax_weights_in_pytorch_model(lowerCamelCase, fx_model.params) self.check_pt_flax_equivalence(lowerCamelCase, lowerCamelCase, lowerCamelCase) def UpperCamelCase ( self) -> List[Any]: """simple docstring""" _lowercase : int = self.prepare_config_and_inputs() self.check_model_from_pretrained_configs(**lowerCamelCase) def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[str] = self.prepare_config_and_inputs() self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase) def UpperCamelCase ( self) -> Union[str, Any]: """simple docstring""" _lowercase : Optional[int] = self.prepare_config_and_inputs() self.check_save_load(**lowerCamelCase) def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : str = self.prepare_config_and_inputs() self.check_vision_text_output_attention(**lowerCamelCase) @is_pt_flax_cross_test def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase : List[str] = config_inputs_dict.pop('vision_config') _lowercase : str = config_inputs_dict.pop('text_config') _lowercase : int = config_inputs_dict self.check_equivalence_pt_to_flax(lowerCamelCase, lowerCamelCase, lowerCamelCase) self.check_equivalence_flax_to_pt(lowerCamelCase, lowerCamelCase, lowerCamelCase) @slow def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase , _lowercase : Optional[Any] = self.get_pretrained_model_and_inputs() _lowercase : Optional[int] = model_a(**lowerCamelCase) _lowercase : Tuple = outputs[0] with tempfile.TemporaryDirectory() as tmp_dirname: model_a.save_pretrained(lowerCamelCase) _lowercase : int = FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase) _lowercase : List[Any] = model_a(**lowerCamelCase) _lowercase : Tuple = after_outputs[0] _lowercase : Dict = np.amax(np.abs(out_a - out_a)) self.assertLessEqual(lowerCamelCase, 1E-5) @require_flax class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> List[str]: """simple docstring""" _lowercase : Union[str, Any] = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-vit', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : List[Any] = 13 _lowercase : str = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Tuple = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Union[str, Any] = random_attention_mask([batch_size, 4]) _lowercase : int = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Any: """simple docstring""" _lowercase : List[Any] = FlaxViTModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> str: """simple docstring""" _lowercase : List[Any] = FlaxViTModelTester(self) _lowercase : Any = FlaxBertModelTester(self) _lowercase : Dict = vit_model_tester.prepare_config_and_inputs() _lowercase : Any = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : List[str] = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Tuple = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_torch class _lowerCamelCase( _a, unittest.TestCase ): def UpperCamelCase ( self) -> Tuple: """simple docstring""" _lowercase : str = FlaxVisionTextDualEncoderModel.from_vision_text_pretrained( 'hf-internal-testing/tiny-random-clip', 'hf-internal-testing/tiny-bert', vision_from_pt=lowerCamelCase, text_from_pt=lowerCamelCase, ) _lowercase : Tuple = 13 _lowercase : Any = floats_tensor( [ batch_size, model.config.vision_config.num_channels, model.config.vision_config.image_size, model.config.vision_config.image_size, ]) _lowercase : Union[str, Any] = ids_tensor([batch_size, 4], model.config.text_config.vocab_size) _lowercase : Any = random_attention_mask([batch_size, 4]) _lowercase : Dict = {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask} return model, inputs def UpperCamelCase ( self, lowerCamelCase, lowerCamelCase) -> Optional[int]: """simple docstring""" _lowercase : Any = FlaxCLIPVisionModel(lowerCamelCase) _lowercase : Optional[Any] = FlaxBertModel(lowerCamelCase) return vision_model, text_model def UpperCamelCase ( self) -> Dict: """simple docstring""" _lowercase : Tuple = FlaxCLIPVisionModelTester(self) _lowercase : Union[str, Any] = FlaxBertModelTester(self) _lowercase : Tuple = clip_model_tester.prepare_config_and_inputs() _lowercase : str = bert_model_tester.prepare_config_and_inputs() _lowercase , _lowercase : Dict = vision_config_and_inputs _lowercase , _lowercase , _lowercase , _lowercase : Optional[int] = text_config_and_inputs # make sure that cross attention layers are added return { "text_config": text_config, "vision_config": vision_config, "pixel_values": pixel_values, "attention_mask": attention_mask, "input_ids": input_ids, "token_type_ids": token_type_ids, } @require_flax @require_vision class _lowerCamelCase( unittest.TestCase ): @slow def UpperCamelCase ( self) -> Optional[int]: """simple docstring""" _lowercase : List[str] = FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian', logit_scale_init_value=1.0) _lowercase : List[str] = VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian') _lowercase : List[Any] = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') _lowercase : List[Any] = processor( text=['una foto di un gatto', 'una foto di un cane'], images=lowerCamelCase, padding=lowerCamelCase, return_tensors='np') _lowercase : List[Any] = model(**lowerCamelCase) # verify the logits self.assertEqual(outputs.logits_per_image.shape, (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])) self.assertEqual( outputs.logits_per_text.shape, (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]), ) _lowercase : Optional[int] = np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]) self.assertTrue(np.allclose(outputs.logits_per_image, lowerCamelCase, atol=1E-3))
21
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available __lowercase = { """configuration_groupvit""": [ """GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GroupViTConfig""", """GroupViTOnnxConfig""", """GroupViTTextConfig""", """GroupViTVisionConfig""", ], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowercase = [ """GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST""", """GroupViTModel""", """GroupViTPreTrainedModel""", """GroupViTTextModel""", """GroupViTVisionModel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __lowercase = [ """TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFGroupViTModel""", """TFGroupViTPreTrainedModel""", """TFGroupViTTextModel""", """TFGroupViTVisionModel""", ] if TYPE_CHECKING: from .configuration_groupvit import ( GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GroupViTConfig, GroupViTOnnxConfig, GroupViTTextConfig, GroupViTVisionConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_groupvit import ( GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST, GroupViTModel, GroupViTPreTrainedModel, GroupViTTextModel, GroupViTVisionModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_groupvit import ( TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST, TFGroupViTModel, TFGroupViTPreTrainedModel, TFGroupViTTextModel, TFGroupViTVisionModel, ) else: import sys __lowercase = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
40
import random from typing import Any def UpperCamelCase_( lowerCamelCase_ ) -> list[Any]: for _ in range(len(lowerCamelCase_ ) ): _lowercase : Optional[int] = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase : str = random.randint(0 , len(lowerCamelCase_ ) - 1 ) _lowercase , _lowercase : Optional[int] = data[b], data[a] return data if __name__ == "__main__": SCREAMING_SNAKE_CASE : str = [0, 1, 2, 3, 4, 5, 6, 7] SCREAMING_SNAKE_CASE : int = ["python", "says", "hello", "!"] print("Fisher-Yates Shuffle:") print("List", integers, strings) print("FY Shuffle", fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
21
0