





import argparse
import os

import torch

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)


_lowerCamelCase      							=   {
    'sample_size': 32,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 2,
    'num_class_embeds': 1000,
    'block_out_channels': [32, 64],
    'attention_head_dim': 8,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'scale_shift',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

_lowerCamelCase      							=   {
    'sample_size': 64,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 3,
    'num_class_embeds': 1000,
    'block_out_channels': [192, 192 * 2, 192 * 3, 192 * 4],
    'attention_head_dim': 64,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'scale_shift',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

_lowerCamelCase      							=   {
    'sample_size': 256,
    'in_channels': 3,
    'out_channels': 3,
    'layers_per_block': 2,
    'num_class_embeds': None,
    'block_out_channels': [256, 256, 256 * 2, 256 * 2, 256 * 4, 256 * 4],
    'attention_head_dim': 64,
    'down_block_types': [
        'ResnetDownsampleBlock2D',
        'ResnetDownsampleBlock2D',
        'ResnetDownsampleBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
        'AttnDownBlock2D',
    ],
    'up_block_types': [
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'AttnUpBlock2D',
        'ResnetUpsampleBlock2D',
        'ResnetUpsampleBlock2D',
        'ResnetUpsampleBlock2D',
    ],
    'resnet_time_scale_shift': 'default',
    'upsample_type': 'resnet',
    'downsample_type': 'resnet',
}

_lowerCamelCase      							=   {
    'num_train_timesteps': 40,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}

_lowerCamelCase      							=   {
    'num_train_timesteps': 201,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}

_lowerCamelCase      							=   {
    'num_train_timesteps': 151,
    'sigma_min': 0.002,
    'sigma_max': 80.0,
}




def  __UpperCAmelCase(   lowercase_   ):
       if isinstance(lowercase_			,     lowercase_   ):
              return v
       if v.lower() in ("yes", "true", "t", "y", "1"):
              return True
       elif v.lower() in ("no", "false", "f", "n", "0"):
              return False
       else:
              raise argparse.ArgumentTypeError('''boolean value expected'''   )




def  __UpperCAmelCase(   lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     lowercase_=False   ):
       _lowerCamelCase				:  Any						=		checkpoint[F"""{old_prefix}.in_layers.0.weight"""]
       _lowerCamelCase				:  Any						=		checkpoint[F"""{old_prefix}.in_layers.0.bias"""]
       _lowerCamelCase				:  Optional[Any]						=		checkpoint[F"""{old_prefix}.in_layers.2.weight"""]
       _lowerCamelCase				:  int						=		checkpoint[F"""{old_prefix}.in_layers.2.bias"""]
       _lowerCamelCase				:  Tuple						=		checkpoint[F"""{old_prefix}.emb_layers.1.weight"""]
       _lowerCamelCase				:  Optional[int]						=		checkpoint[F"""{old_prefix}.emb_layers.1.bias"""]
       _lowerCamelCase				:  str						=		checkpoint[F"""{old_prefix}.out_layers.0.weight"""]
       _lowerCamelCase				:  Any						=		checkpoint[F"""{old_prefix}.out_layers.0.bias"""]
       _lowerCamelCase				:  List[str]						=		checkpoint[F"""{old_prefix}.out_layers.3.weight"""]
       _lowerCamelCase				:  str						=		checkpoint[F"""{old_prefix}.out_layers.3.bias"""]

       if has_skip:
              _lowerCamelCase				:  Optional[Any]						=		checkpoint[F"""{old_prefix}.skip_connection.weight"""]
              _lowerCamelCase				:  Dict						=		checkpoint[F"""{old_prefix}.skip_connection.bias"""]

       return new_checkpoint




def  __UpperCAmelCase(   lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     lowercase_=None   ):
       _lowerCamelCase,	_lowerCamelCase,	_lowerCamelCase				:  List[Any]						=		checkpoint[F"""{old_prefix}.qkv.weight"""].chunk(3			,     dim=0   )
       _lowerCamelCase,	_lowerCamelCase,	_lowerCamelCase				:  List[Any]						=		checkpoint[F"""{old_prefix}.qkv.bias"""].chunk(3			,     dim=0   )

       _lowerCamelCase				:  Optional[int]						=		checkpoint[F"""{old_prefix}.norm.weight"""]
       _lowerCamelCase				:  Any						=		checkpoint[F"""{old_prefix}.norm.bias"""]

       _lowerCamelCase				:  str						=		weight_q.squeeze(-1   ).squeeze(-1   )
       _lowerCamelCase				:  Dict						=		bias_q.squeeze(-1   ).squeeze(-1   )
       _lowerCamelCase				:  List[Any]						=		weight_k.squeeze(-1   ).squeeze(-1   )
       _lowerCamelCase				:  Tuple						=		bias_k.squeeze(-1   ).squeeze(-1   )
       _lowerCamelCase				:  List[Any]						=		weight_v.squeeze(-1   ).squeeze(-1   )
       _lowerCamelCase				:  Any						=		bias_v.squeeze(-1   ).squeeze(-1   )

       _lowerCamelCase				:  str						=		(
           checkpoint[F"""{old_prefix}.proj_out.weight"""].squeeze(-1   ).squeeze(-1   )
       )
       _lowerCamelCase				:  Union[str, Any]						=		checkpoint[F"""{old_prefix}.proj_out.bias"""].squeeze(-1   ).squeeze(-1   )

       return new_checkpoint




def  __UpperCAmelCase(   lowercase_			,     lowercase_   ):
       _lowerCamelCase				:  List[str]						=		torch.load(lowercase_			,     map_location='''cpu'''   )
       _lowerCamelCase				:  Any						=		{}

       _lowerCamelCase				:  Optional[int]						=		checkpoint['''time_embed.0.weight''']
       _lowerCamelCase				:  Optional[int]						=		checkpoint['''time_embed.0.bias''']
       _lowerCamelCase				:  List[Any]						=		checkpoint['''time_embed.2.weight''']
       _lowerCamelCase				:  List[Any]						=		checkpoint['''time_embed.2.bias''']

       if unet_config["num_class_embeds"] is not None:
              _lowerCamelCase				:  Optional[int]						=		checkpoint['''label_emb.weight''']

       _lowerCamelCase				:  int						=		checkpoint['''input_blocks.0.0.weight''']
       _lowerCamelCase				:  List[Any]						=		checkpoint['''input_blocks.0.0.bias''']

       _lowerCamelCase				:  str						=		unet_config['''down_block_types''']
       _lowerCamelCase				:  List[str]						=		unet_config['''layers_per_block''']
       _lowerCamelCase				:  Optional[int]						=		unet_config['''attention_head_dim''']
       _lowerCamelCase				:  Any						=		unet_config['''block_out_channels''']
       _lowerCamelCase				:  Optional[Any]						=		1
       _lowerCamelCase				:  Optional[Any]						=		channels_list[0]

       for i, layer_type in enumerate(lowercase_   ):
              _lowerCamelCase				:  Any						=		channels_list[i]
              _lowerCamelCase				:  int						=		current_channels != prev_channels
              if layer_type == "ResnetDownsampleBlock2D":
                     for j in range(lowercase_   ):
                            _lowerCamelCase				:  Tuple						=		F"""down_blocks.{i}.resnets.{j}"""
                            _lowerCamelCase				:  Any						=		F"""input_blocks.{current_layer}.0"""
                            _lowerCamelCase				:  List[str]						=		True if j == 0 and downsample_block_has_skip else False
                            _lowerCamelCase				:  Tuple						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     has_skip=lowercase_   )
                            current_layer += 1

              elif layer_type == "AttnDownBlock2D":
                     for j in range(lowercase_   ):
                            _lowerCamelCase				:  Optional[int]						=		F"""down_blocks.{i}.resnets.{j}"""
                            _lowerCamelCase				:  Optional[Any]						=		F"""input_blocks.{current_layer}.0"""
                            _lowerCamelCase				:  Union[str, Any]						=		True if j == 0 and downsample_block_has_skip else False
                            _lowerCamelCase				:  str						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     has_skip=lowercase_   )
                            _lowerCamelCase				:  List[Any]						=		F"""down_blocks.{i}.attentions.{j}"""
                            _lowerCamelCase				:  Optional[int]						=		F"""input_blocks.{current_layer}.1"""
                            _lowerCamelCase				:  Dict						=		convert_attention(
                                lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
                            current_layer += 1

              if i != len(lowercase_   ) - 1:
                     _lowerCamelCase				:  Union[str, Any]						=		F"""down_blocks.{i}.downsamplers.0"""
                     _lowerCamelCase				:  List[Any]						=		F"""input_blocks.{current_layer}.0"""
                     _lowerCamelCase				:  Optional[Any]						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
                     current_layer += 1

              _lowerCamelCase				:  List[Any]						=		current_channels

       # hardcoded the mid-block for now
       _lowerCamelCase				:  Optional[int]						=		'''mid_block.resnets.0'''
       _lowerCamelCase				:  int						=		'''middle_block.0'''
       _lowerCamelCase				:  Union[str, Any]						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
       _lowerCamelCase				:  List[Any]						=		'''mid_block.attentions.0'''
       _lowerCamelCase				:  Optional[Any]						=		'''middle_block.1'''
       _lowerCamelCase				:  Optional[int]						=		convert_attention(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
       _lowerCamelCase				:  Union[str, Any]						=		'''mid_block.resnets.1'''
       _lowerCamelCase				:  int						=		'''middle_block.2'''
       _lowerCamelCase				:  Any						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )

       _lowerCamelCase				:  Dict						=		0
       _lowerCamelCase				:  List[Any]						=		unet_config['''up_block_types''']

       for i, layer_type in enumerate(lowercase_   ):
              if layer_type == "ResnetUpsampleBlock2D":
                     for j in range(layers_per_block + 1   ):
                            _lowerCamelCase				:  Optional[int]						=		F"""up_blocks.{i}.resnets.{j}"""
                            _lowerCamelCase				:  Any						=		F"""output_blocks.{current_layer}.0"""
                            _lowerCamelCase				:  Tuple						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     has_skip=lowercase_   )
                            current_layer += 1

                     if i != len(lowercase_   ) - 1:
                            _lowerCamelCase				:  Optional[Any]						=		F"""up_blocks.{i}.upsamplers.0"""
                            _lowerCamelCase				:  List[str]						=		F"""output_blocks.{current_layer-1}.1"""
                            _lowerCamelCase				:  Any						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
              elif layer_type == "AttnUpBlock2D":
                     for j in range(layers_per_block + 1   ):
                            _lowerCamelCase				:  Tuple						=		F"""up_blocks.{i}.resnets.{j}"""
                            _lowerCamelCase				:  Any						=		F"""output_blocks.{current_layer}.0"""
                            _lowerCamelCase				:  List[Any]						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     has_skip=lowercase_   )
                            _lowerCamelCase				:  Dict						=		F"""up_blocks.{i}.attentions.{j}"""
                            _lowerCamelCase				:  List[str]						=		F"""output_blocks.{current_layer}.1"""
                            _lowerCamelCase				:  Optional[Any]						=		convert_attention(
                                lowercase_			,     lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )
                            current_layer += 1

                     if i != len(lowercase_   ) - 1:
                            _lowerCamelCase				:  List[str]						=		F"""up_blocks.{i}.upsamplers.0"""
                            _lowerCamelCase				:  Tuple						=		F"""output_blocks.{current_layer-1}.2"""
                            _lowerCamelCase				:  int						=		convert_resnet(lowercase_			,     lowercase_			,     lowercase_			,     lowercase_   )

       _lowerCamelCase				:  Dict						=		checkpoint['''out.0.weight''']
       _lowerCamelCase				:  Optional[Any]						=		checkpoint['''out.0.bias''']
       _lowerCamelCase				:  int						=		checkpoint['''out.2.weight''']
       _lowerCamelCase				:  List[str]						=		checkpoint['''out.2.bias''']

       return new_checkpoint


