

import timeit






class 							A_				:


     def __init__(							self    :	int    ,						UpperCAmelCase    :	List[str]      )							->			Dict:
      if isinstance(UpperCAmelCase    ,						UpperCAmelCase      ):  # Initializes a matrix identical to the one provided.
       __lowerCAmelCase:     Optional[Any]     			=   arg
       __lowerCAmelCase:     Any     			=   len(UpperCAmelCase      )
      else:  # Initializes a square matrix of the given size and set values to zero.
       __lowerCAmelCase:     int     			=   arg
       __lowerCAmelCase:     str     			=   [[0 for _ in range(self.n      )] for _ in range(self.n      )]


     def __mul__(							self    :	int    ,						UpperCAmelCase    :	int      )							->			Union[str, Any]:
      __lowerCAmelCase:     Dict     			=   Matrix(self.n      )
      for i in range(self.n      ):
       for j in range(self.n      ):
        for k in range(self.n      ):
         matrix.t[i][j] += self.t[i][k] * b.t[k][j]
      return matrix







def _a				( SCREAMING_SNAKE_CASE	:    List[str]					,      SCREAMING_SNAKE_CASE	:    Tuple	)					->					List[Any]:

 """simple docstring"""






 __lowerCAmelCase:     List[str]     			=   Matrix([[1, 0], [0, 1]]	)
 while b > 0:
  if b & 1:
   matrix *= a
  a *= a
  b >>= 1
 return matrix







def _a				( SCREAMING_SNAKE_CASE	:    str					,      SCREAMING_SNAKE_CASE	:    Dict					,      SCREAMING_SNAKE_CASE	:    str	)					->					str:

 """simple docstring"""






 if n == 1:
  return fa
 elif n == 2:
  return fa
 __lowerCAmelCase:     Tuple     			=   Matrix([[1, 1], [1, 0]]	)
 __lowerCAmelCase:     List[Any]     			=   modular_exponentiation(SCREAMING_SNAKE_CASE					,      n - 2	)
 return fa * matrix.t[0][0] + fa * matrix.t[0][1]







def _a				( SCREAMING_SNAKE_CASE	:    List[str]					,      SCREAMING_SNAKE_CASE	:    int					,      SCREAMING_SNAKE_CASE	:    Optional[Any]	)					->					List[str]:

 """simple docstring"""






 if n == 1:
  return fa
 elif n == 2:
  return fa

 __lowerCAmelCase:     Union[str, Any]     			=   fa
 __lowerCAmelCase:     Optional[Any]     			=   fa
 n -= 2

 while n > 0:
  __lowerCAmelCase			,							__lowerCAmelCase:     Tuple     			=   fn_a + fn_a, fn_a
  n -= 1

 return fn_a







def _a				( )					->					Optional[Any]:

 """simple docstring"""






 __lowerCAmelCase:     Optional[int]     			=   '\nfrom random import randint\nfrom __main__ import fibonacci_with_matrix_exponentiation\n'
 __lowerCAmelCase:     List[Any]     			=   'fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)'
 __lowerCAmelCase:     Any     			=   timeit.timeit(setup=SCREAMING_SNAKE_CASE					,      stmt=SCREAMING_SNAKE_CASE					,      number=1_00	)
 print('With matrix exponentiation the average execution time is '					,      exec_time / 1_00	)
 return exec_time







def _a				( )					->					int:

 """simple docstring"""






 __lowerCAmelCase:     Optional[Any]     			=   '\nfrom random import randint\nfrom __main__ import simple_fibonacci\n'
 __lowerCAmelCase:     Any     			=   'simple_fibonacci(randint(1,70000), 1, 1)'
 __lowerCAmelCase:     Optional[int]     			=   timeit.timeit(setup=SCREAMING_SNAKE_CASE					,      stmt=SCREAMING_SNAKE_CASE					,      number=1_00	)
 print(
     'Without matrix exponentiation the average execution time is '					,      exec_time / 1_00	)
 return exec_time







def _a				( )					->					Optional[Any]:

 """simple docstring"""






 matrix_exponentiation_time()
 simple_fibonacci_time()


if __name__ == "__main__":
  main()








from typing import Union

import torch
from PIL import Image
from torchvision import transforms as tfms
from tqdm.auto import tqdm
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)






