code: 
  
  
  
  
  
  
  # limitations under the License.
  
  
  from typing import Optional, Tuple, Union
  
  import torch
  
  from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
  
  class 					snake_case_							(       lowercase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def __init__(    self:	List[Any]   ,       snake_case__:	Optional[int]   ,       snake_case__:	str	)  ->		Optional[Any]:
  
  
         """simple docstring"""
  
  
  
         super().__init__()
         self.register_modules(unet=snake_case__   ,       scheduler=snake_case__	)
  
     @torch.no_grad()
     def __call__(    self:	List[str]   ,       snake_case__:	int = 1   ,       snake_case__:	Optional[torch.Generator] = None   ,       snake_case__:	int = 50   ,       snake_case__:	Optional[str] = "pil"   ,       snake_case__:	bool = True   ,       **snake_case__:	Union[str, Any]   ,       )  ->		Union[ImagePipelineOutput, Tuple]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	torch.randn(
             (batch_size, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size)   ,       generator=snake_case__   ,       )
         _lowercase     =	image.to(self.device	)
  
         # set step values
         self.scheduler.set_timesteps(snake_case__	)
  
         for t in self.progress_bar(self.scheduler.timesteps	):
             # 1. predict noise model_output
             _lowercase     =	self.unet(snake_case__   ,       snake_case__	).sample
  
             # 2. predict previous mean of image x_t-1 and add variance depending on eta
             # eta corresponds to η in paper and should be between [0, 1]
             # do x_t -> x_t-1
             _lowercase     =	self.scheduler.step(snake_case__   ,       snake_case__   ,       snake_case__	).prev_sample
  
         _lowercase     =	(image / 2 + 0.5).clamp(0   ,       1	)
         _lowercase     =	image.cpu().permute(0   ,       2   ,       3   ,       1	).numpy()
         if output_type == "pil":
             _lowercase     =	self.numpy_to_pil(snake_case__	)
  
         if not return_dict:
             return (image,), "This is a local test"
  
         return ImagePipelineOutput(images=snake_case__	), "This is a local test"
  
style_context: 
  
  
  
  
  
  
  from typing import List, Union
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  lowerCamelCase										=  logging.get_logger(__name__)
  
  lowerCamelCase										=  {
      '''allenai/led-base-16384''': '''https://huggingface.co/allenai/led-base-16384/resolve/main/config.json''',
      # See all LED models at https://huggingface.co/models?filter=led
  }
  
  class 					snake_case_							(       lowercase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						"""led"""
     __lowerCAmelCase      =						{
         """num_attention_heads""": """encoder_attention_heads""",
         """hidden_size""": """d_model""",
         """attention_probs_dropout_prob""": """attention_dropout""",
         """initializer_range""": """init_std""",
     }
  
     def __init__(    self:	int   ,       snake_case__:	str=50_265   ,       snake_case__:	Dict=16_384   ,       snake_case__:	str=1_024   ,       snake_case__:	Tuple=12   ,       snake_case__:	int=4_096   ,       snake_case__:	Union[str, Any]=16   ,       snake_case__:	int=12   ,       snake_case__:	Union[str, Any]=4_096   ,       snake_case__:	Optional[Any]=16   ,       snake_case__:	str=0.0   ,       snake_case__:	Optional[Any]=0.0   ,       snake_case__:	List[Any]=True   ,       snake_case__:	List[Any]=True   ,       snake_case__:	List[Any]="gelu"   ,       snake_case__:	Optional[int]=1_024   ,       snake_case__:	List[Any]=0.1   ,       snake_case__:	int=0.0   ,       snake_case__:	List[str]=0.0   ,       snake_case__:	List[str]=0.02   ,       snake_case__:	Dict=2   ,       snake_case__:	int=0.0   ,       snake_case__:	Optional[int]=1   ,       snake_case__:	Tuple=0   ,       snake_case__:	Union[str, Any]=2   ,       snake_case__:	Union[List[int], int] = 512   ,       **snake_case__:	int   ,       )  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	vocab_size
         _lowercase     =	max_encoder_position_embeddings
         _lowercase     =	max_decoder_position_embeddings
         _lowercase     =	d_model
         _lowercase     =	encoder_ffn_dim
         _lowercase     =	encoder_layers
         _lowercase     =	encoder_attention_heads
         _lowercase     =	decoder_ffn_dim
         _lowercase     =	decoder_layers
         _lowercase     =	decoder_attention_heads
         _lowercase     =	dropout
         _lowercase     =	attention_dropout
         _lowercase     =	activation_dropout
         _lowercase     =	activation_function
         _lowercase     =	init_std
         _lowercase     =	encoder_layerdrop
         _lowercase     =	decoder_layerdrop
         _lowercase     =	classifier_dropout
         _lowercase     =	use_cache
         _lowercase     =	encoder_layers
         _lowercase     =	attention_window
  
         super().__init__(
             pad_token_id=snake_case__   ,       bos_token_id=snake_case__   ,       eos_token_id=snake_case__   ,       is_encoder_decoder=snake_case__   ,       decoder_start_token_id=snake_case__   ,       **snake_case__   ,       )
  