if __name__ == "__main__":
       _lowerCamelCase      							=   argparse.ArgumentParser()

       parser.add_argument('--unet_path', default=None, type=str, required=True, help='Path to the unet.pt to convert.')
       parser.add_argument(
           '--dump_path', default=None, type=str, required=True, help='Path to output the converted UNet model.'
       )
       parser.add_argument('--class_cond', default=True, type=str, help='Whether the model is class-conditional.')

       _lowerCamelCase      							=   parser.parse_args()
       _lowerCamelCase      							=   strabool(args.class_cond)

       _lowerCamelCase      							=   os.path.basename(args.unet_path)
       print(F'''Checkpoint: {ckpt_name}''')

       # Get U-Net config
       if "imagenet64" in ckpt_name:
              _lowerCamelCase      							=   IMAGENET_64_UNET_CONFIG
       elif "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)):
              _lowerCamelCase      							=   LSUN_256_UNET_CONFIG
       elif "test" in ckpt_name:
              _lowerCamelCase      							=   TEST_UNET_CONFIG
       else:
              raise ValueError(F'''Checkpoint type {ckpt_name} is not currently supported.''')

       if not args.class_cond:
              _lowerCamelCase      							=   None

       _lowerCamelCase      							=   con_pt_to_diffuser(args.unet_path, unet_config)

       _lowerCamelCase      							=   UNetaDModel(**unet_config)
       image_unet.load_state_dict(converted_unet_ckpt)

       # Get scheduler config
       if "cd" in ckpt_name or "test" in ckpt_name:
              _lowerCamelCase      							=   CD_SCHEDULER_CONFIG
       elif "ct" in ckpt_name and "imagenet64" in ckpt_name:
              _lowerCamelCase      							=   CT_IMAGENET_64_SCHEDULER_CONFIG
       elif "ct" in ckpt_name and "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)):
              _lowerCamelCase      							=   CT_LSUN_256_SCHEDULER_CONFIG
       else:
              raise ValueError(F'''Checkpoint type {ckpt_name} is not currently supported.''')

       _lowerCamelCase      							=   CMStochasticIterativeScheduler(**scheduler_config)

       _lowerCamelCase      							=   ConsistencyModelPipeline(unet=image_unet, scheduler=cm_scheduler)
       consistency_model.save_pretrained(args.dump_path)








