Regarding the value for adjusting the filtering strength of safety_checker. #9068

[suzukimain]

Hello.
I am currently looking for the best adjustment value for the filtering strength of safety_checker, Could you please advise me?
Related to #9068

Currently, I have gotten as far as getting the image concept_scores, etc., but am wondering what to do after that.

import os
import torch
import numpy as np
from PIL import Image

from diffusers import StableDiffusionPipeline
from diffusers.pipelines.stable_diffusion.safety_checker import cosine_distance

class parameter_set:
    def __init__(self):
        self.pipe = StableDiffusionPipeline.from_pretrained(
            "Lykon/dreamshaper-8",
            torch_dtype=torch.float16
        ).to("cuda" if torch.cuda.is_available() else "cpu")

    def run(self,img):
        converted = self.convert_img(img)
        a_list = self.get_arg(converted)
        return self.calculation(a_list[0])

    def convert_img(self,img):
        if isinstance(img,str):
            if os.path.isfile(img):
                return np.array(Image.open(img))
            else:
                raise TypeError(img)
        elif isinstance(img,Image.Image):
            return np.array(img)
        elif isinstance(img,np.ndarray):
            return img
        else:
            raise TypeError(img)

    @torch.no_grad()
    def get_arg(self,image):
        dtype = self.pipe.dtype
        if torch.is_tensor(image):
            feature_extractor_input = self.pipe.image_processor.postprocess(image, output_type="pil")
        else:
            feature_extractor_input = self.pipe.image_processor.numpy_to_pil(image)
        safety_checker_input = self.pipe.feature_extractor(feature_extractor_input, return_tensors="pt").to(self.pipe.device)
        _result = self._check(
                clip_input=safety_checker_input.pixel_values.to(dtype)
            )
        return _result

    @torch.no_grad()
    def _check(self, clip_input):
        pooled_output = self.pipe.safety_checker.vision_model(clip_input)[1]  # pooled_output
        image_embeds = self.pipe.safety_checker.visual_projection(pooled_output)

        special_cos_dist = cosine_distance(image_embeds, self.pipe.safety_checker.special_care_embeds).cpu().float().numpy()
        cos_dist = cosine_distance(image_embeds, self.pipe.safety_checker.concept_embeds).cpu().float().numpy()

        result = []
        batch_size = image_embeds.shape[0]
        for i in range(batch_size):
            result_img = {"special_scores": {}, "special_care": [], "concept_scores": {}}
            adjustment = 0.0
            for concept_idx in range(len(special_cos_dist[0])):
                concept_cos = special_cos_dist[i][concept_idx]
                concept_threshold = self.pipe.safety_checker.special_care_embeds_weights[concept_idx].item()
                result_img["special_scores"][concept_idx] = 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]})
                    adjustment = 0.01

            for concept_idx in range(len(cos_dist[0])):
                concept_cos = cos_dist[i][concept_idx]
                concept_threshold = self.pipe.safety_checker.concept_embeds_weights[concept_idx].item()
                result_img["concept_scores"][concept_idx] = round(concept_cos - concept_threshold + adjustment, 3)
            result.append(result_img["concept_scores"])
        return result

        
    def calculation(self,dict_obj):
        if not dict_obj:
            return {
                'max': 0,
                'min': 0,
                'median': 0,
                'average': 0,
                'all': dict_obj
            }
        else:
            values = list(dict_obj.values())
            values.sort()
            return {
                'max': round(max(values), 10),
                'min': round(min(values), 10),
                'median': round(values[len(values) // 2], 10),
                'average': round(sum(values) / len(values), 10),
                'all': dict_obj
            }
            
if __name__ == '__main__':
    par_cls = parameter_set()
    print(par_cls.run(<img>))

[suzukimain]

As a side note, I originally planned to use the concept score of the image generated using multiple models to determine the value.

[asomoza]

cc: @yiyixuxu who can help here?

[suzukimain]

Hello.
Is there anyone who can help me?
I still can't solve this problem by myself.