
'''simple docstring'''



import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD
def  lowerCAmelCase_						(					)  ->  Optional[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE  			=					'''https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'''
   _SCREAMING_SNAKE_CASE  			=					Image.open(requests.get(SCREAMING_SNAKE_CASE_     ,   stream=SCREAMING_SNAKE_CASE_    ).raw    ).convert("""RGB"""    )

   return image
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_    )  ->  Dict:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE  			=					[]
   # fmt: off

   # vision encoder
   rename_keys.append(("""visual_encoder.cls_token""", """vision_model.embeddings.class_embedding""")    )
   rename_keys.append(("""visual_encoder.pos_embed""", """vision_model.embeddings.position_embedding""")    )
   rename_keys.append(("""visual_encoder.patch_embed.proj.weight""", """vision_model.embeddings.patch_embedding.weight""")    )
   rename_keys.append(("""visual_encoder.patch_embed.proj.bias""", """vision_model.embeddings.patch_embedding.bias""")    )
   rename_keys.append(("""ln_vision.weight""", """vision_model.post_layernorm.weight""")    )
   rename_keys.append(("""ln_vision.bias""", """vision_model.post_layernorm.bias""")    )

   for i in range(config.vision_config.num_hidden_layers    ):
      rename_keys.append((F"visual_encoder.blocks.{i}.norm1.weight", F"vision_model.encoder.layers.{i}.layer_norm1.weight")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.norm1.bias", F"vision_model.encoder.layers.{i}.layer_norm1.bias")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.norm2.weight", F"vision_model.encoder.layers.{i}.layer_norm2.weight")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.norm2.bias", F"vision_model.encoder.layers.{i}.layer_norm2.bias")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.attn.qkv.weight", F"vision_model.encoder.layers.{i}.self_attn.qkv.weight")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.weight", F"vision_model.encoder.layers.{i}.self_attn.projection.weight",)    )
      rename_keys.append((F"visual_encoder.blocks.{i}.attn.proj.bias", F"vision_model.encoder.layers.{i}.self_attn.projection.bias")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.weight", F"vision_model.encoder.layers.{i}.mlp.fc1.weight")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc1.bias", F"vision_model.encoder.layers.{i}.mlp.fc1.bias")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.weight", F"vision_model.encoder.layers.{i}.mlp.fc2.weight")    )
      rename_keys.append((F"visual_encoder.blocks.{i}.mlp.fc2.bias", F"vision_model.encoder.layers.{i}.mlp.fc2.bias")    )

   # QFormer
   rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.weight""", """qformer.layernorm.weight""")    )
   rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.bias""", """qformer.layernorm.bias""")    )

   # fmt: on
   return rename_keys
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )  ->  Optional[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE  			=					dct.pop(SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					val
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )  ->  Union[str, Any]:




   """simple docstring"""
   for i in range(config.vision_config.num_hidden_layers    ):
      # read in original q and v biases
      _SCREAMING_SNAKE_CASE  			=					state_dict.pop(F"visual_encoder.blocks.{i}.attn.q_bias"    )
      _SCREAMING_SNAKE_CASE  			=					state_dict.pop(F"visual_encoder.blocks.{i}.attn.v_bias"    )

      # next, set bias in the state dict
      _SCREAMING_SNAKE_CASE  			=					torch.cat((q_bias, torch.zeros_like(SCREAMING_SNAKE_CASE_     ,   requires_grad=SCREAMING_SNAKE_CASE_    ), v_bias)    )
      _SCREAMING_SNAKE_CASE  			=					qkv_bias
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )  ->  List[str]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE  			=					3_64 if '''coco''' in model_name else 2_24
   _SCREAMING_SNAKE_CASE  			=					BlipaVisionConfig(image_size=SCREAMING_SNAKE_CASE_    ).to_dict()

   # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
   # seems like flan-T5 models don't have bos_token_id properly set?
   if "opt-2.7b" in model_name:
      _SCREAMING_SNAKE_CASE  			=					OPTConfig.from_pretrained("""facebook/opt-2.7b"""     ,   eos_token_id=SCREAMING_SNAKE_CASE_    ).to_dict()
   elif "opt-6.7b" in model_name:
      _SCREAMING_SNAKE_CASE  			=					OPTConfig.from_pretrained("""facebook/opt-6.7b"""     ,   eos_token_id=SCREAMING_SNAKE_CASE_    ).to_dict()
   elif "t5-xl" in model_name:
      _SCREAMING_SNAKE_CASE  			=					TaConfig.from_pretrained("""google/flan-t5-xl"""     ,   dense_act_fn="""gelu"""     ,   bos_token_id=1    ).to_dict()
   elif "t5-xxl" in model_name:
      _SCREAMING_SNAKE_CASE  			=					TaConfig.from_pretrained("""google/flan-t5-xxl"""     ,   dense_act_fn="""gelu"""     ,   bos_token_id=1    ).to_dict()

   _SCREAMING_SNAKE_CASE  			=					BlipaConfig(vision_config=SCREAMING_SNAKE_CASE_     ,   text_config=SCREAMING_SNAKE_CASE_    )

   return config, image_size