import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import (
           AutoProcessor,
           BertTokenizerFast,
           BlipImageProcessor,
           GPTaTokenizer,
           InstructBlipProcessor,
           PreTrainedTokenizerFast,
       )







@require_vision
class       __A							(   unittest.TestCase	):




      """simple docstring"""







      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  List[Any]						=		tempfile.mkdtemp()

             _lowerCamelCase				:  List[str]						=		BlipImageProcessor()
             _lowerCamelCase				:  Union[str, Any]						=		GPTaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-GPT2Model''')
             _lowerCamelCase				:  Any						=		BertTokenizerFast.from_pretrained('''hf-internal-testing/tiny-random-bert''')

             _lowerCamelCase				:  Any						=		InstructBlipProcessor(a__   ,				a__   ,				a__)

             processor.save_pretrained(self.tmpdirname)


      def 					__snake_case      (		self   ,				**a__):



             """simple docstring"""





             return AutoProcessor.from_pretrained(self.tmpdirname   ,				**a__).tokenizer


      def 					__snake_case      (		self   ,				**a__):



             """simple docstring"""





             return AutoProcessor.from_pretrained(self.tmpdirname   ,				**a__).image_processor


      def 					__snake_case      (		self   ,				**a__):



             """simple docstring"""





             return AutoProcessor.from_pretrained(self.tmpdirname   ,				**a__).qformer_tokenizer


      def 					__snake_case      (		self):



             """simple docstring"""





             shutil.rmtree(self.tmpdirname)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  List[Any]						=		[np.random.randint(255   ,				size=(3, 30, 400)   ,				dtype=np.uinta)]

             _lowerCamelCase				:  List[str]						=		[Image.fromarray(np.moveaxis(a__   ,				0   ,				-1)) for x in image_inputs]

             return image_inputs


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Optional[Any]						=		InstructBlipProcessor(
                 tokenizer=self.get_tokenizer()   ,				image_processor=self.get_image_processor()   ,				qformer_tokenizer=self.get_qformer_tokenizer()   ,				)
             processor.save_pretrained(self.tmpdirname)

             _lowerCamelCase				:  Optional[int]						=		self.get_tokenizer(bos_token='''(BOS)'''   ,				eos_token='''(EOS)''')
             _lowerCamelCase				:  str						=		self.get_image_processor(do_normalize=a__   ,				padding_value=1.0)

             _lowerCamelCase				:  Tuple						=		InstructBlipProcessor.from_pretrained(
                 self.tmpdirname   ,				bos_token='''(BOS)'''   ,				eos_token='''(EOS)'''   ,				do_normalize=a__   ,				padding_value=1.0)

             self.assertEqual(processor.tokenizer.get_vocab()   ,				tokenizer_add_kwargs.get_vocab())
             self.assertIsInstance(processor.tokenizer   ,				a__)

             self.assertEqual(processor.image_processor.to_json_string()   ,				image_processor_add_kwargs.to_json_string())
             self.assertIsInstance(processor.image_processor   ,				a__)
             self.assertIsInstance(processor.qformer_tokenizer   ,				a__)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  List[str]						=		self.get_image_processor()
             _lowerCamelCase				:  Optional[int]						=		self.get_tokenizer()
             _lowerCamelCase				:  Any						=		self.get_qformer_tokenizer()

             _lowerCamelCase				:  Dict						=		InstructBlipProcessor(
                 tokenizer=a__   ,				image_processor=a__   ,				qformer_tokenizer=a__)

             _lowerCamelCase				:  List[Any]						=		self.prepare_image_inputs()

             _lowerCamelCase				:  List[str]						=		image_processor(a__   ,				return_tensors='''np''')
             _lowerCamelCase				:  List[Any]						=		processor(images=a__   ,				return_tensors='''np''')

             for key in input_feat_extract.keys():
                    self.assertAlmostEqual(input_feat_extract[key].sum()   ,				input_processor[key].sum()   ,				delta=1e-2)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Any						=		self.get_image_processor()
             _lowerCamelCase				:  Dict						=		self.get_tokenizer()
             _lowerCamelCase				:  int						=		self.get_qformer_tokenizer()

             _lowerCamelCase				:  Tuple						=		InstructBlipProcessor(
                 tokenizer=a__   ,				image_processor=a__   ,				qformer_tokenizer=a__)

             _lowerCamelCase				:  List[Any]						=		'''lower newer'''

             _lowerCamelCase				:  Any						=		processor(text=a__)

             _lowerCamelCase				:  Optional[int]						=		tokenizer(a__   ,				return_token_type_ids=a__)
             _lowerCamelCase				:  Optional[Any]						=		qformer_tokenizer(a__   ,				return_token_type_ids=a__)

             for key in encoded_tokens.keys():
                    self.assertListEqual(encoded_tokens[key]   ,				encoded_processor[key])

             for key in encoded_tokens_qformer.keys():
                    self.assertListEqual(encoded_tokens_qformer[key]   ,				encoded_processor['''qformer_''' + key])


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  List[Any]						=		self.get_image_processor()
             _lowerCamelCase				:  Optional[int]						=		self.get_tokenizer()
             _lowerCamelCase				:  Optional[Any]						=		self.get_qformer_tokenizer()

             _lowerCamelCase				:  List[Any]						=		InstructBlipProcessor(
                 tokenizer=a__   ,				image_processor=a__   ,				qformer_tokenizer=a__)

             _lowerCamelCase				:  List[Any]						=		'''lower newer'''
             _lowerCamelCase				:  Tuple						=		self.prepare_image_inputs()

             _lowerCamelCase				:  Tuple						=		processor(text=a__   ,				images=a__)

             self.assertListEqual(
                 list(inputs.keys())   ,				['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values''']   ,				)

             # test if it raises when no input is passed
             with pytest.raises(a__):
                    processor()


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  int						=		self.get_image_processor()
             _lowerCamelCase				:  List[Any]						=		self.get_tokenizer()
             _lowerCamelCase				:  List[Any]						=		self.get_qformer_tokenizer()

             _lowerCamelCase				:  Optional[Any]						=		InstructBlipProcessor(
                 tokenizer=a__   ,				image_processor=a__   ,				qformer_tokenizer=a__)

             _lowerCamelCase				:  List[Any]						=		[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

             _lowerCamelCase				:  Tuple						=		processor.batch_decode(a__)
             _lowerCamelCase				:  str						=		tokenizer.batch_decode(a__)

             self.assertListEqual(a__   ,				a__)



      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  List[str]						=		self.get_image_processor()
             _lowerCamelCase				:  Dict						=		self.get_tokenizer()
             _lowerCamelCase				:  str						=		self.get_qformer_tokenizer()

             _lowerCamelCase				:  str						=		InstructBlipProcessor(
                 tokenizer=a__   ,				image_processor=a__   ,				qformer_tokenizer=a__)

             _lowerCamelCase				:  str						=		'''lower newer'''
             _lowerCamelCase				:  str						=		self.prepare_image_inputs()

             _lowerCamelCase				:  List[Any]						=		processor(text=a__   ,				images=a__)

             self.assertListEqual(
                 list(inputs.keys())   ,				['''input_ids''', '''attention_mask''', '''qformer_input_ids''', '''qformer_attention_mask''', '''pixel_values''']   ,				)