class 							A_				(	snake_case__      ):


     def __init__(							self    :	List[Any]    ,						UpperCAmelCase    :	AutoencoderKL    ,						UpperCAmelCase    :	CLIPTextModel    ,						UpperCAmelCase    :	CLIPTokenizer    ,						UpperCAmelCase    :	UNetaDConditionModel    ,						UpperCAmelCase    :	Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler]    ,						)							->			Tuple:
      super().__init__()

      self.register_modules(vae=UpperCAmelCase    ,						text_encoder=UpperCAmelCase    ,						tokenizer=UpperCAmelCase    ,						unet=UpperCAmelCase    ,						scheduler=UpperCAmelCase      )


     def 						UpperCAmelCase						(							self    :	str    ,						UpperCAmelCase    :	Dict      )							->			Any:
      with torch.no_grad():
       __lowerCAmelCase:     Tuple     			=   self.vae.encode(tfms.ToTensor()(UpperCAmelCase      ).unsqueeze(0      ).to(self.device      ) * 2 - 1      )
       __lowerCAmelCase:     Tuple     			=   0.18215 * latent.latent_dist.sample()
      return latent


     def 						UpperCAmelCase						(							self    :	List[Any]    ,						UpperCAmelCase    :	str      )							->			int:
      __lowerCAmelCase:     Optional[Any]     			=   (1 / 0.18215) * latent
      with torch.no_grad():
       __lowerCAmelCase:     str     			=   self.vae.decode(UpperCAmelCase      ).sample
      __lowerCAmelCase:     Any     			=   (img / 2 + 0.5).clamp(0    ,						1      )
      __lowerCAmelCase:     Optional[Any]     			=   img.detach().cpu().permute(0    ,						2    ,						3    ,						1      ).numpy()
      __lowerCAmelCase:     List[str]     			=   (img * 2_5_5).round().astype('uint8'      )
      return Image.fromarray(img[0]      )


     def 						UpperCAmelCase						(							self    :	Optional[Any]    ,						UpperCAmelCase    :	Tuple      )							->			str:
      __lowerCAmelCase:     Dict     			=   self.tokenizer(
          UpperCAmelCase    ,						padding='max_length'    ,						max_length=self.tokenizer.model_max_length    ,						truncation=UpperCAmelCase    ,						return_tensors='pt'    ,						)

      __lowerCAmelCase:     Any     			=   self.text_encoder(text_input.input_ids.to(self.device      )      )[0]

      __lowerCAmelCase:     List[str]     			=   self.tokenizer(
          ''    ,						padding='max_length'    ,						max_length=self.tokenizer.model_max_length    ,						truncation=UpperCAmelCase    ,						return_tensors='pt'    ,						)

      __lowerCAmelCase:     str     			=   self.text_encoder(uncond_input.input_ids.to(self.device      )      )[0]

      return torch.cat([uncond_embedding, text_embedding]      )


     def __call__(							self    :	Optional[int]    ,						UpperCAmelCase    :	Image.Image    ,						UpperCAmelCase    :	str    ,						UpperCAmelCase    :	float = 0.3    ,						UpperCAmelCase    :	float = 0.6    ,						UpperCAmelCase    :	float = 0.5    ,						UpperCAmelCase    :	int = 4_2    ,						UpperCAmelCase    :	int = 5_0    ,						UpperCAmelCase    :	float = 7.5    ,						)							->			Image.Image:
      __lowerCAmelCase:     Optional[int]     			=   steps - int(kmin * steps      )
      __lowerCAmelCase:     Dict     			=   steps - int(kmax * steps      )

      __lowerCAmelCase:     Union[str, Any]     			=   self.prep_text(UpperCAmelCase      )

      self.scheduler.set_timesteps(UpperCAmelCase      )

      __lowerCAmelCase			,							__lowerCAmelCase:     str     			=   img.size
      __lowerCAmelCase:     List[Any]     			=   self.encode(UpperCAmelCase      )

      torch.manual_seed(UpperCAmelCase      )
      __lowerCAmelCase:     Optional[int]     			=   torch.randn(
          (1, self.unet.config.in_channels, height // 8, width // 8)    ,						).to(self.device      )

      __lowerCAmelCase:     int     			=   self.scheduler.add_noise(
          UpperCAmelCase    ,						UpperCAmelCase    ,						timesteps=self.scheduler.timesteps[tmax]    ,						)

      __lowerCAmelCase:     Tuple     			=   torch.cat([latents] * 2      )

      __lowerCAmelCase:     int     			=   self.scheduler.scale_model_input(UpperCAmelCase    ,						self.scheduler.timesteps[tmax]      )

      with torch.no_grad():
       __lowerCAmelCase:     List[str]     			=   self.unet(
           UpperCAmelCase    ,						self.scheduler.timesteps[tmax]    ,						encoder_hidden_states=UpperCAmelCase    ,						).sample

      __lowerCAmelCase			,							__lowerCAmelCase:     Optional[Any]     			=   pred.chunk(2      )
      __lowerCAmelCase:     Union[str, Any]     			=   pred_uncond + guidance_scale * (pred_text - pred_uncond)

      __lowerCAmelCase:     List[str]     			=   self.scheduler.step(UpperCAmelCase    ,						self.scheduler.timesteps[tmax]    ,						UpperCAmelCase      ).prev_sample

      for i, t in enumerate(tqdm(self.scheduler.timesteps      )      ):
       if i > tmax:
        if i < tmin:  # layout generation phase
         __lowerCAmelCase:     Optional[Any]     			=   self.scheduler.add_noise(
             UpperCAmelCase    ,						UpperCAmelCase    ,						timesteps=UpperCAmelCase    ,						)

         __lowerCAmelCase:     List[Any]     			=   (mix_factor * latents) + (
             1 - mix_factor
         ) * orig_latents  # interpolating between layout noise and conditionally generated noise to preserve layout sematics
         __lowerCAmelCase:     Optional[Any]     			=   torch.cat([input] * 2      )

        else:  # content generation phase
         __lowerCAmelCase:     str     			=   torch.cat([latents] * 2      )

        __lowerCAmelCase:     List[Any]     			=   self.scheduler.scale_model_input(UpperCAmelCase    ,						UpperCAmelCase      )

        with torch.no_grad():
         __lowerCAmelCase:     Any     			=   self.unet(
             UpperCAmelCase    ,						UpperCAmelCase    ,						encoder_hidden_states=UpperCAmelCase    ,						).sample

        __lowerCAmelCase			,							__lowerCAmelCase:     Optional[int]     			=   pred.chunk(2      )
        __lowerCAmelCase:     Union[str, Any]     			=   pred_uncond + guidance_scale * (pred_text - pred_uncond)

        __lowerCAmelCase:     List[str]     			=   self.scheduler.step(UpperCAmelCase    ,						UpperCAmelCase    ,						UpperCAmelCase      ).prev_sample

      return self.decode(UpperCAmelCase      )