@torch.no_grad()
def  lowerCAmelCase_						(					SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_=None     ,   SCREAMING_SNAKE_CASE_=False    )  ->  str:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE  			=					(
       AutoTokenizer.from_pretrained("""facebook/opt-2.7b"""    )
       if '''opt''' in model_name
       else AutoTokenizer.from_pretrained("""google/flan-t5-xl"""    )
   )
   _SCREAMING_SNAKE_CASE  			=					tokenizer("""\n"""     ,   add_special_tokens=SCREAMING_SNAKE_CASE_    ).input_ids[0]
   _SCREAMING_SNAKE_CASE  			=					get_blipa_config(SCREAMING_SNAKE_CASE_     ,   eos_token_id=SCREAMING_SNAKE_CASE_    )

   _SCREAMING_SNAKE_CASE  			=					BlipaForConditionalGeneration(SCREAMING_SNAKE_CASE_    ).eval()

   _SCREAMING_SNAKE_CASE  			=					{
       '''blip2-opt-2.7b''': ('''blip2_opt''', '''pretrain_opt2.7b'''),
       '''blip2-opt-6.7b''': ('''blip2_opt''', '''pretrain_opt6.7b'''),
       '''blip2-opt-2.7b-coco''': ('''blip2_opt''', '''caption_coco_opt2.7b'''),
       '''blip2-opt-6.7b-coco''': ('''blip2_opt''', '''caption_coco_opt6.7b'''),
       '''blip2-flan-t5-xl''': ('''blip2_t5''', '''pretrain_flant5xl'''),
       '''blip2-flan-t5-xl-coco''': ('''blip2_t5''', '''caption_coco_flant5xl'''),
       '''blip2-flan-t5-xxl''': ('''blip2_t5''', '''pretrain_flant5xxl'''),
   }

   _SCREAMING_SNAKE_CASE  			=					model_name_to_original[model_name]

   # load original model
   print("""Loading original model..."""    )
   _SCREAMING_SNAKE_CASE  			=					'''cuda''' if torch.cuda.is_available() else '''cpu'''
   _SCREAMING_SNAKE_CASE  			=					load_model_and_preprocess(
       name=SCREAMING_SNAKE_CASE_     ,   model_type=SCREAMING_SNAKE_CASE_     ,   is_eval=SCREAMING_SNAKE_CASE_     ,   device=SCREAMING_SNAKE_CASE_    )
   original_model.eval()
   print("""Done!"""    )

   # update state dict keys
   _SCREAMING_SNAKE_CASE  			=					original_model.state_dict()
   _SCREAMING_SNAKE_CASE  			=					create_rename_keys(SCREAMING_SNAKE_CASE_    )
   for src, dest in rename_keys:
      rename_key(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )

   # some keys can be renamed efficiently
   for key, val in state_dict.copy().items():
      _SCREAMING_SNAKE_CASE  			=					state_dict.pop(SCREAMING_SNAKE_CASE_    )
      if key.startswith("""Qformer.bert"""    ):
         _SCREAMING_SNAKE_CASE  			=					key.replace("""Qformer.bert"""     ,   """qformer"""    )
      if "attention.self" in key:
         _SCREAMING_SNAKE_CASE  			=					key.replace("""self"""     ,   """attention"""    )
      if "opt_proj" in key:
         _SCREAMING_SNAKE_CASE  			=					key.replace("""opt_proj"""     ,   """language_projection"""    )
      if "t5_proj" in key:
         _SCREAMING_SNAKE_CASE  			=					key.replace("""t5_proj"""     ,   """language_projection"""    )
      if key.startswith("""opt"""    ):
         _SCREAMING_SNAKE_CASE  			=					key.replace("""opt"""     ,   """language"""    )
      if key.startswith("""t5"""    ):
         _SCREAMING_SNAKE_CASE  			=					key.replace("""t5"""     ,   """language"""    )
      _SCREAMING_SNAKE_CASE  			=					val

   # read in qv biases
   read_in_q_v_bias(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )

   _SCREAMING_SNAKE_CASE  			=					hf_model.load_state_dict(SCREAMING_SNAKE_CASE_     ,   strict=SCREAMING_SNAKE_CASE_    )
   assert len(SCREAMING_SNAKE_CASE_    ) == 0
   assert unexpected_keys == ["qformer.embeddings.position_ids"]

   _SCREAMING_SNAKE_CASE  			=					load_demo_image()
   _SCREAMING_SNAKE_CASE  			=					vis_processors['''eval'''](SCREAMING_SNAKE_CASE_    ).unsqueeze(0    ).to(SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					tokenizer(["""\n"""]     ,   return_tensors="""pt"""    ).input_ids.to(SCREAMING_SNAKE_CASE_    )

   # create processor
   _SCREAMING_SNAKE_CASE  			=					BlipImageProcessor(
       size={"""height""": image_size, """width""": image_size}     ,   image_mean=SCREAMING_SNAKE_CASE_     ,   image_std=SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					BlipaProcessor(image_processor=SCREAMING_SNAKE_CASE_     ,   tokenizer=SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					processor(images=SCREAMING_SNAKE_CASE_     ,   return_tensors="""pt"""    ).pixel_values.to(SCREAMING_SNAKE_CASE_    )

   # make sure processor creates exact same pixel values
   assert torch.allclose(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    )

   original_model.to(SCREAMING_SNAKE_CASE_    )
   hf_model.to(SCREAMING_SNAKE_CASE_    )
   with torch.no_grad():
      if "opt" in model_name:
         _SCREAMING_SNAKE_CASE  			=					original_model({"""image""": original_pixel_values, """text_input""": [""""""]}    ).logits
         _SCREAMING_SNAKE_CASE  			=					hf_model(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_    ).logits
      else:
         _SCREAMING_SNAKE_CASE  			=					original_model(
             {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}    ).logits
         _SCREAMING_SNAKE_CASE  			=					input_ids.masked_fill(input_ids == tokenizer.pad_token_id     ,   -1_00    )
         _SCREAMING_SNAKE_CASE  			=					hf_model(SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_     ,   labels=SCREAMING_SNAKE_CASE_    ).logits

   assert original_logits.shape == logits.shape
   print("""First values of original logits:"""     ,   original_logits[0, :3, :3]    )
   print("""First values of HF logits:"""     ,   logits[0, :3, :3]    )

   # assert values
   if model_name == "blip2-flan-t5-xl":
      _SCREAMING_SNAKE_CASE  			=					torch.tensor(
          [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]     ,   device=SCREAMING_SNAKE_CASE_    )
      assert torch.allclose(logits[0, :3, :3]     ,   SCREAMING_SNAKE_CASE_     ,   atol=1e-4    )
   elif model_name == "blip2-flan-t5-xl-coco":
      _SCREAMING_SNAKE_CASE  			=					torch.tensor(
          [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]     ,   device=SCREAMING_SNAKE_CASE_    )
   else:
      # cast to same type
      _SCREAMING_SNAKE_CASE  			=					logits.dtype
      assert torch.allclose(original_logits.to(SCREAMING_SNAKE_CASE_    )     ,   SCREAMING_SNAKE_CASE_     ,   atol=1e-2    )
   print("""Looks ok!"""    )

   print("""Generating a caption..."""    )
   _SCREAMING_SNAKE_CASE  			=					''''''
   _SCREAMING_SNAKE_CASE  			=					tokenizer(SCREAMING_SNAKE_CASE_     ,   return_tensors="""pt"""    ).input_ids.to(SCREAMING_SNAKE_CASE_    )

   _SCREAMING_SNAKE_CASE  			=					original_model.generate({"""image""": original_pixel_values}    )
   _SCREAMING_SNAKE_CASE  			=					hf_model.generate(
       SCREAMING_SNAKE_CASE_     ,   SCREAMING_SNAKE_CASE_     ,   do_sample=SCREAMING_SNAKE_CASE_     ,   num_beams=5     ,   max_length=30     ,   min_length=1     ,   top_p=0.9     ,   repetition_penalty=1.0     ,   length_penalty=1.0     ,   temperature=1     ,   )
   print("""Original generation:"""     ,   SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					input_ids.shape[1]
   _SCREAMING_SNAKE_CASE  			=					processor.batch_decode(outputs[:, prompt_length:]     ,   skip_special_tokens=SCREAMING_SNAKE_CASE_    )
   _SCREAMING_SNAKE_CASE  			=					[text.strip() for text in output_text]
   print("""HF generation:"""     ,   SCREAMING_SNAKE_CASE_    )

   if pytorch_dump_folder_path is not None:
      processor.save_pretrained(SCREAMING_SNAKE_CASE_    )
      hf_model.save_pretrained(SCREAMING_SNAKE_CASE_    )

   if push_to_hub:
      processor.push_to_hub(F"nielsr/{model_name}"    )
      hf_model.push_to_hub(F"nielsr/{model_name}"    )


if __name__ == "__main__":
     UpperCamelCase__   :		List[str]											=	argparse.ArgumentParser()
     UpperCamelCase__   :		List[Any]											=	[
         'blip2-opt-2.7b',
         'blip2-opt-6.7b',
         'blip2-opt-2.7b-coco',
         'blip2-opt-6.7b-coco',
         'blip2-flan-t5-xl',
         'blip2-flan-t5-xl-coco',
         'blip2-flan-t5-xxl',
     ]
     parser.add_argument(
         "--model_name",
         default="blip2-opt-2.7b",
         choices=choices,
         type=str,
         help="Path to hf config.json of model to convert",
     )
     parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
     parser.add_argument(
         "--push_to_hub",
         action="store_true",
         help="Whether to push the model and processor to the hub after converting",
     )

     UpperCamelCase__   :		Union[str, Any]											=	parser.parse_args()

     convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











'''simple docstring'''



import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


lowerCAmelCase_  :							int             =    logging.get_logger(__name__)
def        UpperCAmelCase (    A	:					List[Any]       ,		A	:					Optional[int]					):
							SCREAMING_SNAKE_CASE       :   Any         =      nn.functional.normalize(A					)
							SCREAMING_SNAKE_CASE       :   List[str]         =      nn.functional.normalize(A					)
							return torch.mm(A       ,		normalized_text_embeds.t()					)






class 						lowerCamelCase_				(       snake_case_      ):
						_lowerCAmelCase  : Optional[Any]						  =					CLIPConfig

						_lowerCAmelCase  : List[str]						  =					['CLIPEncoderLayer']







						def __init__(	self :   int					,     lowerCAmelCase__ :   CLIPConfig					):

													"""simple docstring"""
													super().__init__(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Any         =      CLIPVisionModel(config.vision_config					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      nn.Linear(config.vision_config.hidden_size					,     config.projection_dim					,     bias=lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Any         =      nn.Parameter(torch.ones(17					,     config.projection_dim					)					,     requires_grad=lowerCAmelCase__					)
													SCREAMING_SNAKE_CASE       :   int         =      nn.Parameter(torch.ones(3					,     config.projection_dim					)					,     requires_grad=lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Dict         =      nn.Parameter(torch.ones(17					)					,     requires_grad=lowerCAmelCase__					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      nn.Parameter(torch.ones(3					)					,     requires_grad=lowerCAmelCase__					)







						@torch.no_grad()
						def        __lowercase     (	self :   List[str]					,     lowerCAmelCase__ :   List[str]					,     lowerCAmelCase__ :   Optional[Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Any         =      self.vision_model(lowerCAmelCase__					)[1]  # pooled_output
													SCREAMING_SNAKE_CASE       :   Any         =      self.visual_projection(lowerCAmelCase__					)

													# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      cosine_distance(lowerCAmelCase__					,     self.special_care_embeds					).cpu().float().numpy()
													SCREAMING_SNAKE_CASE       :   List[str]         =      cosine_distance(lowerCAmelCase__					,     self.concept_embeds					).cpu().float().numpy()

													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      []
													SCREAMING_SNAKE_CASE       :   int         =      image_embeds.shape[0]
													for i in range(lowerCAmelCase__					):
																				SCREAMING_SNAKE_CASE       :   Any         =      {'''special_scores''': {}, '''special_care''': [], '''concept_scores''': {}, '''bad_concepts''': []}

																				# increase this value to create a stronger `nfsw` filter
																				# at the cost of increasing the possibility of filtering benign images
																				SCREAMING_SNAKE_CASE       :   int         =      0.0

																				for concept_idx in range(len(special_cos_dist[0]					)					):
																											SCREAMING_SNAKE_CASE       :   Optional[int]         =      special_cos_dist[i][concept_idx]
																											SCREAMING_SNAKE_CASE       :   int         =      self.special_care_embeds_weights[concept_idx].item()
																											SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      round(concept_cos - concept_threshold + adjustment					,     3					)
																											if result_img["special_scores"][concept_idx] > 0:
																																		result_img["special_care"].append({concept_idx, result_img['''special_scores'''][concept_idx]}					)
																																		SCREAMING_SNAKE_CASE       :   Tuple         =      0.01

																				for concept_idx in range(len(cos_dist[0]					)					):
																											SCREAMING_SNAKE_CASE       :   Optional[Any]         =      cos_dist[i][concept_idx]
																											SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      self.concept_embeds_weights[concept_idx].item()
																											SCREAMING_SNAKE_CASE       :   Dict         =      round(concept_cos - concept_threshold + adjustment					,     3					)
																											if result_img["concept_scores"][concept_idx] > 0:
																																		result_img["bad_concepts"].append(lowerCAmelCase__					)

																				result.append(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Dict         =      [len(res['''bad_concepts''']					) > 0 for res in result]

													return images, has_nsfw_concepts







						@torch.no_grad()
						def        __lowercase     (	self :   List[str]					,     lowerCAmelCase__ :   torch.FloatTensor					,     lowerCAmelCase__ :   torch.FloatTensor					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      self.vision_model(lowerCAmelCase__					)[1]  # pooled_output
													SCREAMING_SNAKE_CASE       :   List[Any]         =      self.visual_projection(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   List[str]         =      cosine_distance(lowerCAmelCase__					,     self.special_care_embeds					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      cosine_distance(lowerCAmelCase__					,     self.concept_embeds					)

													# increase this value to create a stronger `nsfw` filter
													# at the cost of increasing the possibility of filtering benign images
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      0.0

													SCREAMING_SNAKE_CASE       :   Any         =      special_cos_dist - self.special_care_embeds_weights + adjustment
													# special_scores = special_scores.round(decimals=3)
													SCREAMING_SNAKE_CASE       :   List[Any]         =      torch.any(special_scores > 0					,     dim=1					)
													SCREAMING_SNAKE_CASE       :   Dict         =      special_care * 0.01
													SCREAMING_SNAKE_CASE       :   List[str]         =      special_adjustment.unsqueeze(1					).expand(-1					,     cos_dist.shape[1]					)

													SCREAMING_SNAKE_CASE       :   Optional[int]         =      (cos_dist - self.concept_embeds_weights) + special_adjustment
													# concept_scores = concept_scores.round(decimals=3)
													SCREAMING_SNAKE_CASE       :   Any         =      torch.any(concept_scores > 0					,     dim=1					)

													return images, has_nsfw_concepts




