

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class   __lowercase      (_UpperCAmelCase		,   _UpperCAmelCase		,   _UpperCAmelCase		,   unittest.TestCase ):
 _UpperCamelCase			  =  StableDiffusionInstructPixaPixPipeline
 _UpperCamelCase			  =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width""", """cross_attention_kwargs"""}
 _UpperCamelCase			  =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 _UpperCamelCase			  =  IMAGE_TO_IMAGE_IMAGE_PARAMS
 _UpperCamelCase			  =  IMAGE_TO_IMAGE_IMAGE_PARAMS
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       torch.manual_seed(0					)
       __lowerCAmelCase					:						Tuple					=					UNetaDConditionModel(
           block_out_channels=(32, 64)      ,							layers_per_block=2      ,							sample_size=32      ,							in_channels=8      ,							out_channels=4      ,							down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')      ,							up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')      ,							cross_attention_dim=32      ,							)
       __lowerCAmelCase					:						List[Any]					=					PNDMScheduler(skip_prk_steps=A_					)
       torch.manual_seed(0					)
       __lowerCAmelCase					:						Tuple					=					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      ,							)
       torch.manual_seed(0					)
       __lowerCAmelCase					:						Any					=					CLIPTextConfig(
           bos_token_id=0      ,							eos_token_id=2      ,							hidden_size=32      ,							intermediate_size=37      ,							layer_norm_eps=1e-05      ,							num_attention_heads=4      ,							num_hidden_layers=5      ,							pad_token_id=1      ,							vocab_size=1000      ,							)
       __lowerCAmelCase					:						Optional[Any]					=					CLIPTextModel(A_					)
       __lowerCAmelCase					:						Optional[Any]					=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

       __lowerCAmelCase					:						Dict					=					{
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''safety_checker''': None,
           '''feature_extractor''': None,
       }
       return components
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_=0					)					->List[str]:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					floats_tensor((1, 3, 32, 32)      ,							rng=random.Random(A_					)					).to(A_					)
       __lowerCAmelCase					:						Optional[int]					=					image.cpu().permute(0      ,							2      ,							3      ,							1					)[0]
       __lowerCAmelCase					:						Any					=					Image.fromarray(np.uinta(A_					)					).convert('''RGB'''					)
       if str(A_					).startswith('''mps'''					):
             __lowerCAmelCase					:						Dict					=					torch.manual_seed(A_					)
       else:
             __lowerCAmelCase					:						int					=					torch.Generator(device=A_					).manual_seed(A_					)
       __lowerCAmelCase					:						List[Any]					=					{
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''image''': image,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 6.0,
           '''image_guidance_scale''': 1,
           '''output_type''': '''numpy''',
       }
       return inputs
 def 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       __lowerCAmelCase					:						Dict					=					self.get_dummy_components()
       __lowerCAmelCase					:						List[str]					=					StableDiffusionInstructPixaPixPipeline(**A_					)
       __lowerCAmelCase					:						int					=					sd_pipe.to(A_					)
       sd_pipe.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						List[str]					=					self.get_dummy_inputs(A_					)
       __lowerCAmelCase					:						Union[str, Any]					=					sd_pipe(**A_					).images
       __lowerCAmelCase					:						Dict					=					image[0, -3:, -3:, -1]
       assert image.shape == (1, 32, 32, 3)
       __lowerCAmelCase					:						List[Any]					=					np.array([0.7_526, 0.3_750, 0.4_547, 0.6_117, 0.5_866, 0.5_016, 0.4_327, 0.5_642, 0.4_815]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       __lowerCAmelCase					:						str					=					self.get_dummy_components()
       __lowerCAmelCase					:						List[str]					=					StableDiffusionInstructPixaPixPipeline(**A_					)
       __lowerCAmelCase					:						List[str]					=					sd_pipe.to(A_					)
       sd_pipe.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						int					=					self.get_dummy_inputs(A_					)
       __lowerCAmelCase					:						int					=					'''french fries'''
       __lowerCAmelCase					:						str					=					sd_pipe(**A_      ,							negative_prompt=A_					)
       __lowerCAmelCase					:						List[Any]					=					output.images
       __lowerCAmelCase					:						Union[str, Any]					=					image[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       __lowerCAmelCase					:						int					=					np.array([0.7_511, 0.3_642, 0.4_553, 0.6_236, 0.5_797, 0.5_013, 0.4_343, 0.5_611, 0.4_831]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[Any]					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       __lowerCAmelCase					:						Any					=					self.get_dummy_components()
       __lowerCAmelCase					:						int					=					StableDiffusionInstructPixaPixPipeline(**A_					)
       __lowerCAmelCase					:						Optional[int]					=					sd_pipe.to(A_					)
       sd_pipe.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						List[Any]					=					self.get_dummy_inputs(A_					)
       __lowerCAmelCase					:						Tuple					=					[inputs['''prompt''']] * 2

       __lowerCAmelCase					:						List[Any]					=					np.array(inputs['''image''']					).astype(np.floataa					) / 255.0
       __lowerCAmelCase					:						Tuple					=					torch.from_numpy(A_					).unsqueeze(0					).to(A_					)
       __lowerCAmelCase					:						int					=					image / 2 + 0.5
       __lowerCAmelCase					:						int					=					image.permute(0      ,							3      ,							1      ,							2					)
       __lowerCAmelCase					:						Optional[int]					=					image.repeat(2      ,							1      ,							1      ,							1					)

       __lowerCAmelCase					:						int					=					sd_pipe(**A_					).images
       __lowerCAmelCase					:						List[Any]					=					image[-1, -3:, -3:, -1]

       assert image.shape == (2, 32, 32, 3)
       __lowerCAmelCase					:						Any					=					np.array([0.5_812, 0.5_748, 0.5_222, 0.5_908, 0.5_695, 0.7_174, 0.6_804, 0.5_523, 0.5_579]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
       __lowerCAmelCase					:						List[Any]					=					self.get_dummy_components()
       __lowerCAmelCase					:						Any					=					EulerAncestralDiscreteScheduler(
           beta_start=0.00_085      ,							beta_end=0.012      ,							beta_schedule='''scaled_linear'''					)
       __lowerCAmelCase					:						int					=					StableDiffusionInstructPixaPixPipeline(**A_					)
       __lowerCAmelCase					:						Dict					=					sd_pipe.to(A_					)
       sd_pipe.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						Optional[int]					=					self.get_dummy_inputs(A_					)
       __lowerCAmelCase					:						Optional[Any]					=					sd_pipe(**A_					).images
       __lowerCAmelCase					:						Optional[Any]					=					image[0, -3:, -3:, -1]

       __lowerCAmelCase					:						List[str]					=					[round(A_      ,							4					) for x in image_slice.flatten().tolist()]
       print(''','''.join([str(A_					) for x in slice]					)					)

       assert image.shape == (1, 32, 32, 3)
       __lowerCAmelCase					:						List[str]					=					np.array([0.7_417, 0.3_842, 0.4_732, 0.5_776, 0.5_891, 0.5_139, 0.4_052, 0.5_673, 0.4_986]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





       super().test_inference_batch_single_identical(expected_max_diff=3e-3					)





 def 	UpperCamelCase__  (							self					)					->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase					:						List[Any]					=					self.get_dummy_components()
       __lowerCAmelCase					:						Any					=					StableDiffusionInstructPixaPixPipeline(**A_					)
       __lowerCAmelCase					:						Dict					=					VaeImageProcessor(do_resize=A_      ,							do_normalize=A_					)
       __lowerCAmelCase					:						List[str]					=					pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						List[str]					=					pipe(**self.get_dummy_inputs_by_type(A_      ,							input_image_type='''pt'''					)					)[0]

       __lowerCAmelCase					:						Any					=					components['''vae''']
       __lowerCAmelCase					:						Optional[Any]					=					self.get_dummy_inputs_by_type(A_      ,							input_image_type='''pt'''					)

       for image_param in self.image_latents_params:
             if image_param in inputs.keys():
                   __lowerCAmelCase					:						Any					=					vae.encode(inputs[image_param]					).latent_dist.mode()

       __lowerCAmelCase					:						Optional[int]					=					pipe(**A_					)[0]

       __lowerCAmelCase					:						Optional[Any]					=					np.abs(out - out_latents_inputs					).max()
       self.assertLess(A_      ,							1e-4      ,							'''passing latents as image input generate different result from passing image'''					)







@slow
@require_torch_gpu
class   __lowercase      (unittest.TestCase ):
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
 def 	UpperCamelCase__  (							self      ,							A_=0					)					->List[str]:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					torch.manual_seed(A_					)
       __lowerCAmelCase					:						Optional[int]					=					load_image(
           '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg'''					)
       __lowerCAmelCase					:						Optional[int]					=					{
           '''prompt''': '''turn him into a cyborg''',
           '''image''': image,
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''image_guidance_scale''': 1.0,
           '''output_type''': '''numpy''',
       }
       return inputs
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           '''timbrooks/instruct-pix2pix'''      ,							safety_checker=A_					)
       pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing()

       __lowerCAmelCase					:						int					=					self.get_inputs()
       __lowerCAmelCase					:						Union[str, Any]					=					pipe(**A_					).images
       __lowerCAmelCase					:						str					=					image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 512, 3)
       __lowerCAmelCase					:						Optional[Any]					=					np.array([0.5_902, 0.6_015, 0.6_027, 0.5_983, 0.6_092, 0.6_061, 0.5_765, 0.5_785, 0.5_555]					)

       assert np.abs(expected_slice - image_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           '''timbrooks/instruct-pix2pix'''      ,							safety_checker=A_					)
       __lowerCAmelCase					:						Tuple					=					LMSDiscreteScheduler.from_config(pipe.scheduler.config					)
       pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing()

       __lowerCAmelCase					:						Optional[Any]					=					self.get_inputs()
       __lowerCAmelCase					:						Dict					=					pipe(**A_					).images
       __lowerCAmelCase					:						Tuple					=					image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 512, 3)
       __lowerCAmelCase					:						Optional[Any]					=					np.array([0.6_578, 0.6_817, 0.6_972, 0.6_761, 0.6_856, 0.6_916, 0.6_428, 0.6_516, 0.6_301]					)

       assert np.abs(expected_slice - image_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           '''timbrooks/instruct-pix2pix'''      ,							safety_checker=A_					)
       __lowerCAmelCase					:						List[Any]					=					DDIMScheduler.from_config(pipe.scheduler.config					)
       pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing()

       __lowerCAmelCase					:						Optional[Any]					=					self.get_inputs()
       __lowerCAmelCase					:						Union[str, Any]					=					pipe(**A_					).images
       __lowerCAmelCase					:						Union[str, Any]					=					image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 512, 512, 3)
       __lowerCAmelCase					:						Optional[Any]					=					np.array([0.3_828, 0.3_834, 0.3_818, 0.3_792, 0.3_865, 0.3_752, 0.3_792, 0.3_847, 0.3_753]					)

       assert np.abs(expected_slice - image_slice					).max() < 1e-3
 def 	UpperCamelCase__  (							self					)					->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					0

       def callback_fn(A_      ,							A_      ,							A_					) -> None:
             __lowerCAmelCase					:						Union[str, Any]					=					True
             nonlocal number_of_steps
             number_of_steps += 1
             if step == 1:
                   __lowerCAmelCase					:						Any					=					latents.detach().cpu().numpy()
                   assert latents.shape == (1, 4, 64, 64)
                   __lowerCAmelCase					:						List[str]					=					latents[0, -3:, -3:, -1]
                   __lowerCAmelCase					:						Any					=					np.array([-0.2_463, -0.4_644, -0.9_756, 1.5_176, 1.4_414, 0.7_866, 0.9_897, 0.8_521, 0.7_983]					)

                   assert np.abs(latents_slice.flatten() - expected_slice					).max() < 5e-2
             elif step == 2:
                   __lowerCAmelCase					:						int					=					latents.detach().cpu().numpy()
                   assert latents.shape == (1, 4, 64, 64)
                   __lowerCAmelCase					:						List[str]					=					latents[0, -3:, -3:, -1]
                   __lowerCAmelCase					:						Any					=					np.array([-0.2_644, -0.4_626, -0.9_653, 1.5_176, 1.4_551, 0.7_686, 0.9_805, 0.8_452, 0.8_115]					)

                   assert np.abs(latents_slice.flatten() - expected_slice					).max() < 5e-2

       __lowerCAmelCase					:						List[str]					=					False

       __lowerCAmelCase					:						Union[str, Any]					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           '''timbrooks/instruct-pix2pix'''      ,							safety_checker=A_      ,							torch_dtype=torch.floataa					)
       __lowerCAmelCase					:						List[Any]					=					pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing()

       __lowerCAmelCase					:						Optional[int]					=					self.get_inputs()
       pipe(**A_      ,							callback=A_      ,							callback_steps=1					)
       assert callback_fn.has_been_called
       assert number_of_steps == 3
 def 	UpperCamelCase__  (							self					)					->List[str]:



       '''simple docstring'''





       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       __lowerCAmelCase					:						Dict					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           '''timbrooks/instruct-pix2pix'''      ,							safety_checker=A_      ,							torch_dtype=torch.floataa					)
       __lowerCAmelCase					:						str					=					pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing(1					)
       pipe.enable_sequential_cpu_offload()

       __lowerCAmelCase					:						Union[str, Any]					=					self.get_inputs()
       __lowerCAmelCase					:						int					=					pipe(**A_					)

       __lowerCAmelCase					:						Dict					=					torch.cuda.max_memory_allocated()
       # make sure that less than 2.2 GB is allocated
       assert mem_bytes < 2.2 * 10**9





 def 	UpperCamelCase__  (							self					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					self.get_inputs()
       # resize to resolution that is divisible by 8 but not 16 or 32
       __lowerCAmelCase					:						List[str]					=					inputs['''image'''].resize((504, 504)					)

       __lowerCAmelCase					:						Tuple					=					'''timbrooks/instruct-pix2pix'''
       __lowerCAmelCase					:						List[str]					=					StableDiffusionInstructPixaPixPipeline.from_pretrained(
           A_      ,							safety_checker=A_      ,							)
       pipe.to(A_					)
       pipe.set_progress_bar_config(disable=A_					)
       pipe.enable_attention_slicing()

       __lowerCAmelCase					:						List[Any]					=					pipe(**A_					)
       __lowerCAmelCase					:						Optional[int]					=					output.images[0]

       __lowerCAmelCase					:						Any					=					image[255:258, 383:386, -1]

       assert image.shape == (504, 504, 3)
       __lowerCAmelCase					:						int					=					np.array([0.2_726, 0.2_529, 0.2_664, 0.2_655, 0.2_641, 0.2_642, 0.2_591, 0.2_649, 0.2_590]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 5e-3





from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						str					=					[]
      __lowerCAmelCase					:						List[Any]					=					[]
      __lowerCAmelCase					:						str					=					[]

      for rt in rc.restypes:
            __lowerCAmelCase					:						List[Any]					=					rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
            restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]						)
            __lowerCAmelCase					:						List[str]					=					{name: i for i, name in enumerate(lowercase__						)}
            restype_atomaa_to_atomaa_list.append(
                [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]						)

            restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]						)

      # Add dummy mapping for restype 'UNK'
      restype_atomaa_to_atomaa_list.append([0] * 1_4						)
      restype_atomaa_to_atomaa_list.append([0] * 3_7						)
      restype_atomaa_mask_list.append([0.0] * 1_4						)

      __lowerCAmelCase					:						List[Any]					=					torch.tensor(
          lowercase__   ,	dtype=torch.intaa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						Optional[Any]					=					torch.tensor(
          lowercase__   ,	dtype=torch.intaa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						Tuple					=					torch.tensor(
          lowercase__   ,	dtype=torch.floataa   ,	device=protein['''aatype'''].device   ,	)
      __lowerCAmelCase					:						List[Any]					=					protein['''aatype'''].to(torch.long						)

      # create the mapping for (residx, atom14) --> atom37, i.e. an array
      # with shape (num_res, 14) containing the atom37 indices for this protein
      __lowerCAmelCase					:						Any					=					restype_atomaa_to_atomaa[protein_aatype]
      __lowerCAmelCase					:						Union[str, Any]					=					restype_atomaa_mask[protein_aatype]

      __lowerCAmelCase					:						int					=					residx_atomaa_mask
      __lowerCAmelCase					:						List[str]					=					residx_atomaa_to_atomaa.long()

      # create the gather indices for mapping back
      __lowerCAmelCase					:						int					=					restype_atomaa_to_atomaa[protein_aatype]
      __lowerCAmelCase					:						Union[str, Any]					=					residx_atomaa_to_atomaa.long()

      # create the corresponding mask
      __lowerCAmelCase					:						str					=					torch.zeros([2_1, 3_7]   ,	dtype=torch.floataa   ,	device=protein['''aatype'''].device						)
      for restype, restype_letter in enumerate(rc.restypes						):
            __lowerCAmelCase					:						Optional[int]					=					rc.restype_atoa[restype_letter]
            __lowerCAmelCase					:						Optional[Any]					=					rc.residue_atoms[restype_name]
            for atom_name in atom_names:
                  __lowerCAmelCase					:						str					=					rc.atom_order[atom_name]
                  __lowerCAmelCase					:						List[Any]					=					1

      __lowerCAmelCase					:						Union[str, Any]					=					restype_atomaa_mask[protein_aatype]
      __lowerCAmelCase					:						Any					=					residx_atomaa_mask

      return protein







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						Dict					=					tree_map(lambda lowercase__						: torch.tensor(lowercase__   ,	device=batch['''aatype'''].device						)   ,	lowercase__   ,	np.ndarray						)
      __lowerCAmelCase					:						Tuple					=					tensor_tree_map(lambda lowercase__						: np.array(lowercase__						)   ,	make_atomaa_masks(lowercase__						)						)
      return out


