code: 
  '''simple docstring'''
  
  import gc
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers import VersatileDiffusionDualGuidedPipeline
  from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device
  
  
  UpperCamelCase_     			=       False
  
  
  @nightly
  @require_torch_gpu
  class   a_  (unittest.TestCase    ):
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           # clean up the VRAM after each test
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Tuple   				=					VersatileDiffusionDualGuidedPipeline.from_pretrained("""shi-labs/versatile-diffusion"""  )
           # remove text_unet
           pipe.remove_unused_weights()
           pipe.to(snake_case_  )
           pipe.set_progress_bar_config(disable=snake_case_  )
  
           _lowerCAmelCase       :  Optional[Any]   				=					load_image(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"""  )
  
           _lowerCAmelCase       :  Optional[Any]   				=					torch.manual_seed(0  )
           _lowerCAmelCase       :  Optional[Any]   				=					pipe(
               prompt="""first prompt"""   ,   image=snake_case_   ,   text_to_image_strength=0.75   ,   generator=snake_case_   ,   guidance_scale=7.5   ,   num_inference_steps=2   ,   output_type="""numpy"""   ,   ).images
  
           with tempfile.TemporaryDirectory() as tmpdirname:
             pipe.save_pretrained(snake_case_  )
             _lowerCAmelCase       :  Any   				=					VersatileDiffusionDualGuidedPipeline.from_pretrained(snake_case_  )
  
           pipe.to(snake_case_  )
           pipe.set_progress_bar_config(disable=snake_case_  )
  
           _lowerCAmelCase       :  Tuple   				=					generator.manual_seed(0  )
           _lowerCAmelCase       :  Any   				=					pipe(
               prompt="""first prompt"""   ,   image=snake_case_   ,   text_to_image_strength=0.75   ,   generator=snake_case_   ,   guidance_scale=7.5   ,   num_inference_steps=2   ,   output_type="""numpy"""   ,   ).images
  
           assert np.abs(image - new_image  ).sum() < 1E-5, "Models don't have the same forward pass"
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  int   				=					VersatileDiffusionDualGuidedPipeline.from_pretrained("""shi-labs/versatile-diffusion"""  )
           pipe.remove_unused_weights()
           pipe.to(snake_case_  )
           pipe.set_progress_bar_config(disable=snake_case_  )
  
           _lowerCAmelCase       :  Dict   				=					"""cyberpunk 2077"""
           _lowerCAmelCase       :  Tuple   				=					load_image(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"""  )
           _lowerCAmelCase       :  List[str]   				=					torch.manual_seed(0  )
           _lowerCAmelCase       :  str   				=					pipe(
               prompt=snake_case_   ,   image=snake_case_   ,   text_to_image_strength=0.75   ,   generator=snake_case_   ,   guidance_scale=7.5   ,   num_inference_steps=5_0   ,   output_type="""numpy"""   ,   ).images
  
           _lowerCAmelCase       :  List[Any]   				=					image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]
  
           assert image.shape == (1, 5_1_2, 5_1_2, 3)
           _lowerCAmelCase       :  Optional[Any]   				=					np.array([0.0787, 0.0849, 0.0826, 0.0812, 0.0807, 0.0795, 0.0818, 0.0798, 0.0779]  )
  
           assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2
  
  
  
style_context: 
  '''simple docstring'''
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int		)    ->						float:
    if common_ratio == 1:
      # Formula for sum if common ratio is 1
      return num_of_terms * first_term
  
    # Formula for finding sum of n terms of a GeometricProgression
    return (first_term / (1 - common_ratio)) * (1 - common_ratio**num_of_terms)
  
  
  